shell版俄罗斯方块 分类： shell版俄罗斯方块 2015-07-26 19:41 8人阅读 评论(0) 收藏

shell能是命令行解释器，shell脚本是命令的有序结合。在网上看到一位哥们用shell语言写了一个游戏，俄罗斯方块，佩服呀。为了弥补童年的不足，我们一起用shell语言开始编写我们自己的俄罗斯方块吧。
我们先来回顾一下，俄罗斯都有哪些方块吧。
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)
 
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 = ()东东，这个是什么呢？它是shell中的数组，后面括号里面放的是它的元素，即坐标点.
一起来看看shell中数组的语法吧
Bash中，数组变量的赋值有两种方法:
(1)name=(value1 ... valuen)此时小标从0开始
(2)name[index]=value
下面以一个简单的脚本来说明，脚本内容如下
#!/bin/bash
#定义数组
A=(a   b   c   def)
#把数组按字符串显示输出
echo ${A[@]}或echo ${A[*]}
显示:a  b  c   def
#数组的长度表示${#A[*]}
len=${#A[*]}或者len=${#A[@]}
echo ${#A[*]}
显示: 4
#改变数组元素的值
A[3] ="hello word"
echo ${A[*]}
显示：a  b  c  hello word
#循环输出数组
len=${#A[@]}
for  ((i =  0;i < len;i ++))
do
    echo -n "${A[i]}"
done
________________________________

((  i = 0 ))
while ((  i < len ))
do
    echo "${A[i]}"
    (( i = i + 1))
done
#循环输出数组元素的另一种写法,注意,${A[*]}不能写成$A,$A默认是第一个元素，如果A="a b c ded",就可以写$A
for value in ${A[*]}
do
echo $value
done
现在坐标点有了，那怎样把这些坐标点显示在屏幕上？这里我们要看一下shell中echo的用法
echo的基本语法不在进行讲解，我们来看一些其他的
echo 要变换颜色的时候，要使用-e
格式:echo -e "33[背景颜色;字体颜色m字符串33[0m"
eg:
    echo -e "33[41;36m something here 33[0m"
其中41的位置代表底色，36的位置是代表字的颜色
那些ascii code是对颜色调用的始末
33[;m ... 33[0m
例子:
    让字体变为红色并且不停的闪烁
echo -e "33[31m33[05m请确认是否要停止当前的sequid进程，输入[Y|N]33[0m"
字背景颜色范围：40 -- 49
40：黑      41:深红    42:绿    43:黄    44:蓝    45:紫    46:深绿    47:白色
字颜色:30 -- 39
30:黑     31:红    32:绿    33:黄     34:蓝     35:紫     36:深绿    37:白
ANSI控制码的说明
33[0m  关闭所有属性    33[1m设置高亮度    33[4m下划线     33[y;xH设置光标位置
到这里我们把我们要在屏幕显示的坐标点都显示出来吧:
 
 
效果:
 

到此我们终于可以在屏幕上画出东东了。


前面一节，我们在屏幕上画出了俄罗斯方块，现在我们让它动起来，呵呵，动起来...
思想就是通过改变x,y的坐标，在屏幕的不同地方绘制图形。
方法是通过方向键（A   S   D  W）来改变x,y的坐标。

先来看看shell中的信号处理吧

一、trap捕捉到信号之后，可以有三种反应方式

(1)执行一段程序来处理这一信号

(2)接受信号的默认操作

(3)忽视这一信号

二、trap对上面三种方式提供了三种基本形式

第一种形式的trap命令在shell接受到signal  list清单中数值相同的信号时，将执行双引号中的命令串。

trap 'commands' signal-list

trap "commands" signal-list

为了恢复信号的默认操作，使用第二种形式的trap命令:
trap signal-list

第三种形式的trap命令允许忽视信号
trap ""  signal-list

注意:

(1)对信号11(段违例)不能捕捉，因为shell本身需要捕捉该信号去进行内存的转储

(2)在trap中可以定义对信号0的处理(实际上没有这个信号),shell程序在其终止(如执行exit语句时) 发出该信号

(3)在捕捉到signal-list中指定的信号并执行完相应的命令之后，如果这些命令没有将shell程序终止的话，shell程序将继续执行收到信号时所执行的命令后面的命令

另外，在trap语句中，单引号和双引号是不同的，当shell程序第一次碰到trap语句时，将把commands中的命令扫描一遍。此时若commands是单引号括起来的话，那么shell不会对commands中的变量和命令进行替换，否则commands中的变量和命令将用当时具体的值来替换。

  1. #!/bin/bash
  3. SigA=20
  4. SigS=21
  5. SigD=22
  6. SigW=23
  7. sig=0
  9. function Register_Signal()
  10. {
  11. trap "sig=$SigA;" $SigA
  12. trap "sig=$SigS;" $SigS
  13. trap "sig=$SigD;" $SigD
  14. trap "sig=$SigW;" $SigW
  15. }
  17. function Recive_Signal()
  18. {
  19. Register_Signal
  21. while true
  22. do
  23. sigThis=$sig
  25. case "$sigThis" in
  26. "$SigA")
  27. echo "A"
  28. sig=0
  29. ;;
  31. "$SigS")
  32. echo "S"
  33. sig=0
  34. ;;
  36. "$SigD")
  37. echo "D"
  38. sig=0
  39. ;;
  41. "$SigW")
  42. echo "W"
  43. sig=0
  44. ;;
  45. esac
  47. done
  48. }
  50. function Kill_Signal()
  51. {
  52. local sigThis
  54. while :
  55. do
  56. read -s -n 1 key
  58. case "$key" in
  60. "W"|"w")
  61. kill -$SigW $1
  62. ;;
  63. "S"|"s")
  64. kill -$SigS $1
  65. ;;
  66. "A"|"a")
  67. kill -$SigA $1
  68. ;;
  69. "D"|"d")
  70. kill -$SigD $1
  71. ;;
  72. "Q"|"q")
  73. kill -9 $1
  74. exit
  75. esac
  77. done
  78. }
  80. if [[ "$1" == "--show" ]]
  81. then
  82. Recive_Signal
  83. else
  84. bash $0 --show &
  85. Kill_Signal $!
  86. fi
