# coding:utf8
坚守“ 做人真诚 · 做事靠谱 · 口碑至上 · 高效敬业 ”的价值观，专业网站建设服务10余年为成都成都除甲醛小微创业公司专业提供成都定制网页设计营销网站建设商城网站建设手机网站建设小程序网站建设网站改版，从内容策划、视觉设计、底层架构、网页布局、功能开发迭代于一体的高端网站建设服务。
import rule, config
import random, time, os
class Card(object):
"""docstring for Univalse"""
def __init__(self):
# 牌面对应点数(A代表14)
self.points = {'2':2, '3':3, '4':4, '5':5, '6':6, '7':7, '8':8, '9':9, '10':10, 'J':11, 'Q':12, 'K':13, 'A':14}
# 一副52张牌(去大小王)
self.cards = {1:'黑桃A', 2:'黑桃2', 3:'黑桃3', 4:'黑桃4', 5:'黑桃5', 6:'黑桃6', 7:'黑桃7', 8:'黑桃8', 9:'黑桃9',10:'黑桃10',11:'黑桃J',12:'黑桃Q',13:'黑桃K'
,14:'红桃A',15:'红桃2',16:'红桃3',17:'红桃4',18:'红桃5',19:'红桃6',20:'红桃7',21:'红桃8',22:'红桃9',23:'红桃10',24:'红桃J',25:'红桃Q',26:'红桃K'
,27:'梅花A',28:'梅花2',29:'梅花3',30:'梅花4',31:'梅花5',32:'梅花6',33:'梅花7',34:'梅花8',35:'梅花9',36:'梅花10',37:'梅花J',38:'梅花Q',39:'梅花K'
,40:'方块A',41:'方块2',42:'方块3',43:'方块4',44:'方块5',45:'方块6',46:'方块7',47:'方块8',48:'方块9',49:'方块10',50:'方块J',51:'方块Q',52:'方块K'}
self.keys = list(self.cards.keys()) # 列表化Cards字典key，便于处理
self.newkeys = [] # 洗过牌后的cards.key的新顺序
# 按牌面返回点数
def retPoint(self, card):
return self.points[card[6:]] # 牌对应的点数,切片时注意汉字的len
# 洗牌
def shuffle(self):
random.shuffle(self.keys) # 打乱key的顺序，尽量随机化
# 切牌
def cutCard(self):
startKey = random.randint(0,51) # 从52张牌数中随机一个数(为什么不是1-52,是因为要从list中取对应数)
self.newkeys = self.keys[startKey:]+self.keys[0:startKey] # 从第startKey开始腰牌
# 发牌
def perflop(self):
card1 = self.cards[self.newkeys[0]] # 第一张牌
card2 = self.cards[self.newkeys[1]] # 第二张牌
card3 = self.cards[self.newkeys[2]] # 第三张牌
point1 = self.retPoint(card1) # 第一张牌点数
point2 = self.retPoint(card2) # 第二张牌点数
point3 = self.retPoint(card3) # 第三张牌点数
# 先亮出点数小的牌,后亮出点数大的牌
if point1 point2:
return [card2,card1,point2,point1,point1-point2-1,card3,point3]
else:
return [card1,card2,point1,point2,point2-point1-1,card3,point3]
class Banker(object):
"""docstring for Banker"""
def __init__(self):
self.card = Card()
self.getCards=[]
self.money = Money()
# 开局准备
def ready(self):
print '庄家: 准备开局,请各位玩家准备进入!'
print '庄家: 下注规则:各位玩家投注金额需是$5的倍数(如,$5/$50/$100等),多少我都能赔起!'
# 开局
def start(self):
self.card.shuffle()
self.card.cutCard()
self.getCards = self.card.perflop()
print '庄家: 前两张开牌: %s %s' % (self.getCards[0], self.getCards[1])
span = self.getCards[4] # 跨度
if span == 0: # 点数相连
print '庄家: 两张牌点数相连,平局!'
return False # 直接准备下一局
else:
if span 0: # 点数不相连
print '庄家: 跨度: %d' % span
return True # 交给第三张牌的处理
else: # 一对
print '庄家: 两张一对,停止加注!'
return False # 直接交给第三张牌的处理
# 第三张牌
def thirdCard(self):
card3 = self.getCards[5]
point3 = self.getCards[6]
span = self.getCards[4] # 跨度
if span == 0: # 点数相连
print '系统: 玩家余额 $%d' % self.money.jin(self.money.zongjiazhu())
pass
else:
print '庄家: 第三张开牌: %s' % card3
zongzhue = self.money.zongjiazhu() # 总下注金额
if span 0: # 点数不相连
if point3 = self.getCards[2] or point3 = self.getCards[3]:
print '系统: 抱歉!这局庄家赢!'
print '系统: 玩家余额 $%d' % self.money.chu()
elif point3 self.getCards[2] or point3 self.getCards[3]:
print '系统: 恭喜玩家!',
if span == 1:
print '赢得5:1的赔率金额: $%d!' % (zongzhue * 6)
print '系统: 玩家余额 $%d' % self.money.jin(zongzhue * 6) # 跨度1,5倍赔率+1倍总下注金额
elif span == 2:
print '赢得4:1的赔率金额: $%d!' % (zongzhue * 5)
print '系统: 玩家余额 $%d' % self.money.jin(zongzhue * 5) # 跨度2,4倍赔率+1倍总下注金额
elif span == 3:
print '赢得2:1的赔率金额: $%d!' % (zongzhue * 3)
print '系统: 玩家余额 $%d' % self.money.jin(zongzhue * 3) # 跨度3,2倍赔率+1倍总下注金额
else:
print '赢得1:1的赔率金额: $%d!' % (zongzhue * 2) # 加上括号,防止被认为是把前面的文字打印2遍
print '系统: 玩家余额 $%d' % self.money.jin(zongzhue * 2) # 其余跨度,5倍赔率+1倍总下注金额
else:
pass
else: # 一对 span 0
if point3 == self.getCards[2]:
print '系统: 恭喜玩家!赢得11:1的赔率金额: $%d!' % zongzhue * 12
print '系统: 玩家余额 $%d' % self.money.jin(zongzhue * 12) # 11倍赔率,加上之前的总下注,即为总下注的12倍
else:
print '系统: 第三张牌点数不同,平局!'
print '系统: 玩家余额 $%d' % self.money.jin(zongzhue)
self.end()
# 结束
def end(self):
print '系统: 玩家总下注金额清零 $%d' % self.money.zongjiazhu(-(self.money.zongjiazhu())) # 总下注额清零(10-10)
print '系统: 请等待下一局开局.'
print '--------------------------------------------------------------------------------'
time.sleep(1)
class Player(object):
"""docstring for Player"""
def __init__(self):
self.card = Card()
self.money = Money()
def joinGame(self):
while True:
comd = raw_input('系统: 是否加入这局(y/n,回车默认y,5秒后默认n,退出输入q)?: ')
if comd == 'y' or comd == '':
balance = self.money.chkBalance()
if balance == 0:
print '系统: 抱歉!您的余额为$0,无法下注,正在退出游戏!'
print '系统: 请修改money文件中余额数量后,再进入游戏!'
return 'q'
else:
print '系统: 玩家余额 $%d' % balance
print '系统: 玩家总下注金额 $%d' % self.money.zongjiazhu() # 总下注金额已清零
time.sleep(0.5)
return True
elif comd == 'n':
print '玩家: 我不想加入这局!'
return False
elif comd == 'q':
print '系统: 玩家退出游戏!'
return 'q'
else:
print '系统: 命令错误,只能输入字母y或n或q或直接回车!'
time.sleep(0.5)
continue
# 直接回车或输入的是0,放弃此局 / 放弃加注
def giveUp(self, input):
if input == '' or input == '0':
return True
# 下注
def bet(self):
while True:
firstBet = raw_input('系统: 各位玩家请请下注(需是$%s的倍数,PASS请直接回车!): ' % self.money.base)
# 放弃此局
if self.giveUp(firstBet):
print '玩家: PASS!'
time.sleep(0.5)
return False
# 检查输入的金额
input = self.money.chkInput(firstBet)
if input == 'lack':
continue
elif input == 'beyond':
continue
elif input:
print '玩家: 下注 $%s' % firstBet
print '系统: 玩家余额 $%d' % self.money.chu(int(firstBet))
print '系统: 玩家总下注金额 $%d' % self.money.zongjiazhu(int(firstBet))
time.sleep(0.5)
return True
else:
continue
# 加注(再下注)
def againBet(self):
while True:
secondBet = raw_input('系统: 各位玩家请加注(需是$%s的倍数,STAND请直接回车!): ' % self.money.base)
# 放弃加注
if self.giveUp(secondBet):
print '玩家: STAND!'
print '系统: 玩家余额 $%d' % self.money.chkBalance()
print '系统: 玩家总下注金额 $%d' % self.money.zongjiazhu()
time.sleep(0.5)
return True # 放弃加注也开第三张
# 检查输入的金额
againInput = self.money.chkInput(secondBet)
if againInput == 'lack':
continue
elif againInput == 'beyond':
continue
elif againInput:
print '玩家: 加注 $%s' % secondBet
print '系统: 玩家余额 $%d' % self.money.chu(int(secondBet))
print '系统: 玩家总下注金额 $%d' % self.money.zongjiazhu(int(secondBet))
time.sleep(0.5)
return True
else:
continue
class Money(object):
"""docstring for Money"""
def __init__(self):
self.base = config.base # 下注金额基数
self.rwFile = RWFile()
# 数钱出账
def chu(self, money=0):
lose = self.rwFile.readFile(self.rwFile.moneyFilePath)-money
self.rwFile.writeFile(self.rwFile.moneyFilePath, lose)
return lose
# 赢钱进账
def jin(self, money=0):
win = self.rwFile.readFile(self.rwFile.moneyFilePath)+money
self.rwFile.writeFile(self.rwFile.moneyFilePath, win)
return win
# 总下注金额
def zongjiazhu(self, money=0):
zongzhue = self.rwFile.readFile(self.rwFile.amountFilePath)+money
self.rwFile.writeFile(self.rwFile.amountFilePath, zongzhue)
return zongzhue
# 检查输入的金额
def chkInput(self, number):
if number.isdigit(): # 数字
if self.chkBalance() == 0:
print '提醒: 您当前余额为$0,无法加注!' # 此处是"加注",为什么不是"下注"?,因为玩家加入游戏后就对玩家余额进行检查,如果是$0,则直接提示无法继续游戏,要求退出!都不给下注的机会,故不会存在余额为$0的情况下还可以下注的,但可以加注,因为第一次下注时全下了!
time.sleep(0.5)
return 'lack'
elif int(number) = self.chkBalance(): # 输入的金额在玩家余额之内
if int(number) % self.base == 0: # 输入的金额是base的倍数
return True
else:
print '提醒: 输入的金额必须是$%s的倍数,请重新输入!' % self.base
time.sleep(0.5)
return False
else:
print '提醒: 输入的金额$%s已超出您当前余额$%d,请重新输入!' % (number,self.chkBalance())
time.sleep(0.5)
return 'beyond'
else:
print '提醒: 抱歉,你输入的不是金额数字,请重新输入!'
time.sleep(0.5)
return False
# 查询余额
def chkBalance(self):
balance = self.rwFile.readFile(self.rwFile.moneyFilePath)
return balance
class RWFile(object):
"""读写金钱和总下注金额文本文件"""
def __init__(self):
self.moneyFilePath = 'money.txt' # 必须utf8格式的txt文本
self.amountFilePath = 'amount.txt' # 必须utf8格式的txt文本
# 读(返回读到的数)
def readFile(self, filePath):
f = open(filePath,'r')
money = f.read()
if money == '' and not money.isdigit():
print '存储玩家金钱的文件: "%s" 的内容不是一个金额数字,系统已恢复成初始值!'
money = config.money # 恢复为config中的money数
f.close
return int(money)
# 写
def writeFile(self, filePath, money = 0):
f = open(filePath,'w')
f.write(str(money))
f.close()
# 检查配置文件,money文件,amount文件
def chkFile(self):
# 检查配置文件
if not str(config.base).isdigit() or not str(config.money).isdigit():
print '配置文件config.py不正确!必须是数字,且其中前后无空格!'
return False
# money文件是否存在
if not os.path.isfile(self.moneyFilePath) or not os.path.isfile(self.amountFilePath):
f1 = open(self.moneyFilePath,'w')
f1.write(config.money)
f1.close()
f2 = open(self.amountFilePath,'w')
f2.write('0')
f2.close()
return True
return True
def main():
# 显示游戏规则
print rule.gameRule
# a=[]
# for i in range(2,15):
# a.append(i)
# print a
banker = Banker()
player = Player()
rwFile = RWFile()
if not rwFile.chkFile():
return
while True:
banker.ready() # 庄家准备
playComd = player.joinGame() # 系统提示玩家是否加入这局
if playComd == 'q':
break
elif playComd:
# 加入
if player.bet(): # 玩家下注
# 下注
if banker.start(): # 庄家开局,发前两张牌
if player.againBet(): # 玩家加注
banker.thirdCard() # 庄家发第三张牌
else:
banker.thirdCard() # 庄家发第三张牌
else:
# 没下注
banker.end() # 庄家结束这局
else:
# PASS
banker.end() # 庄家结束这局
continue
if __name__ == '__main__':
main()
运行结果
--------------------------------------------------------------------------------
庄家: 准备开局,请各位玩家准备进入!
庄家: 下注规则:各位玩家投注金额需是$5的倍数(如,$5/$50/$100等),多少我都能赔起!
系统: 是否加入这局(y/n,回车默认y,5秒后默认n,退出输入q)?:
系统: 玩家余额 $18705
系统: 玩家总下注金额 $0
系统: 各位玩家请请下注(需是$5的倍数,PASS请直接回车!): 55
玩家: 下注 $55
系统: 玩家余额 $18650
系统: 玩家总下注金额 $55
庄家: 前两张开牌: 梅花J 红桃A
庄家: 跨度: 2
系统: 各位玩家请加注(需是$5的倍数,STAND请直接回车!): 55
玩家: 加注 $55
系统: 玩家余额 $18595
系统: 玩家总下注金额 $110
庄家: 第三张开牌: 方块9
系统: 抱歉!这局庄家赢!
系统: 玩家余额 $18595
系统: 玩家总下注金额清零 $0
系统: 请等待下一局开局.
--------------------------------------------------------------------------------
庄家: 准备开局,请各位玩家准备进入!
庄家: 下注规则:各位玩家投注金额需是$5的倍数(如,$5/$50/$100等),多少我都能赔起!
系统: 是否加入这局(y/n,回车默认y,5秒后默认n,退出输入q)?: q
系统: 玩家退出游戏!
意思是：贝它；希腊字母的第二个字母。
英［＇bi：tə］
释义：
n.β（希腊字母表的第二个字母）；β项，β类；β等，乙等；β星；β衰变的，β粒子的；β系数，β因素
n.（Beta）（罗马尼亚、波兰、美、印度）布蕾塔（人名）
［复数：betas］
短语：
beta function贝塔函数；贝他函数；Beta函数
扩展资料：
临近单词：bet
英［bet］
释义：
v.打赌；与（某人）以钱打赌；（非正式）敢说
n.打赌；赌注；（非正式）有可能成功的人选（或备选行动）
abbr.在……中间；往返于；合用；夹在两物之间的空间中；在期间（between）
n.（Bet）（美）贝特（人名）
［复数：bets；第三人称单数：bets；现在分词：betting；过去式：bet或betted；过去分词：bet或betted］
短语：
Best Bet迎妻接福；最好的措施；最佳选择
一.前言
注：因为复制的时候太激动了,所以本文的转载无法经过夏克的同意,这里说声对不住了,希望有人能给个地址,大家上他那去看看！本文在原文的基础上面稍微扩充了RGSS2的知识,但是不多,很多地方都修改了,希望希望夏克同学原谅我,因为我实在没办法联系到你.那么,请各位看官阅览本文过后,仔细看看RPG Maker自带的帮助,虽然说是帮助,但是那个也是很好的教材哦!
二.基本概念
1.什么是RGSS/RGSS 2?
Ruby Game Scripting System(以下简称RGSS),中文意思就是：Ruby游戏脚本系统,是一个脚本性质的游戏编程系统,并不是整个游戏都用它来生成,RGSS所能做的只是一些有限的功能,而这些功能,是由厂家也就是EnterBrain所规定的,我们只能在自己力所能及的范围内来挖掘RGSS的潜力,RGSS 2则是在RGSS的基础上扩充和删减了一部分形成的,也可以称之为RGSS的换代版本,是RMVX所使用的
2.脚本（Script）:
脚本这个概念应用的范围很广,Windows系统里就有VBScript,JavaScript,WScript等脚本程序,Unix系统也有很多Perl,C等脚本程序,脚本可以解释为是一种系统内用来实现一些特定功能的有着局限性的编程环境.有的脚本可以触及到系统底层,有的却只是完成一些运算或者控制流程的功能,这取决于脚本系统的权限,也可以说取决于脚本系统所提供的库函数功能.
3.RGSS/RGSS2中的脚本：
在RPG Maker XP/RPG Maker VX(以下简称RMXP/RMVX)中,按F11就可以打开[脚本编辑器],不过RM2003或更早的版本却没有这个功能,左边的窗口是脚本列表,右边的窗口是脚本内容,左下角可以修改脚本名称.
在RMXP/RMVX中,游戏开始运行后,总是从最上边的脚本开始运行,依次往下,所以,经常把变量声明、类声明、函数声明、函数定义的脚本放在上面,而MAIN脚本总是放在最后.
三.开始神奇的脚本学习旅程
1.Hello,World!
经过上面的基本知识后,相信你对RGSS/RGSS2的相关知识有了一定了解,一般的编程语言教程都是从"Hello,World!"开始的,那好,我们也从"Hello,World!"开始,不过为了体现RGSS语言与Ruby的不同,我们将其改为"Hello,World,我来学习RGSS语言了!",首先,请打开RMXP/RMVX,在新建好一个空白工程后,按下键盘上面的"F11"键,开始我们的RGSS/RGSS2脚本学习之旅!为了保证执行脚本的快速,请在脚本列表中选中最顶端的那个脚本,然后按下方向键上面的Delete(也称为DEL、删除)键,删除脚本直到Main脚本为止(这里的意思是只保留Main脚本),选择[插入]来插入一个新的脚本,给新脚本命名为Test,删除Main脚本,点[确定].这样我们就得到了一个空的脚本系统,试着运行一下游戏,可以看到游戏在短暂的启动后就自动终止了,这表明没有任何脚本可以执行,游戏只好退出.既然测试成功了,那么下面我们在Test脚本中加入一些内容.按F11打开[脚本编辑器],因为我们只有Test一个空脚本,所以在Test的内容中输入下面的代码：
p "Hello,World,我来学习RGSS语言了!"
把这行代码复制并粘贴在Test脚本中,按[确定],按F12,保存后游戏开始运行,短暂停顿后就会弹出一个对话框,内容是不是："Hello,World!"?这样我们就做出了第一个脚本,如果是学过Ruby的你一定会发现中文会被正常的输出,而不是类似于"/数字/"的结果,但是这里要说的是,RGSS不支持puts命令,而printf命令则会忽略掉,如果您实在怀恋,可以通过其他的脚本来辅助实现.值得说一下的是,RGSS是会区分大小的,所以这里的p不能使用P(大写的P).
2.脚本的注释
在学习任何语言的过程中,注释是少不了的,因为注释不仅仅可以让新手更明白脚本语句的含义,而且还会使脚本看起来更整洁、美观,当然,能做到的当然还有很多.在RGSS中,有两种注释,它们分别是符号 # 和
=begin
=end
如果你比较细心的话应该可以看出他们的用途, 符号#是用来注释单行,而 =begin ... =end 是用来注释多行的,在这里,有个知识点需要提一下,符号#后的脚本是会被忽略的,也就是说,你把符号#插入到某一脚本的前面,那么那条脚本就会无效,很多人都将在脚本前添加#看做是一种解决脚本故障的办法(也就是DEBUG),举个例子:
p "Hello,World,我来学习RGSS语言了!" #我是很可爱的注释,执行脚本的时候你会无视我!
将这段代码插入到脚本中,#后面的语句或者注释将被无视,然而在这段代码中,无论是什么都会无效.
=begin
p "Hello,World,我来学习RGSS语言了!" #我是很可爱的注释,执行脚本的时候你会无视我!
=end
到此,基础部分完毕,如果你想要学习更深入的知识,请往下看.
四.数据类型
1.数字
数字包括整数和小数,小数在计算机术语中被称为浮点数,相信大家都明白什么是整数和小数了.整数包括正整数和负整数,0可以被视为整数,数字属于常量的一部分.
常见的数字种类有：
1 = 整数
100 = 整数
-10 = 整数
0 = 整数
0.11 = 浮点数
-12.3 = 浮点数
那好,让我们写一个脚本来学习如何显示一个常量的值,在Test脚本中,清除脚本内容,插入下面的代码：
p 100
运行游戏,看到弹出的对话框显示："100",若输入我们输入:
p 100.100
作为新手的你觉得会弹出什么呢,想想,实际上弹出的是100.1,而不是100.100
2.数字的计算
我们在上节讲了数字的类型与输出给用户的方法,现在我们来体验一下数字的计算,在脚本 TEST 中插入以下代码:
p 1+1
运行游戏,看到弹出的对话框显示：2.这就是常量的加法.你可以很聪明地想象出乘法、除法、减法：
p 3+5
p 3*5
p 3/5
p 3-5
运行游戏,你会发现游戏按脚本顺序输出了加、乘、除、减,你会发现,3/5输出的是0而不是正确结果,整数和整数的运算,其结果仍旧表现为整数,如果你希望得到浮点数,那么就应该使被除数或者除数至少有一个是小数形式的表示.请看下面的代码:
p 3.0/5
p 3/5.0
运行游戏,显示的结果就都是小数了.值得一提的是还有两个很有用的算符,求余数(%)和乘方(**),输入以下代码:
p 14%4
p 2**3
它们分别输出了2与8,和预期的正确结果一样.
3.括号的用处
各种运算符之间总会存在优先顺序,加减乘除的顺序是不变的,对于其它你所不熟悉的或者弄不清除的,只要记住一点就可以了,那就是括号的优先权是最高的,善用括号能够至少确保程序的准确性而先不管是不是很难看,当然,强大的RGSS所使用的基本不是只有一个功能,或考得其他功能我们会在以后的章节一一阐述.
4. 常量与变量
常量：常量就是我们经常会用的数字、字符串了,比如我们问一张光盘多少钱,回答说5元,那么5就是常量,如果说一张光盘的价格不定,在3-5元的范围内浮动,那么这就是我们学过的未知数,对于这样的未知数我们经常会用一个变量来表示.
变量：变量就是我们用一个符号来表示一个我们想要表示的概念,比如我们可以用price这个变量来表示一张光盘的价格.变量与常量的区别就在变量是可以变动的,也就是说我们用变量来定义一个概念后,接下来就会来操作这个变量使它变化.而我们不能让一个常量变化,比如我们不能让5=4,但我们可以让price=4.
命名规则: 变量的取名有以下的限制：
1、必须以英文字母（大小写均可）、汉字、下划线开头.
2、第二个字符开始可以使用数字、英文字母、汉字、下划线.
3、不能使用保留字作变量的名字.
保留字是保留给系统用的,也就是说系统已经占用了,以下是系统的保留字：
alias def false nil return unless
and do for not self until
begin else if or super when
break elsif in redo then while
case end module rescue true yield
class ensure next retry undef
所以不要使用上面列出的单词做你的变量的名字.
变量的赋值：变量无需事先声明,可以拿来就用,例如:
a=100
p a
运行脚本,看到弹出的对话框显示：100 , 但必须先赋值才可以使用变量,否则,试试下面的代码：
p b
会弹出什么呢,如果不赋值给变量,就相当于这个变量不存在,而一旦赋值给它,就表明这个变量存在了.
变量的运算：
下面的代码你应该可以猜出是什么结果的：
战斗前的体力=234
战斗后的体力=200
p 战斗前的体力
p 战斗后的体力
继续：
p 战斗前的体力-战斗后的体力
看到了吗,这里我进行了运算,变量的运算.
就像对于常量一样,加减乘除和括号同样适用于变量的运算：
x=1
y=2
z=3
p x+(y*z)/(y+z)-y+z
但下面的运算是常量所没有的：
自运算：
x+=5
y*=2
z/=3
p x
p y
p z
+=,-=,*=,/=这四个运算符是自运算符,x+=1相当于x=x+1,其它同理.
全局变量：
局部变量和全局变量的区别在于局部变量只能被所在的脚本访问,而全局变量能被所有的脚本访问.
在变量名前加$符号就可以声明全局变量了.
5. 字符串
显示字符串：
先看看下面这几行语句在RGSS中的效果：
p"这将会显示双引号"
p'这也会显示双引号'
print"这不会显示双引号"
print'这也不会显示双引号'
把上面的四行语句复制下来,然后在我们刚刚建立好的Test脚本中粘贴,粘贴前最好把Test脚本的内容清除掉,我们只需要测试我们现在的代码.好,运行游戏,看看效果吧.
首先,看得出来,用来输出显示的方法又多了一种：print,不同的是,p可以显示很多种数据类型,对不同的数据类型,它会按人们容易理解
的格式来显示,比如说这里的字符串,它都会加上双引号来告诉人们：这次显示的是字符串,而print直接显示字符串本身.
在上面的代码中,分别输出下面的四行字符串：
"这将会显示双引号"
"这也会显示双引号"
这不会显示双引号
这也不会显示双引号
6.字符串常量：
字符串常量的表示有两种方法.
1.双引号表示的字符串：
这种表示方法使得字符串可以支持一些特殊格式,这将是我们用的最多的表示方法,下面会有更详细的介绍.
2.单引号表示的字符串：
直白的说,单引号所包括的字符串会被原样显示出来,也就是说,即使单引号中包含特殊格式,也不会显示这种特殊格式.
7.字符串变量：
和数字变量一样,看看例子吧：
1、赋值：
a="欢迎使用RGSS来编程"
print a
结果输出：欢迎使用RGSS来编程
2、连接：
a="中华人民"
b="共和国"
print a+b
结果输出：中华人民共和国
3、乘法：
a="连续两遍"
print a*2
结果输出：连续两遍连续两遍
4、换行符：
\n表示换行,但是只能用在双引号字符串内,若是在单引号字符串内便不起作用了,看看下面两个例子：
a='中华人民\n共和国'
b="中华人民\n共和国"
print a
print b
结果输出：
中华人民\n共和国
中华人民
共和国
5、常量中包含变量：
a="人民"
print "中华#共和国"
结果输出：中华人民共和国
记住：这个特殊格式和\n一样只能在双引号形式的字符串中使用,这里提一下,这里的#符号不是注释的意思.
再看一个：
a="C:\\Program Files\\RPG Maker XP\\System\\Data\\Skills.rxdata"
print "系统安装后的初始脚本文件是：#"
你可以试试看下面的例子：
a="人民"
print '中华#共和国'
结果输出：中华#共和国
五. 控制语句
1. 条件分歧语句
1.比较运算符：
有6个比较运算符,分别是
== 相等
!= 不相等
小
大
= 小或相等
= 大或相等
比较运算符,顾名思义,就是用来比较的,比较的对象可以是任意的,比较的结果是True或者False.
举例：
p(" 早安 "==" 早安 ") # = true
p(" 早安 "==" 晚安 ") # = false
p (3 + 1 == 3 + 5) # = false
p (3 + 1 == 2 + 2) # = true
观察一下结果就会明白.
逻辑运算符：
逻辑运算符也有6个,分别是：
与：and ,
或：or , ||
非：not , !
举例：
p (100 77 and 1 + 1 == 2) # = true
p (100 77 1 + 1 == 2) # = true
if..elseif..else..end 语句：
结构：
if 条件1
语句1
elseif 条件2
语句2
.
.
else
语句
end
举例：
x=123
y=23
z=67
a=(x*y*z+x/y+z/y)*(y-z)+x*z
if a0
print "大于0"
elseif a=0
print "等于0"
else
print "小于0"
end
最常用的还是if...end语句：
金钱数=10
if 金钱数100
print "对不起,你的钱不够了.."
end
unless..end 语句：
这是if..end语句的变种,正好跟if..end相反,就是除非的意思：
unless 条件
语句
end
举例：
金钱数=10
unless 金钱数=100
print "对不起,你的钱不够了.."
end
除非你的金钱数大于等于100,否则：“对不起,你的钱不够了..”
case..when..end 语句：
如果对于把条件限制在某个范围或者某些特定的值的情况,使用case..end语句更方便：
case 变量
when 特定的值或者范围
when 特定的值或者范围
.
.
end
举例：
主角状态="昏睡"
case 主角状态
when "昏迷"
print "你昏迷了.."
when "中毒"
print "你中毒了.."
when "昏睡"
print "你昏睡了.."
end
2.条件赋值语句：
条件赋值语句给我们提供了一个非常方便的if..else..end的简化版.
(条件1 ? 语句1 : 语句2)
相当于：
if 条件1
语句1
else
语句2
end
举例：
战斗状态=1
print (战斗状态0 ? "胜利" : "失败")
2.循环
1.while..end 循环：
举例：
a = 0
i = 1
while i = 5
a += i
i += 1
end
p a
这很简单,很容易明白的.
2.for..in..end 循环：
类似于c语言中的for,但不同,in后面给出变量的变化范围.
3变化范围：
类似于1..5表示一个变化范围,其所含的值为大于等于1小于等于5.
举例：
a = 0
for i in 1..5
a += i
end
p a
这也很简单,很容易明白的.
4.loop do..end 循环：
举例：
i = 0
loop do
i += 1
p i
end
上面的代码会一直循环下去,也就是说是个死循环.只有使用break才可以从中跳出.
5.break 语句：
上面的例子如果改成下面的样子,就不再是死循环了：
i = 0
loop do
i += 1
if i == 5
break
end
p i
end
break也可以从while、for循环中跳出.
6.next 语句：
跳过本次循环,进入下次循环.
举例：
for i in 1..5
if i == 3
next
end
p i
end
结果显示四次,就只有1,2,3,4,5被显示出来了.
3. 函数
1. 函数的概念：
我们把事先编好的,能够解决或者说处理某种情况的功能的集合叫做函数.不必在意概念,用得多了自然就明白.其实我们一直在使用的
p,print就是函数的一种,下面介绍一个很有用的函数,随机函数rand()：
rand(x)返回0-(xx-1)范围内的随机数,例如：
p rand(100)
返回的数字在0-99范围内.
我们也可以设计自己的函数以便增加我们需要的功能,更多的时候,我们大多数时间是在跟函数打交道.
2. 函数的声明：
函数的名字基本上和变量的名字有着相同的限制,例外的情况是,函数可以在名字的最后添加?或!符号,这种符号有着特殊的用处,以后会讲到.
函数的声明要用def..end语句,形如：
def 函数名字
语句
end
我们用rand函数来设计一个自己的函数bet()：
def bet
if rand(6)3
return "大"
else
return "小"
end
end
print bet
这里的return表示函数返回的值,如果省略return也可以,但最好带上,能够使程序可读性更好.
我们给bet函数增加参数：
def bet(x)
if rand(x)3
return "大"
else
return "小"
end
end
print bet(7)
还可以为参数设置默认值:
def bet(x=7)
if rand(x)3
return "大"
else
return "小"
end
end
print bet #这和print bet(7)一样
函数可以有很多参数：
def bet(x,y,z)
if rand(x)3 and rand(y)3 and rand(z)3
return "大"
else
return "小"
end
end
print bet(7,6,10)
4. 重定义函数：
如果定义了两次相同的函数,则只有后面定义的函数有效,而先前的定义就无效了.
def hello
return" 您好 "
end
def hello
return" 晚安 "
end
p hello #=" 晚安 "
六. 数组
如果知道将多次对一个变量,例如 $salut赋值,您会怎样做呢？这在很多情况下都会发生.因此,您可以将所有的变量值放进一个数组里,而不是手动
地给变量重新赋值.
数组允许对每个变量值进行分别的处理.请看如下示例：
$salut = ['Hello World','Good Bye World','What do you mean Good Bye World?'] print $salut
运行上述代码得到的输出如下所示：
Hello WorldGood Bye WorldWhat do you mean Good Bye World?
显然,这不是我们想要的输出.没有间隔也没有换行.因此,我们可以标识希望显示数组的哪一部分,并使用先前解释的串联技术来更方便地提供易读的输出.
$salut = ['Hello World','Good Bye World','What do you mean Good Bye World?']
print $salut[0] + "\n"
print $salut[1] + "\n"
print $salut[2] + "\n"
将会导致如下输出：
Hello World
Good Bye
World What do you mean Good Bye World?
仔细分析这些代码.如果回顾一下我们建立的数组：
$salut = ['Hello World','Good Bye World','What do you mean Good Bye World?']
我们告诉 Ruby 定义一个名为 salut 的变量,其值为：
$salut = 0 1 2
Hello World Good Bye World What do you mean Good Bye World?
每个值通过一个数字来被识别.数字通过数组中的数字位置来定义.位置总是从 0 开始,并从 0 开始递增.所以要打印数组中的第 2 个值,
您要输入：
print $salut[1]
最容易忘记的是字段从 0 而不是从 1 开始.
七. load,require语句
在许多知名网站上,很多的人都认为RGSS不支持load,requir,语句,如果需要使用的话好去破解Scripts.rxdata文件(XP)或者Scripts.rvdata(VX),其实你不用去研究破解Scripts.rxdata了,因为RGSS完全支持load,require语句,只不过与Ruby语言稍有区别的是这两个语句只支持绝对地址,也就是说不支持类似于:require "win32/***" 的格式
在我们的试验脚本中输入：
load "d:/sequh.rb"
就可以加载D盘的sequh.rb文件了,同理：
require "D:/sequh.rb"
这里我输入的是绝对路径,绝对路径的表示方法是：
把DOS格式的路径名中的“\”统统改为“/”即可
而相对路径的获得,需要一点儿办法：
因为在我的游戏目录下有game.exe文件,所以我们可以通过它来获得游戏目录,然后得到绝对目录,把我们的相对路径加到绝对目录后面,例
子：
load "#/scripts/sequh.rb"
其中的File.dirname(File.expand_path("Game.exe"))便是游戏目录的绝对路径.
八. 对象和方法
这个代码段中用到的一些技术和方法您可能是第一次见到.RGSS是一种面向对象的编程（Object Oriented Programming,OOP）语言.使用 OOP 时,通常情况下程序员将调用诸如对象和方法之类的项目.对象就象一个容器.它包含自己特定的变量和函数. 方法是一种被调用的东西,就像函数对对象进行专门处理一样.如果看一下先前的示例,我们就可以显示工作中的对象和方法.
while enterWorld = STDIN.gets enterWorld.chop!
这里我们有两个对象和两个方法的示例.第一个对象是 enterWorld,第二个对象是 STDIN.enterWorld 对象是用户定义的对象,而 STDIN 对象（Standard Input 的缩写）是RGSS内建的.
这个示例中还有两种方法.第一种是 gets,第二种是 chop!.前面提到过,方法对对象进行专门处理.明确地说,方法将在对象中执行一个操作.用 gets 方法,我们告诉 RGSS 去获取 STDIN.当 RGSS 看到与 STDIN 关联的 gets,它就会等待键盘输入和一个回车.简而言之,STDIN.gets 就是等待用户输入一些内容然后敲 Enter 键.
第二种方法 chop! 用来对用户定义的对象 enterWorld 进行专门处理.chop! 方法告诉 enterWorld 将 enterWorld 对象关联的数据的换行符
和回车符截去.如果不使用 chop!（或者 chomp!）,那么包含在先前代码上下文中的下面语句永远都不会为真.
if enterWorld == $salut[0]
因为没有使用 chop!,所以得出结果将为假,$salut[0] 实际上就等于 $salut[0]\n.新行是由 STDIN 对象从 gets 方法接收的输入产生的.使用回车将会在值末尾添加一个换行符.
autoit和按键精灵 按键娃娃这些属于按键工具 可以模拟控制
ruby,lua,php,python vb6.0,C#,java erlang等这些可以模拟控制
C/C++ 汇编 可以控制硬件键盘鼠标
用C语言编写一程序，完成以下功能：定义一个结构体数组，输入4种商品的名称、单价、数量，要求计算并逐个输出每种商品的总价，最后输出单价最高的商品价格。
注意事项：
1.注意进行异常处理。
2.注意代码书写、命名规范。
提示算法（仅供参考）：
1.定义一个结构体，包括名称、单价、数量、总价四个成员
2.通过循环输入名称、单价、数量
3.计算商品总价，存入结构体
4.循环输出每种商品总价
5.判断并输出单价最高的商品价格
#!/usr/bin/env python3
# coding=utf-8
import random
# 财富值
wealth = 1000
# 下注金额
amount = 0
# 下注位置 0 表示小 1 表示大
bet = 0
# 财富最大临界值
max_wealth = 50000
# 财富最小临界值
min_wealth = 0
# 下注金额，传入剩余财富值
def input_num(residue_wealth):
num = input('您的剩余金额为: {}，请输入下注金额: '.format(residue_wealth))
# 判断输入金额 为正整数 大于0且不大于剩余财富值
if (num.isdigit() == False):
print('下注金额错误，您输入值为{}，请输入整数金额'.format(num))
return input_num(residue_wealth)
elif (num == '0'):
print('下注金额错误，您输入的值为{}，请输入大于0的整数金额'.format(num))
return input_num(residue_wealth)
num = int(num)
if (num residue_wealth):
print('下注金额({0})大于剩余财富值({1})，请重新输入'.format(num, residue_wealth))
return input_num(residue_wealth)
return num
# 下注大小
def input_bet_size():
input_bet = input('请您输入买大买小(0 为小 1 为大): ')
if (input_bet != '0' and input_bet != '1'):
print('您下注{}有误，请重新买大小'.format(input_bet))
return input_bet_size()
return int(input_bet)
# 随机生成大小
def random_bet_fun():
# 1-6的随机数，1，2，3为小 4，5，6为大
random_num = random.randint(1, 6)
if random_num = 1 and random_num 4:
random_bet = 0
else:
random_bet = 1
return random_bet
while 1:
amount = input_num(wealth)
bet = input_bet_size()
random_bet = random_bet_fun()
if (bet == random_bet):
# 猜对大小，财富值增加下注金额
wealth += amount
print('下注大小成功，财富值增加{0}，您的剩余财富值为{1}'.format(amount, wealth))
else:
# 猜错大小，财富值扣除下注金额
wealth -= amount
print('下注大小失败，财富值扣除{0}，您的剩余财富值为{1}'.format(amount, wealth))
print('您的剩余金额为: {}'.format(wealth))
if (wealth max_wealth):
print('您发财了，您的财富值{0}大于{1}'.format(wealth, max_wealth))
break
elif (wealth = min_wealth):
print('您破产了，您的财富值{0}不足'.format(wealth))
break
下注用的是色子的 1-6，1-3为小，4-6为大。
