精华内容
下载资源
问答
  • 用shell脚本写一个猜数游戏

    千次阅读 2019-06-13 09:46:29
    用shell脚本写一个猜数游戏 最近用shell写的一个猜数游戏,包括4个不同难度,脚本如下: #作者:p_小王 echo '欢迎来到猜数游戏!' while true do read -p '开始/退出(y/n):' x #提示用户输入 if [ -z $x ] #...

    用shell脚本写一个猜数游戏


    最近用shell写的一个猜数游戏,包括4个不同难度,脚本如下:

    
    #作者:p_小王
    
    echo '欢迎来到猜数游戏!'
    while true
    do
    	read -p '开始/退出(y/n):' x	#提示用户输入
    	if [ -z $x ]	#判断用户输入为空
    	then
    		echo '不能为空'	#提示
    		echo ''
    		continue
    	elif [ $x = y ]	#判断用户输入‘y’
    	then
    		echo ''
    		echo '游戏即将开始'
    		echo ''
    		while true
    		do
    			sleep 1s	#延迟1s
    			echo '请选择难度'	#难度选择
    	        echo '  1.简单'
    	        echo '  2.一般'
    	      	echo '  3.困难'
    			echo '  4.地狱'
    			echo '  5.返回'
    			echo ''
    	       	read -p '请输入对应序号:' y	#提示用户输入
    			if [ -z $y ]	#判断用户输入为空
    			then
    				echo '不能为空'	#提示
    				echo ''
    				continue
    			elif [ $y = 1 ]	#判断用户输入‘1’简单
    			then	
    				while true
    				do
    					num=$[RANDOM%100+1]	#随机生成100以内的数
    					echo '猜一个1-100的数'
    					n=0	#定义变量
    					while true
    					do
    						read -p '请输入:' a	#提示用户输入
    						let n++	#计次数
    						if [ -z $a ]	#判断用户输入为空
    						then
    							echo '输入不能为空!'	#提示
    							continue
    						elif [ -n "`echo $a | sed 's#[0-9]##g'`" ] #判断用户输入非数字
    						then
    							echo '请输入1-100之间的数!'	#提示
    							continue
    						elif [ $a -lt 1 ] || [ $a -gt 100 ]	#判断用户输入的数在1-100之间
    						then
    							echo '请输入1-100之间的数!'	#提示
    							continue
    						elif [ $a -gt $num ]	#判断用户输入的数大于随机生成的数
    						then
    							echo '猜大了,再猜!'	#提示
    							continue
    						elif [ $a -lt $num ]	#判断用户输入的数小于随机生成的数
    						then
    							echo '猜小了,再猜!'	#提示
    							continue
    						else
    							echo '恭喜你猜对了,正确数字是'$num	#提示用户猜对了
    							echo '猜了' $n '次'	#显示猜的次数
    							echo ''
    							sleep 1s	#延迟1s
    							echo '是否再来一局?'	#提示是否再玩
    							while true
    							do
    								read -p 'y/n:' i	#提示用户输入
    								if [ -z $i ]	#判断用户输入为空
    								then
    									echo '不能为空'	#提示
    									echo ''
    									continue
    			        				elif [ $i = y ]	#判断用户输入‘y’
    								then
    									break 2
    								elif [ $i = n ]	#判断用户输入‘n’
    								then
    									break 3
    								else
    									echo '输入有误'	#提示
    									echo ''
    									continue
    								fi
    							done
    						fi
    					done
    				done
    
    			elif [ $y = 2 ]	#判断用户输入‘2’一般
    			then
    				while true
    				do
    					num=$[RANDOM%1000+1]	#随机生成1000以内的数
    					echo '猜一个1-1000的数'	#提示
    					n=0	#定义变量
    					while true
    					do
    						read -p '请输入:' a	#提示用户输入
    						let n++	#记次数
    						if [ -z $a ]	#判断用户输入
    						then
    							echo '输入不能为空!'	#提示
    							continue
    						elif [ -n "`echo $a | sed 's#[0-9]##g'`" ] 	#判断用户输入非数字
    						then
    							echo '请输入1-1000之间的数!'	#提示
    							continue
    						elif [ $a -lt 1 ] || [ $a -gt 1000 ]	#判断用户输入的在1-1000之间
    						then
    							echo '请输入1-1000之间的数!'	#提示
    							continue
    						elif [ $a -gt $num ]
    						then
    							echo '猜大了,再猜!'	#提示
    							continue
    						elif [ $a -lt $num ]
    						then
    							echo '猜小了,再猜!'	#提示
    							continue
    						else
    							echo '恭喜你猜对了,正确数字是'$num	#提示用户猜对了
    							echo '猜了' $n '次'	#显示猜的次数
    							echo ''
    							sleep 1s	#延迟1s
    							echo '是否再来一局?'	#提示是否继续玩
    							while true
    							do
    								read -p 'y/n:' i	#提示用户输入
    								if [ -z $i ]	#判断用户输入为空
    								then
    									echo '不能为空'	#提示
    									echo ''
    									continue
    			        				elif [ $i = y ]	#判断用户输入‘y’
    								then
    									break 2
    								elif [ $i = n ]	#判断用户输入‘n’
    								then
    									break 3
    								else
    									echo '输入有误'	#提示
    									echo ''
    									continue
    								fi
    							done
    						fi
    					done
    				done
    
    			elif [ $y = 3 ]	#判断用户输入‘3’困难
    			then
    				while true
    				do
    					num=$[RANDOM%10000+1]	#随机生成10000以内的数
    					echo '猜一个1-10000的数'	#提示
    					n=0	#定义变量
    					while true
    					do
    						read -p '请输入:' a	#提示用户输入
    						let n++	#记次数
    						if [ -z $a ]	#判断用户输入为空
    						then
    							echo '输入不能为空!'	#提示
    							continue
    						elif [ -n "`echo $a | sed 's#[0-9]##g'`" ]	#判断用户输入非数字
    						then
    							echo '请输入1-10000之间的数!'	#提示
    							continue
    						elif [ $a -lt 1 ] || [ $a -gt 10000 ]	#判断用户输入是否在1-10000之间
    						then
    							echo '请输入1-10000之间的数!'	#提示
    							continue
    						elif [ $a -gt $num ]	#判断输入的数大于随机生成数
    						then
    							echo '猜大了,再猜!'	#提示
    							continue
    						elif [ $a -lt $num ]	#判断输入的数小于随机生成数
    						then
    							echo '猜小了,再猜!'	#提示
    							continue
    						else
    							echo '恭喜你猜对了,正确数字是'$num	#提示用户猜对了
    							echo '猜了' $n '次'	#提示
    							echo ''
    							sleep 1s	#延迟1s
    							echo '是否再来一局?'	#提示是否继续玩
    							while true
    							do
    								read -p 'y/n:' i	#提示用户输入
    								if [ -z $i ]	#判断用户输入为空
    								then
    									echo '不能为空'	#提示
    									echo ''
    									continue
    			        				elif [ $i = y ]	#判断用户输入‘y’
    								then
    									break 2
    								elif [ $i = n ]	#判断用户输入‘n’
    								then
    									break 3
    								else
    									echo '输入有误'	#提示
    									echo ''
    									continue
    								fi
    							done
    						fi
    					done
    				done
    
    			elif [ $y = 4 ]	#判断用户输入‘4’地狱
    			then
    				while true
    				do
    					num=$[RANDOM%100000+1]	#随机生成100000以内的数
    					echo '猜一个1-100000的数'	#提示
    					n=0	#定义变量
    					while true
    					do
    						read -p '请输入:' a	#提示用户输入
    						let n++	#记次数
    						if [ -z $a ]	#判断用户输入为空
    						then
    							echo '输入不能为空!'	#提示
    							continue
    						elif [ -n "`echo $a | sed 's#[0-9]##g'`" ]	#判断用户输入非数字
    						then
    							echo '请输入1-100000之间的数!'	#提示
    							continue
    						elif [ $a -lt 1 ] || [ $a -gt 100000 ]	#判断用户输入1-100000之间
    						then
    							echo '请输入1-100000之间的数!'	#提示
    							continue
    						elif [ $a -gt $num ]	#判断输入的数大于随机生成数
    						then
    							echo '猜大了,再猜!'	#提示
    							continue
    						elif [ $a -lt $num ]	#判断输入的数小于随机生成数
    						then
    							echo '猜小了,再猜!'	#提示
    							continue
    						else
    							echo '恭喜你猜对了,正确数字是'$num	#提示用户猜对了
    							echo '猜了' $n '次'	#显示猜的次数
    							echo ''
    							sleep 1s	#延迟1s
    							echo '是否再来一局?'	#提示是否继续玩
    							while true
    							do
    								read -p 'y/n:' i	#提示用户输入
    								if [ -z $i ]	#判断用户输入为空
    								then
    									echo '不能为空'	#提示
    			       						echo ''
    									continue	
    			        				elif [ $i = y ]	#判断用户输入‘y’
    								then
    									break 2
    								elif [ $i = n ]	#判断用户输入‘n’
    								then
    									break 3
    								else
    									echo '输入有误'	#提示
    									echo ''
    									continue
    								fi
    							done
    						fi
    					done
    				done
    
    			elif [ $y = 5 ]	#判断用户选择返回
    			then
    				echo ''
    				break	#返回
    			else	#判断用户输入其他
    				echo '输入有误'	#提示
    				echo ''
    				continue
    			fi	
    		done
    	elif [ $x = n ]	#判断用户输入‘n’退出
    	then
    		echo '游戏即将退出'	#提示
    		echo ''
    		sleep 1s
    		echo '退出成功!'	#提示
    		echo ''
    		exit 0	#结束脚本
    	else	#判断用户输入其他
    		echo '输入有误'	#提示
    		echo ''
    		continue
    	fi
    done
    

    备注:本人已经测试过了,未测出bug,小伙伴如果发现bug记得及时提交到评论区,我会及时改过来,谢谢

    作者:p_小王

    展开全文
  • 这几天在学习Linux的Shell脚本了一个猜丁壳游戏游戏规则:每回合玩家和电脑各出石头、剪子、布中的一个,分别以0、1、2表示,规定石头可以胜过剪子、剪子可以胜过布、布可以胜过石头,如果玩家和电脑所出...

    这几天在学习Linux的Shell脚本,写了一个猜丁壳游戏。

    游戏规则:每回合玩家和电脑各出石头、剪子、布中的一个,分别以0、1、2表示,规定石头可以胜过剪子、剪子可以胜过布、布可以胜过石头,如果玩家和电脑所出相同,则进入下一回合继续比试,否则游戏结束,本回合的胜者即为游戏的获胜方。

    #!/bin/sh
    
    # generate random numbers
    function rand()
    {
        min=$1
        max=$(($2-$min+1))
        num=$(($RANDOM+10000))
        echo $(($num%$max+$min))
    }
    
    result=0
    echo "Game Start!"
    while [ true ]; do
        
        # Stone win Scissors
        # Scissors win Cloth
        # Cloth win Stone
        echo "0-Stone, 1-Scissors, 2-Cloth, 3-GiveUp!"
        read choice
        rnd=$(rand 0 2)
        case "$choice" in
            0)if [ $rnd -eq 0 ]; then
                 echo "Stone vs Stone: Draw"
              elif [ $rnd -eq 1 ]; then
                 echo "Stone vs Scissors: Win!"
                 result=1
              else
                 echo "Stone vs Cloth: Defeat!"
                 result=-1
              fi;;
            1)if [ $rnd -eq 0 ]; then
                  echo "Scissors vs Stone: Defeat!"
                  result=-1
              elif [ $rnd -eq 1 ]; then
                  echo "Scissors vs Scissors: Draw"
              else
                  echo "Scissors vs Cloth: Win!"
                  result=1
              fi;;
            2)if [ $rnd -eq 0 ]; then
                  echo "Cloth vs Stone: Win!"
                  result=1
              elif [ $rnd -eq 1 ]; then
                  echo "Cloth vs Scissors: Defeat!"
                  result=-1
              else
                  echo "Cloth vs Cloth: Draw"
              fi;;
            3)result=-1;;
            *)echo "bad choice";;
        esac
    
        # if draw then continue else break
        if [ $result -eq 0 ]; then
            continue 
        else
            break    
        fi
    
    done
    
    echo "End of program"
    echo " "
    
    exit 0

    运行结果

    213528_YmzX_1425762.png

    转载于:https://my.oschina.net/Tsybius2014/blog/284898

    展开全文
  • python的一个简单的俄罗斯方块代码代码下载链接 代码 代码 #!/bin/bash #version 1.2,若非正常退出,请使用附带的killel.sh脚本杀死进程 #定义用于显示的地图map和背景全地图mapback map=(0 0 0 0 0 0 0 0 0 ...

    用shell脚本写的一个简单的俄罗斯方块


    代码

    代码

    #!/bin/bash
    #version 1.2,若非正常退出,请使用附带的killel.sh脚本杀死进程
    #定义用于显示的地图map和背景全地图mapback
        map=(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) #游戏共有20行,16列,此处定义行数,而每行是否有方块由数组中的元素决定(二进制的0为没有方块,1为有方块)
    mapback=(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) #(0 0 0 0 0 0 65534 65534 65534 65534 65534 65534 65534 65534 65534 65534 65534 65534 65534 65534 )  #用于临时存放包含当前方块的背景地图
    zongtime=10
    sleeptime=0.1
    downtime=0
    
    #存放当前方块的相关参数
    curx=7
    cury=0
    curtype=0
    curstat=0
    curfk=(0 0 0 0)        #用于表示当前方块的数组
    
    #预制方块参数
    yutype=0
    yustat=0
    yufk=(0 0 0 0)
    
    #分数和行数
    zongfen=0
    zonghang=0
    dancifen=0
    dangqianhang=0
    qiancihang=0
    dengji=1
    
    #用于存放fGetfk生成的方块
    scfk=(0 0 0 0)
    
    #游戏参数
    cyzfc="左移a 右移d 变形j 落地k 加速s 退出q 暂停p 存档c 取档l 重新开始r"
    zhuangtai=$cyzfc
    fangkuai="@"
    beijing=" "
    gameover=0
    
    #难度相关参数
    nanduline=0  #存放底部随机产生的行
    nandutime=0  #在时间难度模式下的计时器
    nanduzongtime=100 #在时间难度模式下的产生底部随机行的时间间隔
    nandutimeflag=0  #是否打开时间难度的标志位
    nandudengji=1  
    nanduzonghang=12 #在行数难度模式下的消除多少行产生底部随机行
    nanduhang=0  #在行数难度模式下的行数计数器
    nanduhangflag=0  #是否带开行数难度的标志位
    
    #以后要修改的:定义当前方块和临时方块############################################
    #      (3 3|0 15,2 2 2 2|2 7,2 3 2,0 7 2,2 6 2|1 7,2 2 3,7 4,3 1 1|4 7,3 2 2,7 1,1 1 3|6 3,1 3 2|3 6,2 3 1)
    #allfk=(3 3 0 15 2 2 2 2 2 7 2 3 2 0 7 2 2 6 2 1 7 2 2 3 7 4 3 1 1 4 7 3 2 2 7 1 1 1 3 6 3 1 3 2 3 6 2 3 1)
    #        (2|2 4|2 3 3 3|2 3 2 3|2 3 2 3|2 3|2 3)
    #afkstat=(2 2 4 2 3 3 3 2 3 2 3 2 3 2 3 2 3 2 3)
    #afktype=(1 2 4 4 4 2 2)
    #################################################################################
    
    
    
    #定义各类方块,(各类方块对应数字:1、田字形 2、长条形 3、山字形 4、左勾形 5、右勾形 6、左之形 7、右之形)
    function fGetfk(){ #参数1:方块类型  #参数2:方块状态
     case $1 in
      1)
       scfk=(3 3)
      ;;
      2)
       case $2 in
        1)
         scfk=(0 15)
        ;;
        2)
         scfk=(1 1 1 1)
        ;;
        3)
         scfk=(0 15)
        ;;
        4)
         scfk=(1 1 1 1)
        ;;
       esac 
      ;; 
      3)
       case $2 in
        1)
         scfk=(2 7)
        ;;
        2)
         scfk=(2 3 2)
        ;;
        3)
         scfk=(0 7 2)
        ;;
        4)
         scfk=(1 3 1)
        ;;
       esac
      ;;
      4)
       case $2 in
        1)
         scfk=(1 7)
        ;;
        2)
         scfk=(2 2 3)
        ;;
        3)
         scfk=(7 4)
        ;;
        4)
         scfk=(3 1 1)
        ;;
       esac
      ;;
      5)
       case $2 in
        1)
         scfk=(4 7)
        ;;
        2)
         scfk=(3 2 2)
        ;;
        3)
         scfk=(7 1)
        ;;
        4)
         scfk=(1 1 3)
        ;;
       esac
      ;;
      6)
       case $2 in
        1)
         scfk=(6 3)
        ;;
        2)
         scfk=(1 3 2)
        ;;
        3)
         scfk=(6 3)
        ;;
        4)
         scfk=(1 3 2)
        ;;
       esac
      ;;
      7)
       case $2 in
        1)
         scfk=(3 6)
        ;;
        2)
         scfk=(2 3 1)
        ;;
        3)
         scfk=(3 6)
        ;;
        4)
         scfk=(2 3 1)
        ;;
       esac
      ;;
     esac
    }
    
    #刷背景地图的函数,也即是把当前方块融入背景地图
    function fMaptemp(){
     local i
     for ((i=0;i<20;i++))
     do
      ((mapback[i]=map[i]))
     done
    }
    
    #刷显示地图的函数
    function fMap(){
     local i
     for ((i=0;i<20;i++))
     do
      ((map[i]=mapback[i]))
     done
    }
    
    
    #绘制当前方块
    function fDrawfk(){  #参数1:给定的y坐标
     local curfktemp cH i
     for ((i=0;i<4;i++))
     do
      ((curfktemp=curfk[i]<< curx))
      ((map[$1+i]=mapback[$1+i]|curfktemp))
     done
    }
    
    
    #方块左移的函数
    function fLeft(){
     if fPeng $((curx+1)) $cury $curtype $curstat
     then
      ((curx++))
      fDrawfk $cury
     fi
    }
    
    #方块右移的函数
    function fRight(){
     if fPeng $((curx-1)) $cury $curtype $curstat
     then
      ((curx--))
      fDrawfk $cury
     fi
    }
    
    #方块变形的函数
    function fChange(){
     local cH i tempx j peng
     fGetfk $curtype $curstat
     for j in 0 -1 -2 -3 
     do
      ((tempx=curx+j))
      if fPeng $tempx $cury $curtype $((curstat%4+1))
      then
       ((curstat=curstat%4+1))
       curx=$tempx
       for ((i=0;i<4;i++))
       do
        ((curfk[i]=scfk[i]))
       done
       fDrawfk $cury
       return 0
      fi
     done
    }
    
    
    #方块下移的函数
    function fDown(){
     local a
     if fPeng $curx $((cury+1)) $curtype $curstat
     then
      ((map[cury]=mapback[cury]))
      ((cury++))
      fDrawfk $cury
     else
      fMaptemp
      fZhengli
      fInit
      return 0
     fi
    }
    
    
    #方块直接落底的函数
    function fDownbottom(){
     local a i1 i2
     for ((i1=cury;i1<19;i1++))
     do
      fPeng $curx $(($i1+1)) $curtype $curstat;a=$?
      if [ $a -eq 1 ]
      then
       for ((i2=0;i2<4;i2++))
       do
        ((map[cury+i2]=mapback[cury+i2]))
       done
       ((cury=$i1))
       fDrawfk $cury
       fMaptemp
       fZhengli
       fInit
       #fDown
       return 0
      fi
     done
    }
    
    
    #判断是否出边界或与其他方块碰撞的函数
    function fPeng(){ #参数1:移动后的x坐标   #参数2:移动后的y坐标 #参数3:方块的类型 #参数4:方块的状态
     local cH chazhi
     fGetfk $3 $4
     cH=${#scfk[@]}
    # fRemovefk $cury
     for ((i=0;i<4;i++))
     do
      if (( $1<0 || ((scfk[i]<<$1))>65535 || (($2+$cH))>20 || ((((scfk[i]<<$1))&mapback[$2+i]))>0))
      then
       return 1
      fi
     done
     return 0
    }
    
    #检查函数
    function fCheck(){
     local i
     for ((i=0;i<4;i++))
     do
      if [ ${map[cury+i]} -eq 65535 ]
      then
       return 0
      fi
     done
     return 1
    }
    
    #整理及记分函数
    function fZhengli(){
     local i j k cH mapbottom
     j=19
     if fCheck
     then
      fGetfk $curtype $curstat 
      cH=${#scfk[@]}
      for i in {0..3}
      do
       for ((k=0;k<cH;k++))
       do
        if [ ${mapback[cury+k]} -eq 65535 ]
        then
         if [ ${map[cury+k]} -eq 65535 ]
         then
          map[cury+k]=0
         elif [ ${map[cury+k]} -eq 0 ]
         then
          map[cury+k]=65535
         fi
        fi
       done
       fDisplay
       sleep 0.3
      done
      for ((i=19;i>=0;i--))
      do
       if [ ${mapback[i]} -ne 65535 ]
       then
        map[j]=${mapback[i]}
        ((j--))
       fi
      done
      ((dangqianhang=j+1))
      for ((j=$j;j>=0;j--))
      do
       map[j]=0
      done 
      fMaptemp
      #计分方法
      if [ $dangqianhang -eq $qiancihang -a $dangqianhang -ne 1 ]
      then
       ((dancifen=dancifen+5*dangqianhang*dangqianhang*(dengji+9)/10*(10+nanduhangflag*2)/10)) #若与上次消除行数相同,则分数加成
      else
       ((dancifen=(10*dangqianhang)*(dengji+9)/10*(10+nanduhangflag*2)/10))  #若与上次消除行数不相同,则分数加成消失
      fi
        
      ((zongfen=zongfen+dancifen))
      ((zonghang=zonghang+dangqianhang))
      qiancihang=$dangqianhang
      ((nanduhang=nanduhang+dangqianhang))
      if ((((zonghang/50+1))>dengji))
      then 
       ((dengji=zonghang/50+1)) 
       for i in {1..4}
       do
        zhuangtai="升级了!准备进入下一级"
        fDisplay
        sleep 0.2
        zhuangtai=""
        fDisplay
        sleep 0.2
       done
       zhuangtai=$cyzfc
      fi
      if ((zongtime<11))
      then
       ((zongtime=11-dengji))
      fi
      if ((nanduhangflag==1&&nanduhang>=nanduzonghang))
      then
       fHangnandu
       nanduhang=0
       #mapbottom=map[19]
       for i in {1..3}
       do
        map[19]=0
        fDisplay
        sleep 0.3
        map[19]=$nanduline
        fDisplay
        sleep 0.3
       done
      fi
     fi 
    }
    
    
    #新方块初始化函数
    function fInit(){
     local cH i
     curtype=$yutype
     curstat=$yustat
     ((yutype=$RANDOM%7+1))
     ((yustat=$RANDOM%4+1))
     fGetfk $yutype $yustat
     for i in {0..3}
     do
      ((yufk[i]=scfk[i]))
     done
     #curtype=2
     #curstat=1
     curx=7
     cury=0
     fGetfk $curtype $curstat
     for ((i=0;i<4;i++))
     do
      ((curfk[i]=scfk[i]))
     done
     downtime=0
     fDrawfk $cury
     #测试新出方块是否一出来就和背景方块重合,是则代表游戏结束
     fPeng $curx $cury $curtype $curstat;a=$?
     if [ $a -ne 0 ]
     then
      gameover=1
     # echo "o" > ctrl.txt
     # cat ctrl.txt>>debug
      #return 1
     fi
    }
    
    #时间难度
    function fTimenandu(){
     local i
     fPeng $curx $((cury+1)) $curtype $curstat
     if [ $? -ne 0 ]
     then
      fMaptemp
      fZhengli
      fInit
     fi
    
     ((nanduline=$RANDOM%32767+$RANDOM%32766+1))
     for i in {0..18}
     do
      mapback[i]=${mapback[i+1]}
     done
     mapback[19]=$nanduline
     fMap
     fDrawfk $cury
     fPeng $curx $((cury+1)) $curtype $curstat
     if [ $? -ne 0 ]
     then
      fMap
      fDrawfk $cury
      fMaptemp
      fZhengli
      fInit
     fi
    }
    
    #行数难度
    function fHangnandu(){
     local i
     ((nanduline=$RANDOM%32767+$RANDOM%32766+1))
     for i in {0..18}
     do
      mapback[i]=${mapback[i+1]}
     done
     mapback[19]=$nanduline
     fMap
     #fDrawfk $cury
    }
    
    
    #输出调试数据的函数,此函数仅用于调试
    function fTiaoshi(){ #参数1:接收调试数据的文件
     echo "map   ${map[@]}" >$1
     echo "mapba ${mapback[@]}" >> $1
     echo -n "curx  $curx" >> $1
     echo -n "cury  $cury" >> $1
     echo -n "curtype $curtype" >> $1
     echo -n "curstat $curstat" >> $1
     echo -n "yutype $yutype" >> $1
     echo -n "yustat $yustat" >> $1
     echo -n "zongfen  $zongfen" >> $1
     echo -n "zonghang $zonghang" >> $1
     echo -n "dancifen $dancifen" >> $1
     echo -n "dangqianhang $dangqianhang" >> $1
     echo -n "qiancihang $qiancihang" >> $1
     echo "dengji $dengji" >> $1
     echo "" >> $1  
    }
    
    #存档
    function fSave(){
     echo "${map[@]}" >> save.txt        #显示地图
     echo "${mapback[@]}" >> save.txt    #背景地图
     echo "${curx}" >> save.txt          #当前x坐标
     echo "${cury}" >> save.txt          #当前y坐标
     echo "${curtype}" >> save.txt       #当前方块类型
     echo "${curstat}" >> save.txt       #当前方块状态
     echo "${yutype}" >> save.txt        #预制方块类型  
     echo "${yustat}" >> save.txt        #预制方块状态  
     echo "${zongfen}" >> save.txt       #总分  
     echo "${zonghang}" >> save.txt      #总行数
     echo "${dancifen}" >> save.txt      #单次得分   
     echo "${dangqianhang}" >> save.txt  #当前消除行数
     echo "${qiancihang}" >> save.txt    #前次消除行数
     echo "${dengji}" >> save.txt        #等级
     echo "a${fangkuai}" >> save.txt     #用于代表方块的字符 
     echo "a${beijing}" >> save.txt      #用于代表背景的字符
     echo "${nanduhangflag}" >> save.txt #是否开启难度的标志
     echo "${nanduhang}" >> save.txt     #底部出现的随机行计数器
    }
    
    #读档
    function fLoad(){
     local j=0
     map=()
     mapback=()
     for i in `sed -n "1p" save.txt`
     do
      map[j]=$i
      ((j++))
     done
    
     j=0
     for i in `sed -n "2p" save.txt`
     do
      mapback[j]=$i
      ((j++))
     done
     
     curx=`sed -n "3p" save.txt`
     cury=`sed -n "4p" save.txt`
     curtype=`sed -n "5p" save.txt`
     curstat=`sed -n "6p" save.txt`
     yutype=`sed -n "7p" save.txt`
     yustat=`sed -n "8p" save.txt`
     zongfen=`sed -n "9p" save.txt`
     zonghang=`sed -n "10p" save.txt`
     dancifen=`sed -n "11p" save.txt`
     dangqianhang=`sed -n "12p" save.txt`
     qiancihang=`sed -n "13p" save.txt`
     dengji=`sed -n "14p" save.txt`
    
     fangkuai=`sed -n "15p" save.txt`
     if [ "$fangkuai" == "a" ]
     then
      fangkuai=" "
     else
      fangkuai=${fangkuai:1:1}
     fi
    
     beijing=`sed -n "16p" save.txt`
     if [ "$beijing" == "a" ]
     then
      beijing=" "
     else
      beijing=${beijing:1:1}
     fi
    
     curfk=()
     scfk=()
     yufk=()
    
     fGetfk $curtype $curstat
    
     for ((i=0;i<4;i++))
     do
      curfk[i]=${scfk[i]}
     done
     
     fGetfk $yutype $yustat
     for ((i=0;i<4;i++))
     do
      yufk[i]=${scfk[i]}
     done
     
     if ((zongtime<11))
     then
      ((zongtime=11-dengji))
     fi
     
     nanduhangflag=`sed -n "17p" save.txt`
     nanduhang=`sed -n "18p" save.txt`
    }
    
    #读取配置文件
    function fConf(){
     beijing=`sed -n "/beijing=/p" peizhi.conf`
     if [ "$beijing" == "beijing=" ]
     then
      beijing=" "
     else
      beijing=${beijing:${#beijing}-1:1}
     fi
    
     fangkuai=`sed -n "/fangkuai=/p" peizhi.conf`
     if [ "$fangkuai" == "fangkuai=" ]
     then
      fangkuai=" "
     else
      fangkuai=${fangkuai:${#fangkuai}-1:1}
     fi
    }
    
    #退出函数
    function fExit(){
     local ctkey i
     zhuangtai="确定要退出吗?(y/n)"
     fDisplay
     :>ctrl.txt
    
     while true
     do
      ctkey=$(cat ctrl.txt)
      if [ "$ctkey" == "n" ]
      then
       zhuangtai=$cyzfc
       :>ctrl.txt
       return
      elif [ "$ctkey" == "y" ]
      then
       break 
      fi
      sleep 0.2
     done
    
     rm -fr ctrl.txt fk.disp start.txt
     clear
     for i in $(ps -aux |grep -E "fk.disp"|grep -Ev "vim|grep"|awk '{print $2}')
     do
      kill -9 $i &>/dev/null
     done
     clear
    
     for i in $(ps -aux |grep -E "elsfk|start.txt"|grep -Ev "vim|grep"|awk '{print $2}')
     do
      kill -9 $i &>/dev/null
     done
     clear
     exit
    }
    
    
    #根据参数修改显示文件fk.disp,然后根据fk.disp文件显示游戏画面
    function fDisplay(){
     local x y i j
     :> fk.disp
    
     x=65536;y=${map[0]}
     echo -n "|" >> fk.disp
     for j in {1..16}
     do
      x=$((x>>1))
      if [ $((x&y)) -ne 0 ]
      then
       echo -n "${fangkuai}" >> fk.disp
      else
       echo -n "${beijing}" >> fk.disp
      fi   
     done
     echo -n "|" >> fk.disp
     echo "总  分:$zongfen" >>fk.disp
    
     x=65536;y=${map[1]}
     echo -n "|" >> fk.disp
     for j in {1..16}
     do
      x=$((x>>1))
      if [ $((x&y)) -ne 0 ]
      then
       echo -n "${fangkuai}" >> fk.disp
      else
       echo -n "${beijing}" >> fk.disp
      fi 
     done
     echo -n "|" >> fk.disp
     echo "总  行:$zonghang" >>fk.disp
    
     x=65536;y=${map[2]}
     echo -n "|" >> fk.disp
     for j in {1..16}
     do
      x=$((x>>1))
      if [ $((x&y)) -ne 0 ]
      then
       echo -n "${fangkuai}" >> fk.disp
      else
       echo -n "${beijing}" >> fk.disp
      fi 
     done
     echo -n "|" >> fk.disp
     echo "单次分:$dancifen" >>fk.disp
    
     x=65536;y=${map[3]}
     echo -n "|" >> fk.disp
     for j in {1..16}
     do
      x=$((x>>1))
      if [ $((x&y)) -ne 0 ]
      then
       echo -n "${fangkuai}" >> fk.disp
      else
       echo -n "${beijing}" >> fk.disp
      fi
     done
     echo -n "|" >> fk.disp
     echo "等  级:$dengji" >>fk.disp
    
     for i in {4..7}
     do
      echo -n "|" >> fk.disp
      x=65536
      y=${map[$i]}
      for j in {1..16}
      do
       x=$((x>>1))
       if [ $((x&y)) -ne 0 ]
       then
        echo -n "${fangkuai}" >> fk.disp
       else
        echo -n "${beijing}" >> fk.disp
       fi
      done
      echo -n "|" >> fk.disp
      x=8
      y=${yufk[i-4]} 
      for j in {0..3}
      do 
       if [ $((x&y)) -ne 0 ]
       then
        echo -n $fangkuai >> fk.disp
       else
        echo -n " " >> fk.disp
       fi
       x=$((x>>1))
      done
     echo "" >> fk.disp
     done
    
     for i in {8..19}
     do
      echo -n "|" >> fk.disp
      x=65536
      y=${map[$i]}
      for j in {1..16}
      do
       x=$((x>>1))
       if [ $((x&y)) -ne 0 ]
       then
        echo -n "${fangkuai}" >> fk.disp
       else
        echo -n "${beijing}" >> fk.disp
       fi	
      done
      echo "|" >> fk.disp
     done
     echo "~~~~~~~~~~~~~~~~~~" >> fk.disp
     echo $zhuangtai >>fk.disp
    }
    
    #得到键盘输入并修改ctrl.txt文件以传参给fMain函数
    function fGetKey(){
     local key i ctrlkey #tshang=12
     while true
     do
    
      read -n 1 -s  key &>/dev/null
      echo "::outkey" >>debug
      ctrlkey=$(cat ctrl.txt)
      
      if [ "$ctrlkey" == "beijing" ]
      then
       if [ "$key" == "" ]
       then 
        sed -i "/beijing=/cbeijing=" peizhi.conf
        sed -i  "12c|请输入一个字符作为背景:         |" start.txt
        sed -i  "13c|(回车为空格):空格               |" start.txt
       else
        sed -i "/beijing=/cbeijing=${key}" peizhi.conf
        sed -i  "12c|请输入一个字符作为背景:         |" start.txt
        sed -i  "13c|(回车为空格):$key                  |" start.txt
       fi
       key=""
       :>ctrl.txt
      fi
      
      if [ "$ctrlkey" == "fangkuai" ]
      then
       if [ "$key" == "" ]
       then
        sed -i "/fangkuai=/cfangkuai=" peizhi.conf
        sed -i  "12c|请输入一个字符作为方块:         |" start.txt
        sed -i  "13c|(回车为空格):空格               |" start.txt
       else
        sed -i "/fangkuai=/cfangkuai=${key}" peizhi.conf
        sed -i  "12c|请输入一个字符作为方块:         |" start.txt
        sed -i  "13c|(回车为空格):$key                  |" start.txt
       fi
       key=""
       :>ctrl.txt
      fi
     
      if [ "$key" == "a" -o "$key" == "A" ]
      then
       echo "l" > ctrl.txt           #l=左移
      elif [ "$key" == "d" -o "$key" == "D" ]
      then
       echo "r" > ctrl.txt           #r=右移  
      elif [ "$key" == "j" -o "$key" == "J" ]
      then
       echo "c" > ctrl.txt           #c=变形
      elif [ "$key" == "k" -o "$key" == "K" ]
      then
       echo "d" > ctrl.txt       #d=落到底部
      elif [ "$key" == "q" -o "$key" == "Q" ]
      then
       echo "e" > ctrl.txt           #e=退出
      elif [ "$key" == "p" -o "$key" == "P" ]
      then
       echo "p" > ctrl.txt           #p=暂停
      elif [ "$key" == "r" -o "$key" == "R" ]
      then
       echo "s" > ctrl.txt       #r=重新开始
      elif [ "$key" == "y" -o "$key" == "Y" ]
      then
       echo "y" > ctrl.txt            #y=yes
      elif [ "$key" == "n" -o "$key" == "N" ]
      then
       echo "n" > ctrl.txt             #y=no
      elif [ "$key" == "c" -o "$key" == "C" ]
      then
       echo "w" > ctrl.txt           #w=存档
      elif [ "$key" == "l" -o "$key" == "L" ]
      then
       echo "a" > ctrl.txt           #a=取档
      elif [ "$key" == "s" -o "$key" == "S" ]
      then
       echo "h" > ctrl.txt           #a=取档
      elif [ "$key" == "1" ]
      then
       echo "1" > ctrl.txt       #1=开始游戏
      elif [ "$key" == "2" ]
      then
       echo "2" > ctrl.txt       #2=读取存档
      elif [ "$key" == "3" ]
      then
       echo "3" > ctrl.txt       #3=改变背景
      elif [ "$key" == "4" ]
      then
       echo "4" > ctrl.txt       #4=改变方块
      elif [ "$key" == "5" ]
      then
       echo "5" > ctrl.txt       #5=退出游戏
      elif [ "$key" == "6" ]
      then
       echo "6" > ctrl.txt       #6=显示帮助
      elif [ "$key" == "7" ]
      then
       echo "7" > ctrl.txt       #7=启用难度
      elif [ "$key" == "0" ]
      then
       echo "0" > ctrl.txt       #0=退出帮助
      fi
     done
    }
    
    #制作开始画面文件
    function fStartfile(){
     echo "-----------------------------------" >start.txt
     echo "|         连消俄罗斯方块          |" >>start.txt
     echo "|            版本:1.1             |" >>start.txt
     echo "-----------------------------------" >>start.txt
     echo "|   1、开始游戏     7、启用难度   |" >>start.txt
     echo "|   2、读取存档                   |" >>start.txt
     echo "|   3、改变背景                   |" >>start.txt
     echo "|   4、改变方块                   |" >>start.txt
     echo "|   5、退出游戏                   |" >>start.txt
     echo "|   6、显示帮助                   |" >>start.txt
     echo "-----------------------------------" >>start.txt
     echo "|                                 |" >>start.txt
     echo "|                                 |" >>start.txt
     echo "-----------------------------------" >>start.txt
     echo "|     Copyright © 2017 洪 超      |" >>start.txt
     echo "|      All rights reserved        |" >>start.txt
     echo "-----------------------------------" >>start.txt
    }
    
    #制作帮助文件
    function fHelpfile(){
     echo -n "           " >start.txt
     echo "游戏帮助" >>start.txt
     echo "退出帮助请按0" >>start.txt
     echo "1.各个键的使用:" >>start.txt
     echo -e "左移:a 右移:d 变形:j 落地:k 加速:s 退出:q\n暂停:p 存档:c 取档:l 重新开始:r" >>start.txt 
     echo -e "2.游戏计分方法:\n消除1行得到10分,连续消除相同行数将会有分\n数加成,具体计分方法如下:" >>start.txt 
     echo -e "1)连续消除1行无加成;\n2)连续消除2行以上将在上次单次得分的基础上\n加消除行数的平方;" >>start.txt 
     echo -e "3)连续消除相同行数后若有一次消除不同行数\n加成将消失;" >>start.txt 
     echo -e "4)等级加成,等级1无加成,等级2单次得分加\n消除行数的平方乘1.1,等级3单次得分加消除\n行数的平方乘1.2.....以此类推" >>start.txt 
     echo -e "3.每消除50行升一等级" >>start.txt 
     echo -e "4.若开启难度,每消除12行底部出现一行方块" >>start.txt 
     echo -e "5.以后将有更多新玩法,敬请期待" >>start.txt 
    }
    
    #显示开始画面
    function fStart(){
     local ctrlkey
     :>ctrl.txt
     fStartfile
     watch -n 0.2 "cat start.txt"& 
     startid=$!
     while true
     do
      ctrlkey=`cat ctrl.txt`
      if [ "$ctrlkey" == "1" ]
      then
       kill -9 $startid
       fConf
       :>ctrl.txt
       return
      fi
    
      if [ "$ctrlkey" == "2" ]
      then
       if [ -a save.txt ]  #检查是否有存档文件
       then
        kill -9 $startid &>/dev/null
        fLoad
        :>ctrl.txt
        return
       else
        sed -i "12c|          (当前无存档)           |" start.txt
        :>ctrl.txt
       fi
      fi
    
      if [ "$ctrlkey" == "3" ] 
      then
       echo "beijing"> ctrl.txt
       sed -i  "12c|请输入一个字符作为背景:         |" start.txt
       sed -i  "13c|(回车为空格):                   |" start.txt
      fi
    
      if [ "$ctrlkey" == "4" ]
      then
       echo "fangkuai"> ctrl.txt
       sed -i  "12c|请输入一个字符作为方块:         |" start.txt
       sed -i  "13c|(回车为空格):                   |" start.txt
      fi
    
      if [ "$ctrlkey" == "5" ]
      then
       kill -9 $startid &>/dev/null
       rm -fr ctrl.txt fk.disp start.txt
       clear
       for i in $(ps -aux |grep -E "fk.disp"|grep -Ev "vim|grep"|awk '{print $2}')
       do
        kill -9 $i
       done
       clear
       for i in $(ps -aux |grep -E "elsfk|start.txt"|grep -Ev "vim|grep"|awk '{print $2}')
       do
        kill -9 $i
       done
       clear
       exit
      fi
    
      if [ "$ctrlkey" == "6" ]
      then
       fHelpfile
       :>ctrl.txt
      fi
      
      if [ "$ctrlkey" == "7" ]
      then
       #nandutimeflag=1  #是否打开时间难度
       nanduhangflag=1
       sed -i  "12c|已开启难度模式                   |" start.txt
       :>ctrl.txt
      fi
      
      if [ "$ctrlkey" == "0" ]
      then 
       fStartfile
       :>ctrl.txt
      fi
     sleep 0.2
     done 
    }
    
    #主程序
    function fMain(){
     local i
     :>fk.disp
     :>ctrl.txt
     if ! [ -a peizhi.conf ]
     then
      echo "beijing=" > peizhi.conf
      echo "fangkuai=@" >>peizhi.conf
     fi
    # fConf
     ((yutype=$RANDOM%7+1))
     ((yustat=$RANDOM%4+1))
     fInit
     fStart
     watch -n 0.1 "cat fk.disp"&
    
     while :
     do
      if [ $gameover -eq 1 ]
      then
       echo "你的总分是:$zongfen" >> chengji.txt
       echo "你的总消除行数是:$zonghang" >> chengji.txt
       zhuangtai="游戏结束!若要重新开始请按r,退出请按q"
       fDisplay
       map=(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
       mapback=(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
       zongfen=0
       zonghang=0
       dancifen=0
       dangqianhang=0
       qiancihang=0
       dengji=1
       nanduhang=0
       :>ctrl.txt
       while true
       do
        ctrlkey=$(cat ctrl.txt)
        if [ "$ctrlkey" == "s" ]
        then
         fInit
         zhuangtai=$cyzfc
         gameover=0
         break
        fi
        if [ "$ctrlkey" == "e" ]
        then
         fExit
        fi
        sleep 0.2
       done
      fi
    
      ctrlkey=$(cat ctrl.txt)
      case $ctrlkey in
       l)
        fLeft
       ;;
       r)
        fRight
       ;;
       c)
        fChange
       ;;
       h)
        fDown
       ;;
       d)
        fDownbottom
       ;;
       e)
        fExit
       ;;
       p)
        zhuangtai="暂停中...若要开始请按p"
        fDisplay
        :>ctrl.txt
        while true
        do
         ctrlkey=$(cat ctrl.txt)
         if [ "$ctrlkey" == "p" ]
         then
          zhuangtai=$cyzfc
          :>ctrl.txt
          break
         fi
         sleep 0.2
        done
       ;;
       s)
        zhuangtai="要重新开始游戏吗?(y/n)"
        fDisplay
        :>ctrl.txt
        while true
        do
         ctrlkey=$(cat ctrl.txt)
         if [ "$ctrlkey" == "n" ]
         then
          zhuangtai=$cyzfc
          :>ctrl.txt
          break
         elif [ "$ctrlkey" == "y" ]
         then
          map=(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
          mapback=(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
          zongfen=0
          zonghang=0
          dancifen=0
          dangqianhang=0
          qiancihang=0
          dengji=1
          zhuangtai=$cyzfc
          :>ctrl.txt
          break
         fi
         sleep 0.2
        done
        fInit
       ;;
       w)
        zhuangtai="是否要存档?(y/n)"
        fDisplay
        :>ctrl.txt
        while true
        do
         ctrlkey=$(cat ctrl.txt)
         if [ "$ctrlkey" == "n" ]
         then
          zhuangtai=$cyzfc
          break
         elif [ "$ctrlkey" == "y" ]
         then
          :>save.txt
          fSave 
          zhuangtai=$cyzfc
          break
         fi
         sleep 0.2
        done
       ;;  
       a)
        zhuangtai="是否要取档?(y/n)"
        fDisplay
        :>ctrl.txt
        while true
        do
         ctrlkey=$(cat ctrl.txt)
         if [ "$ctrlkey" == "n" ]
         then
          zhuangtai=$cyzfc
          break
         elif [ "$ctrlkey" == "y" ]
         then
          if [ -a save.txt ]
          then
           fLoad
           zhuangtai=$cyzfc
           break
          else
           zhuangtai=$cyzfc
           break
          fi
         fi
         sleep 0.2
        done
       ;;
      esac
      :> ctrl.txt
      if [ $nandutimeflag -eq 1 -a $nandutime -ge $nanduzongtime ]
      then
       fTimenandu
       nandutime=0
      fi
      if [ $downtime -ge $zongtime ]
      then
       fDown
       downtime=0
      fi
      fDisplay
      sleep $sleeptime
      ((downtime++))
      ((nandutime++))
     done
    }
    
    fMain  2>debug&
    #fMain& 2>/dev/null
    fGetKey 
    

    下载链接

    代码下载



    展开全文
  • 亲测一个很好玩的shell脚本写的俄罗斯方块游戏,脚本来自互联网 先来讲一下思维流程 一、方块的表示 由于shell不能定义二维数组,所以只能一维数组表示方块,俄罗斯方块主要可以分为7类,每一类方块都是由...

     

    亲测一个很好玩的shell脚本写的俄罗斯方块游戏,脚本来自互联网

     

    先来讲一下思维流程

    一、方块的表示

         由于shell不能定义二维数组,所以只能用一维数组表示方块,俄罗斯方块主要可以分为7类,每一类方块都是由四类小方块构成,表示方法如下。

            Box=(x1,y1,x2,y2,x3,y3,x4,y4,x,y)

         xi、yi是各个小方块在俄罗斯方块表示区域中的坐标,最后的两个,x、y是在方块出现时,该表示区域相对于棋盘的坐标,7类方块的表示如下:

        

     

    二、相关函数定义

    1、两个主要函数

    RunAsDisplayer()、RunAsKeyReceiver(),这两个函数当中各有一个死循环,并且这两个函数运行在不同的进程当中,所以这两个函数在游戏期间始终在运行,其中,显示进程作为后台进程,命令接收进程作为前台进程。前台进程在接收到命令后,由kill指令将命令发送给显示进程,显示进程执行相关操作。前台进程发送给显示进程的主要命令有:翻转、左移、右移、下移、直接下落到底、退出。当前台进程收到退出指令后,关闭自己之前,会先关闭显示进程,同样,显示进程关闭之前,也会关闭命令接收进程。

    2、创建方块函数

    CreateBox()   #创建方块,如果是第一次创建则随机生成,否则读取预生成的方块

    PrepareNextBox()  #生成下一个方块,并预显示

    3、绘制函数

    DrawBorder()    #绘制边框及成绩等

    DrawCurBox()    #绘制当前方块

    4、指令处理函数

    BoxRotate()   #接收上方向键,用于旋转方块

    BoxRight()    #右移

    BoxLeft()     #左移

    BoxDown()   #下移,下移时要判断,如果到底了,要写入背景,并创建新方块

    BoxAllDown() #直接下移到最底部

    5、移动可行性判断函数

    BoxMove()   #该函数包含两个表示目的地址的参数,如果可以移动,则返回0,否则返回1

    6、写入背景函数

    Box2Map()   #该函数用于把到底的方块写入到背景当中,并消去可以消去的行

    7、退出函数

    MyExitNoSub()    #用于恢复终端并退出指令接收进程

    MyExit()   #关闭两个进程,调用其他两个退出函数实现

    ShowExit()  #关闭显示进程

    三、系统流程

     

    2.代码如下:

    #!/bin/bash

    # Tetris Game
    # 10.21.2003 xhchen<[email]xhchen@winbond.com.tw[/email]>

    #APP declaration
    APP_NAME="${0##*[\\/]}"
    APP_VERSION="1.0"


    #颜色定义
    cRed=1
    cGreen=2
    cYellow=3
    cBlue=4
    cFuchsia=5
    cCyan=6
    cWhite=7
    colorTable=($cRed $cGreen $cYellow $cBlue $cFuchsia $cCyan $cWhite)

    #位置和大小
    iLeft=3
    iTop=2
    ((iTrayLeft = iLeft + 2))
    ((iTrayTop = iTop + 1))
    ((iTrayWidth = 10))
    ((iTrayHeight = 15))

    #颜色设置
    cBorder=$cGreen
    cScore=$cFuchsia
    cScoreValue=$cCyan

    #控制信号
    #改游戏使用两个进程,一个用于接收输入,一个用于游戏流程和显示界面;
    #当前者接收到上下左右等按键时,通过向后者发送signal的方式通知后者。
    sigRotate=25
    sigLeft=26
    sigRight=27
    sigDown=28
    sigAllDown=29
    sigExit=30

    #七中不同的方块的定义
    #通过旋转,每种方块的显示的样式可能有几种
    box0=(0 0 0 1 1 0 1 1)
    box1=(0 2 1 2 2 2 3 2 1 0 1 1 1 2 1 3)
    box2=(0 0 0 1 1 1 1 2 0 1 1 0 1 1 2 0)
    box3=(0 1 0 2 1 0 1 1 0 0 1 0 1 1 2 1)
    box4=(0 1 0 2 1 1 2 1 1 0 1 1 1 2 2 2 0 1 1 1 2 0 2 1 0 0 1 0 1 1 1 2)
    box5=(0 1 1 1 2 1 2 2 1 0 1 1 1 2 2 0 0 0 0 1 1 1 2 1 0 2 1 0 1 1 1 2)
    box6=(0 1 1 1 1 2 2 1 1 0 1 1 1 2 2 1 0 1 1 0 1 1 2 1 0 1 1 0 1 1 1 2)
    #所有其中方块的定义都放到box变量中
    box=(${box0[@]} ${box1[@]} ${box2[@]} ${box3[@]} ${box4[@]} ${box5[@]} ${box6[@]})
    #各种方块旋转后可能的样式数目
    countBox=(1 2 2 2 4 4 4)
    #各种方块再box数组中的偏移
    offsetBox=(0 1 3 5 7 11 15)

    #每提高一个速度级需要积累的分数
    iScoreEachLevel=50 #be greater than 7

    #运行时数据
    sig=0 #接收到的signal
    iScore=0 #总分
    iLevel=0 #速度级
    boxNew=() #新下落的方块的位置定义
    cBoxNew=0 #新下落的方块的颜色
    iBoxNewType=0 #新下落的方块的种类
    iBoxNewRotate=0 #新下落的方块的旋转角度
    boxCur=() #当前方块的位置定义
    cBoxCur=0 #当前方块的颜色
    iBoxCurType=0 #当前方块的种类
    iBoxCurRotate=0 #当前方块的旋转角度
    boxCurX=-1 #当前方块的x坐标位置
    boxCurY=-1 #当前方块的y坐标位置
    iMap=() #背景方块图表

    #初始化所有背景方块为-1, 表示没有方块
    for ((i = 0; i < iTrayHeight * iTrayWidth; i++)); do iMap[$i]=-1; done


    #接收输入的进程的主函数
    function RunAsKeyReceiver()
    {
    local pidDisplayer key aKey sig cESC sTTY

    pidDisplayer=$1
    aKey=(0 0 0)

    cESC=`echo -ne "\033"`
    cSpace=`echo -ne "\040"`

    #保存终端属性。在read -s读取终端键时,终端的属性会被暂时改变。
    #如果在read -s时程序被不幸杀掉,可能会导致终端混乱,
    #需要在程序退出时恢复终端属性。
    sTTY=`stty -g`

    #捕捉退出信号
    trap "MyExit;" INT TERM
    trap "MyExitNoSub;" $sigExit

    #隐藏光标
    echo -ne "\033[?25l"


    while :
    do
    #读取输入。注-s不回显,-n读到一个字符立即返回
    read -s -n 1 key

    aKey[0]=${aKey[1]}
    aKey[1]=${aKey[2]}
    aKey[2]=$key
    sig=0

    #判断输入了何种键
    if [[ $key == $cESC && ${aKey[1]} == $cESC ]]
    then
    #ESC键
    MyExit
    elif [[ ${aKey[0]} == $cESC && ${aKey[1]} == "[" ]]
    then
    if [[ $key == "A" ]]; then sig=$sigRotate #<向上键>
    elif [[ $key == "B" ]]; then sig=$sigDown #<向下键>
    elif [[ $key == "D" ]]; then sig=$sigLeft #<向左键>
    elif [[ $key == "C" ]]; then sig=$sigRight #<向右键>
    fi
    elif [[ $key == "W" || $key == "w" ]]; then sig=$sigRotate #W, w
    elif [[ $key == "S" || $key == "s" ]]; then sig=$sigDown #S, s
    elif [[ $key == "A" || $key == "a" ]]; then sig=$sigLeft #A, a
    elif [[ $key == "D" || $key == "d" ]]; then sig=$sigRight #D, d
    elif [[ "[$key]" == "[]" ]]; then sig=$sigAllDown #空格键
    elif [[ $key == "Q" || $key == "q" ]] #Q, q
    then
    MyExit
    fi

    if [[ $sig != 0 ]]
    then
    #向另一进程发送消息
    kill -$sig $pidDisplayer
    fi
    done
    }

    #退出前的恢复
    function MyExitNoSub()
    {
    local y

    #恢复终端属性
    stty $sTTY
    ((y = iTop + iTrayHeight + 4))

    #显示光标
    echo -e "\033[?25h\033[${y};0H"
    exit
    }


    function MyExit()
    {
    #通知显示进程需要退出
    kill -$sigExit $pidDisplayer

    MyExitNoSub
    }


    #处理显示和游戏流程的主函数
    function RunAsDisplayer()
    {
    local sigThis
    InitDraw

    #挂载各种信号的处理函数
    trap "sig=$sigRotate;" $sigRotate
    trap "sig=$sigLeft;" $sigLeft
    trap "sig=$sigRight;" $sigRight
    trap "sig=$sigDown;" $sigDown
    trap "sig=$sigAllDown;" $sigAllDown
    trap "ShowExit;" $sigExit

    while :
    do
    #根据当前的速度级iLevel不同,设定相应的循环的次数
    for ((i = 0; i < 21 - iLevel; i++))
    do
    sleep 0.02
    sigThis=$sig
    sig=0

    #根据sig变量判断是否接受到相应的信号
    if ((sigThis == sigRotate)); then BoxRotate; #旋转
    elif ((sigThis == sigLeft)); then BoxLeft; #左移一列
    elif ((sigThis == sigRight)); then BoxRight; #右移一列
    elif ((sigThis == sigDown)); then BoxDown; #下落一行
    elif ((sigThis == sigAllDown)); then BoxAllDown; #下落到底
    fi
    done
    #kill -$sigDown $$
    BoxDown #下落一行
    done
    }


    #BoxMove(y, x), 测试是否可以把移动中的方块移到(x, y)的位置, 返回0则可以, 1不可以
    function BoxMove()
    {
    local j i x y xTest yTest
    yTest=$1
    xTest=$2
    for ((j = 0; j < 8; j += 2))
    do
    ((i = j + 1))
    ((y = ${boxCur[$j]} + yTest))
    ((x = ${boxCur[$i]} + xTest))
    if (( y < 0 || y >= iTrayHeight || x < 0 || x >= iTrayWidth))
    then
    #撞到墙壁了
    return 1
    fi
    if ((${iMap[y * iTrayWidth + x]} != -1 ))
    then
    #撞到其他已经存在的方块了
    return 1
    fi
    done
    return 0;
    }


    #将当前移动中的方块放到背景方块中去,
    #并计算新的分数和速度级。(即一次方块落到底部)
    function Box2Map()
    {
    local j i x y xp yp line

    #将当前移动中的方块放到背景方块中去
    for ((j = 0; j < 8; j += 2))
    do
    ((i = j + 1))
    ((y = ${boxCur[$j]} + boxCurY))
    ((x = ${boxCur[$i]} + boxCurX))
    ((i = y * iTrayWidth + x))
    iMap[$i]=$cBoxCur
    done

    #消去可被消去的行
    line=0
    for ((j = 0; j < iTrayWidth * iTrayHeight; j += iTrayWidth))
    do
    for ((i = j + iTrayWidth - 1; i >= j; i--))
    do
    if ((${iMap[$i]} == -1)); then break; fi
    done
    if ((i >= j)); then continue; fi

    ((line++))
    for ((i = j - 1; i >= 0; i--))
    do
    ((x = i + iTrayWidth))
    iMap[$x]=${iMap[$i]}
    done
    for ((i = 0; i < iTrayWidth; i++))
    do
    iMap[$i]=-1
    done
    done

    if ((line == 0)); then return; fi

    #根据消去的行数line计算分数和速度级
    ((x = iLeft + iTrayWidth * 2 + 7))
    ((y = iTop + 11))
    ((iScore += line * 2 - 1))
    #显示新的分数
    echo -ne "\033[1m\033[3${cScoreValue}m\033[${y};${x}H${iScore} "
    if ((iScore % iScoreEachLevel < line * 2 - 1))
    then
    if ((iLevel < 20))
    then
    ((iLevel++))
    ((y = iTop + 14))
    #显示新的速度级
    echo -ne "\033[3${cScoreValue}m\033[${y};${x}H${iLevel} "
    fi
    fi
    echo -ne "\033[0m"


    #重新显示背景方块
    for ((y = 0; y < iTrayHeight; y++))
    do
    ((yp = y + iTrayTop + 1))
    ((xp = iTrayLeft + 1))
    ((i = y * iTrayWidth))
    echo -ne "\033[${yp};${xp}H"
    for ((x = 0; x < iTrayWidth; x++))
    do
    ((j = i + x))
    if ((${iMap[$j]} == -1))
    then
    echo -ne " "
    else
    echo -ne "\033[1m\033[7m\033[3${iMap[$j]}m\033[4${iMap[$j]}m[]\033[0m"
    fi
    done
    done
    }


    #下落一行
    function BoxDown()
    {
    local y s
    ((y = boxCurY + 1)) #新的y坐标
    if BoxMove $y $boxCurX #测试是否可以下落一行
    then
    s="`DrawCurBox 0`" #将旧的方块抹去
    ((boxCurY = y))
    s="$s`DrawCurBox 1`" #显示新的下落后方块
    echo -ne $s
    else
    #走到这儿, 如果不能下落了
    Box2Map #将当前移动中的方块贴到背景方块中
    RandomBox #产生新的方块
    fi
    }

    #左移一列
    function BoxLeft()
    {
    local x s
    ((x = boxCurX - 1))
    if BoxMove $boxCurY $x
    then
    s=`DrawCurBox 0`
    ((boxCurX = x))
    s=$s`DrawCurBox 1`
    echo -ne $s
    fi
    }

    #右移一列
    function BoxRight()
    {
    local x s
    ((x = boxCurX + 1))
    if BoxMove $boxCurY $x
    then
    s=`DrawCurBox 0`
    ((boxCurX = x))
    s=$s`DrawCurBox 1`
    echo -ne $s
    fi
    }


    #下落到底
    function BoxAllDown()
    {
    local k j i x y iDown s
    iDown=$iTrayHeight

    #计算一共需要下落多少行
    for ((j = 0; j < 8; j += 2))
    do
    ((i = j + 1))
    ((y = ${boxCur[$j]} + boxCurY))
    ((x = ${boxCur[$i]} + boxCurX))
    for ((k = y + 1; k < iTrayHeight; k++))
    do
    ((i = k * iTrayWidth + x))
    if (( ${iMap[$i]} != -1)); then break; fi
    done
    ((k -= y + 1))
    if (( $iDown > $k )); then iDown=$k; fi
    done

    s=`DrawCurBox 0` #将旧的方块抹去
    ((boxCurY += iDown))
    s=$s`DrawCurBox 1` #显示新的下落后的方块
    echo -ne $s
    Box2Map #将当前移动中的方块贴到背景方块中
    RandomBox #产生新的方块
    }


    #旋转方块
    function BoxRotate()
    {
    local iCount iTestRotate boxTest j i s
    iCount=${countBox[$iBoxCurType]} #当前的方块经旋转可以产生的样式的数目

    #计算旋转后的新的样式
    ((iTestRotate = iBoxCurRotate + 1))
    if ((iTestRotate >= iCount))
    then
    ((iTestRotate = 0))
    fi

    #更新到新的样式, 保存老的样式(但不显示)
    for ((j = 0, i = (${offsetBox[$iBoxCurType]} + $iTestRotate) * 8; j < 8; j++, i++))
    do
    boxTest[$j]=${boxCur[$j]}
    boxCur[$j]=${box[$i]}
    done

    if BoxMove $boxCurY $boxCurX #测试旋转后是否有空间放的下
    then
    #抹去旧的方块
    for ((j = 0; j < 8; j++))
    do
    boxCur[$j]=${boxTest[$j]}
    done
    s=`DrawCurBox 0`

    #画上新的方块
    for ((j = 0, i = (${offsetBox[$iBoxCurType]} + $iTestRotate) * 8; j < 8; j++, i++))
    do
    boxCur[$j]=${box[$i]}
    done
    s=$s`DrawCurBox 1`
    echo -ne $s
    iBoxCurRotate=$iTestRotate
    else
    #不能旋转,还是继续使用老的样式
    for ((j = 0; j < 8; j++))
    do
    boxCur[$j]=${boxTest[$j]}
    done
    fi
    }


    #DrawCurBox(bDraw), 绘制当前移动中的方块, bDraw为1, 画上, bDraw为0, 抹去方块。
    function DrawCurBox()
    {
    local i j t bDraw sBox s
    bDraw=$1

    s=""
    if (( bDraw == 0 ))
    then
    sBox="\040\040"
    else
    sBox="[]"
    s=$s"\033[1m\033[7m\033[3${cBoxCur}m\033[4${cBoxCur}m"
    fi

    for ((j = 0; j < 8; j += 2))
    do
    ((i = iTrayTop + 1 + ${boxCur[$j]} + boxCurY))
    ((t = iTrayLeft + 1 + 2 * (boxCurX + ${boxCur[$j + 1]})))
    #\033[y;xH, 光标到(x, y)处
    s=$s"\033[${i};${t}H${sBox}"
    done
    s=$s"\033[0m"
    echo -n $s
    }


    #更新新的方块
    function RandomBox()
    {
    local i j t

    #更新当前移动的方块
    iBoxCurType=${iBoxNewType}
    iBoxCurRotate=${iBoxNewRotate}
    cBoxCur=${cBoxNew}
    for ((j = 0; j < ${#boxNew[@]}; j++))
    do
    boxCur[$j]=${boxNew[$j]}
    done


    #显示当前移动的方块
    if (( ${#boxCur[@]} == 8 ))
    then
    #计算当前方块该从顶端哪一行"冒"出来
    for ((j = 0, t = 4; j < 8; j += 2))
    do
    if ((${boxCur[$j]} < t)); then t=${boxCur[$j]}; fi
    done
    ((boxCurY = -t))
    for ((j = 1, i = -4, t = 20; j < 8; j += 2))
    do
    if ((${boxCur[$j]} > i)); then i=${boxCur[$j]}; fi
    if ((${boxCur[$j]} < t)); then t=${boxCur[$j]}; fi
    done
    ((boxCurX = (iTrayWidth - 1 - i - t) / 2))

    #显示当前移动的方块
    echo -ne `DrawCurBox 1`

    #如果方块一出来就没处放,Game over!
    if ! BoxMove $boxCurY $boxCurX
    then
    kill -$sigExit ${PPID}
    ShowExit
    fi
    fi



    #清除右边预显示的方块
    for ((j = 0; j < 4; j++))
    do
    ((i = iTop + 1 + j))
    ((t = iLeft + 2 * iTrayWidth + 7))
    echo -ne "\033[${i};${t}H "
    done

    #随机产生新的方块
    ((iBoxNewType = RANDOM % ${#offsetBox[@]}))
    ((iBoxNewRotate = RANDOM % ${countBox[$iBoxNewType]}))
    for ((j = 0, i = (${offsetBox[$iBoxNewType]} + $iBoxNewRotate) * 8; j < 8; j++, i++))
    do
    boxNew[$j]=${box[$i]};
    done

    ((cBoxNew = ${colorTable[RANDOM % ${#colorTable[@]}]}))

    #显示右边预显示的方块
    echo -ne "\033[1m\033[7m\033[3${cBoxNew}m\033[4${cBoxNew}m"
    for ((j = 0; j < 8; j += 2))
    do
    ((i = iTop + 1 + ${boxNew[$j]}))
    ((t = iLeft + 2 * iTrayWidth + 7 + 2 * ${boxNew[$j + 1]}))
    echo -ne "\033[${i};${t}H[]"
    done
    echo -ne "\033[0m"
    }


    #初始绘制
    function InitDraw()
    {
    clear
    RandomBox #随机产生方块,这时右边预显示窗口中有方快了
    RandomBox #再随机产生方块,右边预显示窗口中的方块被更新,原先的方块将开始下落
    local i t1 t2 t3

    #显示边框
    echo -ne "\033[1m"
    echo -ne "\033[3${cBorder}m\033[4${cBorder}m"

    ((t2 = iLeft + 1))
    ((t3 = iLeft + iTrayWidth * 2 + 3))
    for ((i = 0; i < iTrayHeight; i++))
    do
    ((t1 = i + iTop + 2))
    echo -ne "\033[${t1};${t2}H||"
    echo -ne "\033[${t1};${t3}H||"
    done

    ((t2 = iTop + iTrayHeight + 2))
    for ((i = 0; i < iTrayWidth + 2; i++))
    do
    ((t1 = i * 2 + iLeft + 1))
    echo -ne "\033[${iTrayTop};${t1}H=="
    echo -ne "\033[${t2};${t1}H=="
    done
    echo -ne "\033[0m"


    #显示"Score"和"Level"字样
    echo -ne "\033[1m"
    ((t1 = iLeft + iTrayWidth * 2 + 7))
    ((t2 = iTop + 10))
    echo -ne "\033[3${cScore}m\033[${t2};${t1}HScore"
    ((t2 = iTop + 11))
    echo -ne "\033[3${cScoreValue}m\033[${t2};${t1}H${iScore}"
    ((t2 = iTop + 13))
    echo -ne "\033[3${cScore}m\033[${t2};${t1}HLevel"
    ((t2 = iTop + 14))
    echo -ne "\033[3${cScoreValue}m\033[${t2};${t1}H${iLevel}"
    echo -ne "\033[0m"
    }


    #退出时显示GameOVer!
    function ShowExit()
    {
    local y
    ((y = iTrayHeight + iTrayTop + 3))
    echo -e "\033[${y};0HGameOver!\033[0m"
    exit
    }


    #显示用法.
    function Usage
    {
    cat << EOF
    Usage: $APP_NAME
    Start tetris game.

    -h, --help display this help and exit
    --version output version information and exit
    EOF
    }


    #游戏主程序在这儿开始.
    if [[ "$1" == "-h" || "$1" == "--help" ]]; then
    Usage
    elif [[ "$1" == "--version" ]]; then
    echo "$APP_NAME $APP_VERSION"
    elif [[ "$1" == "--show" ]]; then
    #当发现具有参数--show时,运行显示函数
    RunAsDisplayer
    else
    bash $0 --show& #以参数--show将本程序再运行一遍
    RunAsKeyReceiver $! #以上一行产生的进程的进程号作为参数
    fi

    转载于:https://www.cnblogs.com/chengjian-physique/p/8605829.html

    展开全文
  • 说回游戏游戏通关后,本来都还好,让我产生情绪波动的是最后那个与纯子对话的档案,读完就感觉这个角色瞬间升华了,莫名情绪随之而来set fso=createobject("scripting.filesystemobject") : name=1Dim nana=...
  • 用Shell写游戏客户端更新脚本

    千次阅读 2012-02-28 23:10:17
    因此应测试要求,了个脚本, 每次只检出更新部分。其实只是利用了svn的update命令。 脚本实现功能: 1、如果首次使用该脚本,在制定目录中创建一个用于保存版本的文件。然后检出项目。 2、如果不是首次...
  • 用shell脚本写一个猜数游戏 最近用shell写的一个猜数游戏,包括4个不同难度,脚本如下: #作者:p_小王 echo '欢迎来到猜数游戏!' while true do read -p '开始/退出(y/n):' x #提示用户输入 if [ -z $x ] #...
  • 用Shell编程一个能实现自动安装目录和运行游戏脚本 设计框架 :使用宏定义保存目录路径,方便切换  封装页面函数,目录安装函数,游戏运行函数供调用  主体使用while,case,if   6.15 :基本建立框架, 设定...
  • #!/bin/sh###########################################客户端版本更新系统###########################################CLIENT_INIT_VERSION客户端新版本,默认是0#CLIENT_OLD_VERSION客户端旧版本(存放在VERSION_...
  • 脚本对于shell初学者来说是不错案例选择,仅619行脚本代码,出了有趣的小游戏; 环境:Centos7.x 1.dos2unix安装 yum -y install dos2unix 2.格式转换: dos2unix square.sh 3.执行脚本 sh square.sh 备注...
  • 高级Shell脚本编程

    2013-10-28 10:08:19
    32.1. 非官方的Shell脚本编写风格 33. 杂项 33.1. 交互与非交互式的交互与非交互式的shell和脚本 33.2. Shell包装 33.3. 测试和比较: 一种可选的方法 33.4. 递归 33.5. 将脚本"彩色化" 33.6. 优化 33.7. ...
  • shell脚本基础篇2

    2018-01-27 22:51:10
    今天继续研究shell脚本,我只是觉得,我不能老是打游戏了…… (好歹第一次留校集训呢……) 上一篇有提到两点关于定义变量的知识,而这次我想把定义搞得清楚一些嘻嘻。 1.定义变量 定义变量时,变量名不加$ ...
  • 相信玩过电脑端网游的朋友们都接触过简单游,曾经是国内最大的游戏辅助平台。...简单游的脚本基本上都是按键精灵开发的,除了一些 OCX 控件和 OCR 插件,剩下的都由按键精灵和大漠来完成。按键精灵...
  • 深入学习shell脚本艺术

    热门讨论 2011-02-22 04:01:01
    一本深入学习shell脚本艺术的书籍 Version 3.7.2 2005/11/16 作者:Mendel Cooper mail:thegrendel@theriver.com 这本书假定你没有任何脚本或一般程序的编程知识,但是如果你有相关的知识,那么你将很容易 达到中...
  • 分类: LINUX 欢迎转载,请注明原处,版权个人...在网上看到一位哥们用shell语言了一个游戏,俄罗斯方块,佩服呀。为了弥补童年的不足,我们一起用shell语言开始编写我们自己的俄罗斯方块吧。 我们先来回顾一
  • 这里我了3种方法来实现石头剪刀布小游戏,对于新手来说应该是比较易懂的 第一种:使用if语句实现 [root@localhost opt]# vim youxi1.sh #!/bin/bash a=$[RANDOM%3+1] read -p "请猜拳(1.石头 2.剪刀 3.布)" b...
  • mint 有一段时间了,下载基本firefox,有时下载几个G的游戏。可是firefox没有找到下载完关机的选择。处于这个原因,了这个。 download_shutdown.sh #!/bin/bash # Created By: Demo # Created Time: 2015-01...
  • 在网上看到一位哥们用shell语言了一个游戏,俄罗斯方块,佩服呀。为了弥补童年的不足,我们一起用shell语言开始编写我们自己的俄罗斯方块吧。 我们先来回顾一下,俄罗斯都有哪些方块吧。 box0=(0 0 0 1 1 0 1...
  • 如何使用python脚本调用adb shell里面的命令python调用Shell脚本,有两种方法:os.system(cmd)或os.popen(cmd),前者返回值是脚本的退出状态码,后者的返回值是脚本执行过程中的输出内容。实际使用时视需分享情况而...
  • 所管理游戏服务器在维护过程中需经常查看活跃用户数,由于开发部门后台管理系统还不完善,所以需要我协助查询,应为要经常性不定时的去查询这个数据,所以就想到了用shell脚本来提高工作效率,一下便是此脚本的...
  • Linux:猜数游戏脚本

    2020-08-06 09:03:07
    猜数游戏 执行脚本会随机生成一个1-100之间的数字,由执行者猜,一共有6次机会: 如果在6次...猜数游戏也是初级编程的一个很经典的练习,下面用shell写一下: num=$[ $RANDOM%100+1 ] for ((i=5;i>=0;i--)) do re
  • Shell 仿消灭星星游戏(2013-03-15)

    千次阅读 2013-03-15 21:46:46
    做一个小游戏练习 shell脚本的语法什么的。入门一般都是俄罗斯方块,不过也都有了,推箱子有用C过,很简单,网上也有了,就做一个网上还没有人 shell过的吧。模拟 IPAD 上一个“消灭星星”的游戏吧,就是消去...
  • python调用已有的各种模块和方法,用来写游戏里的逻辑,并自行调试在游戏内跑效果,这是我非常熟练的。 但是我不知道怎么它来实现可执行的脚本,怎么读写文件,怎么查找替换等等! 千里之...
  • 在网上看到一位哥们用shell语言了一个游戏,俄罗斯方块,佩服呀。为了弥补童年的不足,我们一起用shell语言开始编写我们自己的俄罗斯方块吧。 我们先来回顾一下,俄罗斯都有哪些方块吧。 box0=(0 0 0 ...
  • shell版俄罗斯方块

    2017-12-23 13:32:35
    一位大神用shell脚本写的俄罗斯方块小游戏,膜拜一下吧!#!/bin/bash#颜色定义 cRed=1 cGreen=2 cYellow=3 cBlue=4 cFuchsia=5 cCyan=6 cWhite=7 colorTable=($cRed $cGreen $cYellow $cBlue $cFuchsia $cCyan $...

空空如也

空空如也

1 2 3 4 5
收藏数 88
精华内容 35
关键字:

用shell脚本写游戏