这段shell脚本的功能是:按下A  S  D  W键会打印出对应的字母，按下 Q键退出
 
上一节我们学了一下shell脚本中信号的用法，这一节我们在屏幕上画出一个方块，并且让它动起来.

box0=(0  0  0  1  1  0  1  1)
现在我们就让box0在我们屏幕的任意地方动起来
实现功能:
A  -> 左移    D->右移     W->向上     S->向下
思路就是通过改变x,y的坐标，在屏幕不同的地方，把box0画出来

  1. #!/bin/bash 

  3. #信号
  4. SigA=20
  5. SigS=21
  6. SigD=22
  7. SigW=23
  8. sig=0

  10. #方块在屏幕上的坐标点
  11. box0=(0 0 0 1 1 0 1 1)

  13. #边缘距离
  14. top=3
  15. left=3

  17. #当前x,y坐标
  18. currentX=15
  19. currentY=2

  21. function Draw_Box()
  22. {
  23.     local i j x y

  25.     if (($1 == 0))
  26.     then
  27.         for ((i = 0;i < 8;i += 2))
  28.         do
  29.             ((x = left + 3 * (currentX + ${box0[i]})))
  30.             ((y = top + currentY + ${box0[i+1]}))

  32.             echo -e "33[${y};${x}H "
  33.         done
  34.     else
  35.         echo -e "33[31m33[1m"
  36.         for ((i = 0;i < 8;i += 2))
  37.         do
  38.             ((x = left + 3 * (currentX + ${box0[i]})))
  39.             ((y = top + currentY + ${box0[i+1]}))

  41.             echo -e "33[${y};${x}H[*]"
  42.         done
  43.     fi

  45.     echo -e "33[0m"
  46. }

  48. function move_left()
  49. {    

  51.     if ((currentX == 0 ))
  52.     then
  53.         return 1;
  54.     fi

  56.     #先清除以前的方块
  57.     Draw_Box 0
  58.     
  59.     #改变x坐标
  60.     (( currentX -- ))
  61.     
  62.     #画出新的方块
  63.     Draw_Box 1

  65.     return 0;
  66. }


  69. function move_right()
  70. {    

  72.     if ((currentX > 20 ))
  73.     then
  74.         return 1;
  75.     fi

  77.     #先清除以前的方块
  78.     Draw_Box 0
  79.     
  80.     #改变x坐标
  81.     (( currentX ++ ))
  82.     
  83.     #画出新的方块
  84.     Draw_Box 1

  86.     return 0;
  87. }


  90. function move_up()
  91. {    

  93.     if ((currentY == 0 ))
  94.     then
  95.         return 1;
  96.     fi

  98.     #先清除以前的方块
  99.     Draw_Box 0
  100.     
  101.     #改变x坐标
  102.     (( currentY -- ))
  103.     
  104.     #画出新的方块
  105.     Draw_Box 1

  107.     return 0;
  108. }


  111. function move_down()
  112. {    

  114.     if ((currenty > 20 ))
  115.     then
  116.         return 1;
  117.     fi

  119.     #先清除以前的方块
  120.     Draw_Box 0
  121.     
  122.     #改变x坐标
  123.     (( currentY ++ ))
  124.     
  125.     #画出新的方块
  126.     Draw_Box 1

  128.     return 0;
  129. }


  132. function Register_Signal()
  133. {
  134.     trap "sig=$SigA;" $SigA
  135.     trap "sig=$SigS;" $SigS
  136.     trap "sig=$SigD;" $SigD
  137.     trap "sig=$SigW;" $SigW
  138. }

  140. function Recive_Signal()
  141. {
  142.     Register_Signal

  144.     Draw_Box 1

  146.     while true
  147.     do
  148.         sigThis=$sig

  150.         case "$sigThis" in
  151.             "$SigA")
  152.                 move_left
  153.                 sig=0
  154.                 ;;

  156.             "$SigS")
  157.                 move_down
  158.                 sig=0
  159.                 ;;

  161.             "$SigD")
  162.                 move_right
  163.                 sig=0
  164.                 ;;

  166.             "$SigW")
  167.                 move_up
  168.                 sig=0
  169.                 ;;
  170.         esac
  171.         
  172.     done
  173. }

  175. function Kill_Signal()
  176. {
  177.     local sigThis

  179.     while :
  180.     do
  181.         read -s -n 1 key
  182.         
  183.         case "$key" in

  185.             "W"|"w")
  186.                 kill -$SigW $1
  187.                 ;;
  188.             "S"|"s")
  189.                 kill -$SigS $1
  190.                 ;;
  191.             "A"|"a")
  192.                 kill -$SigA $1
  193.                 ;;
  194.             "D"|"d")
  195.                 kill -$SigD $1
  196.                 ;;
  197.             "Q"|"q")
  198.                 kill -9 $1
  199.                 exit
  200.      esac

  202.     done
  203. }

  205. if [[ "$1" == "--show" ]]
  206. then
  207.     Recive_Signal
  208. else
  209.     bash $0 --show &
  210.     Kill_Signal $!
  211. fi
