home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / CLIPPER / MISC / BIPL.ZIP / PROGS.ZIP / TTT.ICN < prev    next >
Encoding:
Text File  |  1992-09-28  |  7.2 KB  |  303 lines
  1. ############################################################################
  2. #
  3. #    File:     ttt.icn
  4. #
  5. #    Subject:  Program to play tic-tac-toe
  6. #
  7. #    Author:   Chris Tenaglia
  8. #
  9. #    Date:     December 23, 1991
  10. #
  11. ###########################################################################
  12.  
  13. global me,you,true,false,draw,pointer,wins,pass,taken,winner
  14. global mark,row,routes,route
  15.  
  16. procedure main()
  17.   local again, index, path, play, square, tmp, victory, your_last_move
  18.  
  19.   init()
  20.   play := true
  21.   while play == true do
  22.     {
  23.     me      := set()      # computer is me
  24.     you     := set()      # player   is you
  25.     victory := ""         # nobodys' won yet
  26.     winner  := ""         # winner flag
  27.     pass    := 0          # start flag
  28.     taken   := table(false)    # taken position table (rather than set?)
  29.     display()
  30. #
  31. # computer makes first move
  32. #
  33.     insert(me,1)
  34.     taken[1] := true
  35.     display()
  36. #
  37. # player follows
  38. #
  39.     insert(you,(tmp := integer(get_your_move())))
  40.     taken[integer(tmp)] := true
  41.     display()
  42.     path := routes[tmp]              # players' move determines strategy
  43.     index := 2                       # points at 2nd move just happened
  44.  
  45. #
  46. # computers' next move determined from strategy list
  47. #
  48.     insert(me,(tmp := integer(path[(index+:=1)])))
  49.     taken[tmp] := true
  50.     display()
  51. #
  52. # player follows
  53. #
  54.     insert(you,(tmp := integer(get_your_move())))
  55.     taken[integer(tmp)] := true
  56.     your_last_move := tmp
  57.     display()
  58. #
  59. # if didn't take position dictated, loss ensues
  60. #
  61.     if your_last_move ~= (tmp := integer(path[(index+:=1)])) then
  62.       {
  63.       winner := "me"
  64.       insert(me,tmp)
  65.       taken[tmp] := true
  66.       display()
  67.       done_yet()
  68.       write(at(1,22),chop(&host)," Wins, You Loose!")
  69.       every square := !row do writes(pointer[square],mark)
  70.       again := map(input(at(1,23) || "Another game? Y/N :"))[1]
  71.       if again=="y" then next
  72.       stop(at(1,23),"Game Over.",chop())
  73.       }
  74.  
  75. #
  76. # user made a good move, continue (computer plays now)
  77. #
  78.     insert(me,(tmp := integer(path[(index+:=1)])))
  79.     taken[tmp] := true
  80.     display()
  81. #
  82. # player follows
  83. #
  84.     insert(you,(tmp := integer(get_your_move())))
  85.     taken[integer(tmp)] := true
  86.     your_last_move := tmp
  87.     display()
  88.  
  89. #
  90. # if didn't take position dictated, loss ensues
  91. #
  92.     if your_last_move ~= (tmp := integer(path[(index+:=1)])) then
  93.       {
  94.       winner := "me"
  95.       insert(me,tmp)
  96.       taken[tmp] := true
  97.       display()
  98.       done_yet()
  99.       write(at(1,22),chop(&host)," Wins, You Loose!")
  100.       every square := !row do writes(pointer[square],mark)
  101.       again := map(input(at(1,23) || "Another game? Y/N :"))[1]
  102.       if again=="y" then next
  103.       stop(at(1,23),"Game Over.",chop())
  104.       }
  105. #
  106. # if players first move wasn't 5, they lose now too
  107. #
  108.     if integer(path[2]) ~= 5 then
  109.       {
  110.       tmp := integer(path[(index+:=1)])
  111.       winner := "me"
  112.       insert(me,tmp)
  113.       taken[tmp] := true
  114.       display()
  115.       done_yet()
  116.       write(at(1,22),chop(&host)," Wins, You Loose!")
  117.       every square := !row do writes(pointer[square],mark)
  118.       again := map(input(at(1,23) || "Another game? Y/N :"))[1]
  119.       if again=="y" then next
  120.       stop(at(1,23),"Game Over.",chop())
  121.       }
  122.  
  123. #
  124. # user made a good move, continue (computer plays now)
  125. #
  126.     insert(me,(tmp := integer(path[(index+:=1)])))
  127.     taken[tmp] := true
  128.     display()
  129.     write(at(1,22),chop(),"Game was a draw.")
  130.     again := map(input(at(1,23) || "Another game? Y/N :"))[1]
  131.     if again=="y" then next
  132.     stop(at(1,23),"Game Over.",chop())
  133.     }
  134.   end
  135. #
  136. # procedure to display the current tictactoe grid and plays
  137. #               
  138. procedure display()
  139.   local line, x, y
  140.  
  141.   if (pass +:= 1) = 1 then
  142.     {
  143.     write(cls(),uhalf(),"          T I C - T A C - T O E")
  144.     write(lhalf(),"          T I C - T A C - T O E")
  145.     write(trim(center("Computer is 'O' and you are 'X'",80)))
  146.     line := repl("q",60) ; line[21] := "n" ; line[41] := "n"
  147.     every y := 5 to 20 do writes(at(30,y),graf("x"))
  148.     every y := 5 to 20 do writes(at(50,y),graf("x"))
  149.     writes(at(10,10),graf(line))
  150.     writes(at(10,15),graf(line))
  151.     every x := 1 to 9  do writes(pointer[x],dim(x))
  152.     }
  153.   every writes(pointer[!me],high("O"))
  154.   every writes(pointer[!you],under("X"))
  155.   end
  156.                 
  157. #
  158. # procedure to obtain a move choice from the player
  159. #
  160. procedure get_your_move()
  161.   local yours,all_moves
  162.   repeat {
  163.   writes(at(5,22))
  164.   yours := input("Enter block # (1-9) :")
  165.   writes(at(5,23),chop())
  166.   if not(integer(yours)) then
  167.     {
  168.     writes(at(5,23),beep(),"Invalid Input! Choose 1-9.")
  169.     next
  170.     }
  171.   if (1 > yours) | (yours > 9) then
  172.     {
  173.     writes(at(5,23),beep(),"Value out of range! Choose 1-9.")
  174.     next
  175.     }
  176.   if taken[integer(yours)] == true then
  177.     {
  178.     writes(at(5,23),beep(),"That position is already taken! Try again.")
  179.     next
  180.     }
  181.   break }
  182.   return integer(yours)
  183.   end
  184.  
  185. #
  186. # procedure to test if computer has won, or the game is a draw
  187. #
  188. procedure done_yet()
  189.   local outcome, test, part
  190.  
  191.   every outcome := !wins do
  192.     {
  193.     test := 0
  194.     every part := !outcome do
  195.       if member(you,part) then test +:= 1
  196.     if test = 3 then
  197.       {
  198.       winner := "you"
  199.       row    := outcome
  200.       mark   := high(blink("X"))
  201.       return true
  202.       }
  203.     }
  204.   every outcome := !wins do
  205.     {
  206.     test := 0
  207.     every part := !outcome do
  208.       if member(me,part) then test +:= 1
  209.     if test = 3 then
  210.       {
  211.       winner := "me"
  212.       row    := outcome
  213.       mark   := high(blink("O"))
  214.       return true
  215.       }             
  216.     }
  217.   if *me + *you > 8 then
  218.     {
  219.     winner := draw
  220.     return draw
  221.     }
  222.   return "not done yet"
  223.   end
  224. #
  225. # prompts for an input from the user
  226. #
  227. procedure input(prompt)
  228.   writes(prompt)
  229.   return read()
  230.   end
  231. #
  232. # procedures to output ansi graphics and attributes
  233. #
  234. procedure at(x,y)
  235.   return "\e[" || y || ";" || x || "f"
  236.   end
  237.   
  238. procedure graf(str)
  239.   return "\e(0" || str || "\e(B"
  240.   end
  241.  
  242. procedure uhalf(str)
  243.   /str := ""
  244.   return "\e#3" || str
  245.   end
  246.  
  247. procedure lhalf(str)
  248.   /str := ""
  249.   return "\e#4" || str
  250.   end
  251.  
  252. procedure high(str)
  253.   return "\e[1m" || str || "\e[0m"
  254.   end
  255.  
  256. procedure normal(str)
  257.   return "\e[0m" || str
  258.   end
  259.  
  260. procedure dim(str)
  261.   return "\e[2m" || str || "\e[0m"
  262.   end
  263.   
  264. procedure under(str)
  265.   return "\e[4m" || str || "\e[0m"
  266.   end
  267.  
  268. procedure blink(str)
  269.   return "\e[5m" || str || "\e[0m"
  270.   end
  271.  
  272. procedure cls(str)
  273.   /str := ""
  274.   return "\e[2J\e[H" || str
  275.   end
  276.  
  277. procedure chop(str)
  278.   /str := ""
  279.   return "\e[J" || str
  280.   end
  281.  
  282. procedure beep()
  283.   return "\7"
  284.   end
  285. #
  286. # procedure to init useful global variables for later use
  287. #
  288. procedure init()
  289.   true    := "y"
  290.   false   := "n"
  291.   draw    := "?"
  292.   &random := map(&clock,":","0")
  293.   routes  := ["-","1274958","1374958","1432956","1547328",
  294.                   "1632745","1732956","1874352","1974352"]
  295.   wins    := [set([1,5,9]),set([3,5,7]),set([1,2,3]),set([4,5,6]),
  296.               set([7,8,9]),set([1,4,7]),set([2,5,8]),set([3,6,9])]
  297.   pointer := [at(17,7), at(37,7), at(57,7),
  298.               at(17,12),at(37,12),at(57,12),
  299.               at(17,17),at(37,17),at(57,17)]
  300.   end
  301.   
  302.  
  303.