效果图:
 
就到这吧，下一节我们随机产生方块，让后让它改变形状。

现在，我们知道，怎样在屏幕上画方块，怎样让方块移动，今天我们将实现，系统随机产生方块，并且让其动起来，嗯，动起来....
 
现在看看在shell中产生随机数的方法

一、通过时间获得随机数(date)

可以说时间是唯一的，也不会重复的，从这个里面获得同一时间的唯一值。

例子:
    date   +%s
注意:date   空格   +%s

如果用它做随机数，相同一秒的数据是一样的。多线程里面基本不能满足要求了。

date   +%N
这个相当精确了，就算在多cpu，大量循环里面，同一秒里面，也很难出现相同结果，不过不同时间里面还会有大量重复碰撞

date  +%s%N
这个可以说比较完美，加入时间戳，又加上纳秒

接下来我们看怎么获得数据内怎么样获得随机数
 
程序运行的结果:
 
 
二、通过内部系统变量($RANDOM)
其实，linux已经提供有个系统环境变量了，直接就是随机数
echo $RANDOM
通过它，我们可以获得的数据是一个小于或等于5位的整数
学完了随机数，我们让它帮助我们产生随机方块吧。
 
  1. #!/bin/bash 

  3. #七中不同的方块的定义
  4. #通过旋转，每种方块的显示的样式可能有几种
  5. box0=(0 0 0 1 1 0 1 1)
  6. box1=(0 2 1 2 2 2 3 2 1 0 1 1 1 2 1 3)
  7. box2=(0 0 0 1 1 1 1 2 0 1 1 0 1 1 2 0)
  8. box3=(0 1 0 2 1 0 1 1 0 0 1 0 1 1 2 1)
  9. 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)
  10. 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)
  11. 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)

  13. #把所有盒子放在box中
  14. box=(${box0[@]} ${box1[@]} ${box2[@]} ${box3[@]} ${box4[@]} ${box5[@]} ${box6[@]})

  16. #每个盒子在box中的偏移
  17. boxOffset=(0 1 3 5 7 11 15)

  19. #旋转次数
  20. rotateCount=(1 2 2 2 4 4 4)

  22. #颜色数组
  23. colourArry=(31 32 33 34 35 36 37)

  25. #选装类型
  26. rotateType=-1

  28. #盒子标号
  29. boxNum=-1

  31. #新盒子
  32. newBox=()

  34. #边缘距离
  35. top=3
  36. left=3

  38. #当前x,y坐标
  39. currentX=15
  40. currentY=2

  42. function Draw_Box()
  43. {
  44.     local i j x y

  46.     if (($1 == 0))
  47.     then
  48.         for ((i = 0;i < 8;i += 2))
  49.         do
  50.             ((x = left + 3 * (currentX + ${newBox[i]})))
  51.             ((y = top + currentY + ${newBox[i+1]}))

  53.             echo -e "33[${y};${x}H "
  54.         done
  55.     else
  56.         echo -e "33[${colourArry[$colourNum]}m33[1m"
  57.         for ((i = 0;i < 8;i += 2))
  58.         do
  59.             ((x = left + 3 * (currentX + ${newBox[i]})))
  60.             ((y = top + currentY + ${newBox[i+1]}))

  62.             echo -e "33[${y};${x}H[*]"
  63.         done
  64.     fi

  66.     echo -e "33[0m"
  67. }


  70. function Random_Box()
  71. {
  72.     #随机产生盒子号
  73.     (( boxNum = $RANDOM % 7 ))    
  74.     #随机长生盒子的类型
  75.     ((rotateType = $RANDOM % ${rotateCount[boxNum]}))
  76.     #随机产生颜色
  77.     ((colourNum = $RANDOM % ${#colourArry[*]}))

  79.     #找到所在box中的起始位置
  80.     ((j = ${boxOffset[boxNum]} * 8 + rotateType * 8))

  82.     for(( i = 0 ;i < 8;i ++))
  83.     do
  84.         ((newBox[i] = ${box[j+i]}))
  85.     done
  86. }

  88. while :
  89. do
  90.     Random_Box
  91.     Draw_Box 1
  92.     sleep 1
  93.     Draw_Box 0
  94. done
前面我们已经可以随机产生俄罗斯方块了，今天我们让它随键盘而改变
  1. #!/bin/bash 

  3. #七中不同的方块的定义
  4. #通过旋转，每种方块的显示的样式可能有几种
  5. box0=(0 0 0 1 1 0 1 1)
  6. box1=(0 2 1 2 2 2 3 2 1 0 1 1 1 2 1 3)
  7. box2=(0 0 0 1 1 1 1 2 0 1 1 0 1 1 2 0)
  8. box3=(0 1 0 2 1 0 1 1 0 0 1 0 1 1 2 1)
  9. 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)
  10. 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)
  11. 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)

  13. #把所有盒子放在box中
  14. box=(${box0[@]} ${box1[@]} ${box2[@]} ${box3[@]} ${box4[@]} ${box5[@]} ${box6[@]})

  16. #每个盒子在box中的偏移
  17. boxOffset=(0 1 3 5 7 11 15)

  19. #旋转次数
  20. rotateCount=(1 2 2 2 4 4 4)

  22. #颜色数组
  23. colourArry=(31 32 33 34 35 36 37)

  25. #选装类型
  26. rotateType=-1

  28. #盒子标号
  29. boxNum=-1

  31. #新盒子
  32. newBox=()

  34. #边缘距离
  35. top=3
  36. left=3

  38. #当前x,y坐标
  39. currentX=15
  40. currentY=2

  42. #信号
  43. SigA=20
  44. SigS=21
  45. SigD=22
  46. SigW=23
  47. sig=0

  49. #随机产生盒子
  50. function Random_Box()
  51. {
  52.     #随机产生盒子号
  53.     (( boxNum = $RANDOM % 7 ))    
  54.     #随机长生盒子的类型
  55.     ((rotateType = $RANDOM % ${rotateCount[boxNum]}))
  56.     #随机产生颜色
  57.     ((colourNum = $RANDOM % ${#colourArry[*]}))

  59.     #找到所在box中的起始位置
  60.     ((j = ${boxOffset[boxNum]} * 8 + rotateType * 8))

  62.     for(( i = 0 ;i < 8;i ++))
  63.     do
  64.         ((newBox[i] = ${box[j+i]}))
  65.     done
  66. }


  69. function Draw_Box()
  70. {
  71.     local i j x y


  74.     if (($1 == 0))
  75.     then
  76.         for ((i = 0;i < 8;i += 2))
  77.         do
  78.             ((x = left + 3 * (currentX + ${newBox[i]})))
  79.             ((y = top + currentY + ${newBox[i+1]}))

  81.             echo -e "33[${y};${x}H "
  82.         done
  83.     else
  84.         echo -e "33[${colourArry[$colourNum]}m33[1m"
  85.         for ((i = 0;i < 8;i += 2))
  86.         do
  87.             ((x = left + 3 * (currentX + ${newBox[i]})))
  88.             ((y = top + currentY + ${newBox[i+1]}))

  90.             echo -e "33[${y};${x}H[*]"
  91.         done
  92.     fi

  94.     echo -e "33[0m"
  95. }

  97. function move_left()
  98. {    
  99.     local temp

  101.     if (( currentX == 0 ))
  102.     then
  103.         return 1
  104.     fi
  105.     
  106.     #先清除以前的方块
  107.     Draw_Box 0
  108.     
  109.     #改变x坐标
  110.     (( currentX -- ))
  111.     
  112.     #画出新的方块
  113.     Draw_Box 1

  115.     return 0
  116. }


  119. function move_right()
  120. {    

  122.     if ((currentX > 20 ))
  123.     then
  124.         return 1;
  125.     fi

  127.     #先清除以前的方块
  128.     Draw_Box 0
  129.     
  130.     #改变x坐标
  131.     (( currentX ++ ))
  132.     
  133.     #画出新的方块
  134.     Draw_Box 1

  136.     return 0;
  137. }

  139. #记录已经旋转的方块次数
  140. tempCount=0

  142. #按下w键旋转处理
  143. function box_rotate()
  144. {
  145.     local start_post
  146.     
  147.     ((tempCount ++))
  148.     #echo ${rotateCount[boxNum]}
  149.     if ((tempCount >= ${rotateCount[boxNum]}))
  150.     then
  151.         ((tempCount = 0))
  152.     fi

  154.     #每个盒子在box中的始位置
  155.     ((start_post = ${boxOffset[boxNum]} * 8 + tempCount * 8))

  157.     for ((i = 0;i < 8;i ++))
  158.     do
  159.         ((newBox[i] = ${box[start_post+i]}))
  160.     done

  162.     return 0
  163. }

  165. function move_rotate()
  166. {    

  168.     if ((currentY == 0 ))
  169.     then
  170.         return 1;
  171.     fi

  173.     #先清除以前的方块
  174.     Draw_Box 0
  175.     
  176.     #改变当前方块的形状
  177.     box_rotate
  178.         
  179.     #画出新的方块
  180.     Draw_Box 1

  182.     return 0;
  183. }


  186. function move_down()
  187. {    

  189.     if ((currenty > 20 ))
  190.     then
  191.         return 1;
  192.     fi

  194.     #先清除以前的方块
  195.     Draw_Box 0
  196.     
  197.     #改变x坐标
  198.     (( currentY ++ ))
  199.     
  200.     #画出新的方块
  201.     Draw_Box 1

  203.     return 0;
  204. }


  207. function Register_Signal()
  208. {
  209.     trap "sig=$SigA;" $SigA
  210.     trap "sig=$SigS;" $SigS
  211.     trap "sig=$SigD;" $SigD
  212.     trap "sig=$SigW;" $SigW
  213. }

  215. function Recive_Signal()
  216. {

  218.     Random_Box
  219.     Draw_Box 1
  220.     Register_Signal

  222.     while true
  223.     do
  224.         sigThis=$sig

  226.         case "$sigThis" in
  227.             "$SigA")
  228.                 move_left
  229.                 sig=0
  230.                 ;;

  232.             "$SigS")
  233.                 move_down
  234.                 sig=0
  235.                 ;;

  237.             "$SigD")
  238.                 move_right
  239.                 sig=0
  240.                 ;;

  242.             "$SigW")
  243.                 move_rotate
  244.                 sig=0
  245.                 ;;
  246.         esac
  247.         
  248.     done
  249. }

  251. function Kill_Signal()
  252. {
  253.     local sigThis

  255.     while :
  256.     do
  257.         read -s -n 1 key
  258.         
  259.         case "$key" in

  261.             "W"|"w")
  262.                 kill -$SigW $1
  263.                 ;;
  264.             "S"|"s")
  265.                 kill -$SigS $1
  266.                 ;;
  267.             "A"|"a")
  268.                 kill -$SigA $1
  269.                 ;;
  270.             "D"|"d")
  271.                 kill -$SigD $1
  272.                 ;;
  273.             "Q"|"q")
  274.                 kill -9 $1
  275.                 exit
  276.      esac

  278.     done
  279. }

  281. if [[ "$1" == "--show" ]]
  282. then
  283.     Recive_Signal
  284. else
  285.     bash $0 --show &
  286.     Kill_Signal $!
  287. fi
效果图:
 
红色部分是我们今天写的代码，思路是使用随机产生的盒子号确定此盒子在box中的位置，然后从此位置开始，把它的所有造型在屏幕上挨个画出来。
到现在为止，我们可以随机产生俄罗斯方块，并且可以移动和改变，下一节我们在屏幕上画出一个矩阵，让盒子从矩阵的顶部自动下落，到矩阵的底部停止。
 
我们现在屏幕上画出一个矩阵,这个很简单
  1. #!/bin/bash 

  3. clear

  5. #边缘距离
  6. left=10
  7. top=5

  9. #矩阵的长和宽
  10. widthSize=25
  11. hightSize=25

  13. #画出矩阵
  14. function draw_rectangle()
  15. {
  16.     local x y

  18.     echo -e "33[32m33[46m33[1m"

  20.     for ((i = 0 ;i < widthSize;i ++))
  21.     do
  22.         ((x = left + i))
  23.         ((y = top + hightSize - 1))
  24.     
  25.         echo -e "33[${top};${x}H="
  26.         echo -e "33[${y};${x}H="

  28.     done

  30.     for ((i = 0 ;i < hightSize;i ++))
  31.     do
  32.         ((x = left + widthSize - 1))
  33.         ((y = top + i))
  34.     
  35.         echo -e "33[${y};${left}H||"
  36.         echo -e "33[${y};${x}H||"

  38.     done

  40.     echo -e "33[0m"
  41. }

  43. draw_rectangle
效果图:
 
矩阵有了，接下来就是让盒子从矩阵的顶部下落下来到底部停止
  1. #!/bin/bash 

  3. #七中不同的方块的定义
  4. #通过旋转，每种方块的显示的样式可能有几种
  5. box0=(0 0 0 1 1 0 1 1)
  6. box1=(0 2 1 2 2 2 3 2 1 0 1 1 1 2 1 3)
  7. box2=(0 0 0 1 1 1 1 2 0 1 1 0 1 1 2 0)
  8. box3=(0 1 0 2 1 0 1 1 0 0 1 0 1 1 2 1)
  9. 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)
  10. 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)
  11. 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)

  13. #把所有盒子放在box中
  14. box=(${box0[@]} ${box1[@]} ${box2[@]} ${box3[@]} ${box4[@]} ${box5[@]} ${box6[@]})

  16. #每个盒子在box中的偏移
  17. boxOffset=(0 1 3 5 7 11 15)

  19. #旋转次数
  20. rotateCount=(1 2 2 2 4 4 4)

  22. #颜色数组
  23. colourArry=(31 32 33 34 35 36 37)

  25. #选装类型
  26. rotateType=-1

  28. #盒子标号
  29. boxNum=-1

  31. #新盒子
  32. newBox=()

  34. #边缘距离
  35. left=10
  36. top=5

  38. #矩阵的长和宽
  39. widthSize=28
  40. hightSize=26

  42. #确定从矩阵那个地方出来
  43. function ensure_postion()
  44. {
  45.     local sumx=0 i j

  47.     ((minx = ${newBox[0]}))
  48.     ((miny = ${newBox[1]}))
  49.     ((maxy = miny ))
  50.     
  51.     for ((i = 2; i < ${#newBox[*]};i += 2))
  52.     do 
  53.         #确定最小的x坐标
  54.         if ((minx > ${newBox[i]}))
  55.         then
  56.             ((minx = ${newBox[i]}))
  57.         fi
  58.         
  59.         #确定最小的y坐标
  60.         if ((miny > ${newBox[i+1]}))
  61.         then
  62.             ((miny = ${newBox[i+1]}))
  63.         fi

  65.         if ((${newBox[i]} == ${newBox[i-2]}))
  66.         then
  67.             continue
  68.         fi
  69.         
  70.         ((sumx ++))

  72.     done

  74.     if ((sumx == 0))
  75.     then
  76.         ((sumx = 1))
  77.     fi
  78.     
  79.     #当前x,y坐标
  80.     ((currentX = left + widthSize / 2 - sumx * 2 - minx))
  81.     ((currentY = top + 1 - miny))    

  83.     return 0
  84. }

  86. #画出矩阵
  87. function draw_rectangle()
  88. {
  89.     local x y

  91.     echo -e "33[32m33[46m33[1m"

  93.     for ((i = 0 ;i < widthSize;i ++))
  94.     do
  95.         ((x = left + i))
  96.         ((y = top + hightSize - 1))
  97.     
  98.         echo -e "33[${top};${x}H="
  99.         echo -e "33[${y};${x}H="

  101.     done

  103.     for ((i = 0 ;i < hightSize;i ++))
  104.     do
  105.         ((x = left + widthSize - 1))
  106.         ((y = top + i))
  107.     
  108.         echo -e "33[${y};${left}H||"
  109.         echo -e "33[${y};${x}H||"

  111.     done

  113.     echo -e "33[0m"
  114. }


  117. #画出方块
  118. function Draw_Box()
  119. {
  120.     local i j x y

  122.     if (($1 == 0))
  123.     then
  124.         for ((i = 0;i < 8;i += 2))
  125.         do
  126.             ((x = currentX + 3 * ${newBox[i]}))
  127.             ((y = currentY + ${newBox[i+1]}))

  129.             echo -e "33[${y};${x}H "
  130.         done
  131.     else
  132.         echo -e "33[${colourArry[$colourNum]}m33[1m"
  133.         for ((i = 0;i < 8;i += 2))
  134.         do
  135.             ((x = currentX + 3 * ${newBox[i]}))
  136.             ((y = currentY + ${newBox[i+1]}))

  138.             echo -e "33[${y};${x}H[*]"
  139.         done
  140.     fi

  142.     echo -e "33[0m"
  143. }

  145. #随机产生方块
  146. function Random_Box()
  147. {
  148.     #随机产生盒子号
  149.     (( boxNum = $RANDOM % 7 ))    
  150.     #随机长生盒子的类型
  151.     ((rotateType = $RANDOM % ${rotateCount[boxNum]}))
  152.     #随机产生颜色
  153.     ((colourNum = $RANDOM % ${#colourArry[*]}))

  155.     #找到所在box中的起始位置
  156.     ((j = ${boxOffset[boxNum]} * 8 + rotateType * 8))

  158.     for(( i = 0 ;i < 8;i ++))
  159.     do
  160.         ((newBox[i] = ${box[j+i]}))
  161.     done
  162. }

  164. #判断能否下移
  165. function move_test()
  166. {
  167.     local vary=$1 i
  168.     
  169.     #当前的y坐标加上newBox里面的坐标,其值是否大于28
  170.     for ((i = 0;i < ${#newBox[@]}; i += 2))
  171.     do
  172.         if ((vary + ${newBox[i+1]} > 28))
  173.         then
  174.             return 0
  175.         fi
  176.     done

  178.     return 1
  179. }


  182. draw_rectangle
  183. Random_Box
  184. ensure_postion

  186. while :
  187. do
  188.     Draw_Box 1

  190.     sleep 0.1
  191.     Draw_Box 0

  193.     ((currentY ++))

  195.     if move_test currentY
  196.     then
  197.         Draw_Box 1
  198.         sleep 2
  199.         Draw_Box 0
  200.         Random_Box
  201.         ensure_postion
  202.     fi

  204. done

  206. echo
效果图:
下一次，我们实现通过键盘改变方块形状和移动方块，并且实现累加


原文：chengyaogen.blog.chinaunix.net

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/zclzqbx/p/4687042.html