Páginas

domingo, 3 de março de 2013

skribu-kun-python-cxap15

fonto: http://inventwithpython.com/chapter15.html

Temoj Kovritaj dum tiu ĉapitro:

  • La bool () Funkcio
  • Taksante Ne-Bulea Valoroj kiel Booleans

Kiel Ludi Reversi

En ĉi tiu ĉapitro ni faros ludon kiu ni nomas Reverson. Reversi (ankaŭ nomita Othello) estas tabulo ludo kiu estas ludata sur krado (do ni uzos karteziaj koordinatoj kun XY koordinatoj, kiel ni faris kun Soni.) Ĝi estas ludo ludata per du ludantoj. Nia versio de la ludo havos komputilon AI tio estas pli progresintaj ol la AI ni faris por Tic Tac Toe. Fakte, ĉi AI estas tiel bona ke ĝi probable batis vi preskaŭ ĉiufoje kiam vi ludas. (Mi scias ke mi perdas kiam mi ludas kontraŭ ĝi!)
Se vi ŝatus vidi la video de Reversi estante ludita, ne estas pruvo en ĉi tiu libro de afiŝinto. Iru al la retadreso http://inventwithpython.com/videos kaj trovi la "Reversi Demo Video" video.
Reversi havas 8 x 8 tabulo kun azuleĥoj kiuj estas nigraj en unu flanko kaj celo sur la alia (nia ludo uzos ho aj kaj X kvankam). La komenca tabulo aspektas kiel Figuro 15-1. Ĉiu ludanto prenas turni metante malsupren nova kahelo de ilia koloro. Iu el la kontraŭulo azuleĥoj kiuj estas inter la nova kahelo kaj la alia azuleĥoj de tiu koloro estas spegulita. La celo de la ludo estas havi kiel multaj el la tegoloj kun via koloro ebla. Ekzemple, Figuro 15-2 estas kia gxi aspektas kvazaŭ la blanka ludanto metas novan blankan kahelo en spaco 5, 6.
Figuro 15-1: La komenca Reversi tabulo
havas du blankajn azuleĥoj kaj du nigraj tegoloj. 		Figuro 15-2: Blanka metas novan kahelo.
La nigra kahelo en 5, 5 estas inter la nova blanka kahelo kaj la ekzistantaj blanka kahelo en 5, 4. Tiu nigra kahelo estas spegulita super kaj iĝas nova blanka kahelo, farante la estraro aspekti Figuro 15-3. Nigra faras similan movadon proksima, metante nigra kahelo la 4, 6 kiu klakas la blankaj kaheloj al 4, 5. Ĉi tiuj rezultoj en tabulo kiu similas Figuro 15-4.
Figuro 15-3: White movado volo
klaki sur unu el nigra kaheloj. 		Figuro 15-4: Nigra lokoj nova azuleĥo,
kiu klakas sur unu el la blankaj kaheloj.
Azuleĥoj en ĉiuj direktoj estas spegulita tiel longe kiel ili estas inter la ludanto nova kahelo kaj ekzistantaj kahelo. En Figuro 15-5, la blanka ludanto metas kahelo en 3, 6 kaj klakas nigra azuleĥoj en ambaŭ direktoj (markita de la linioj.) La rezulto estas en Figuro 15-6.
Figuro 15-5: blanka, la dua movado
ĉe 3, 6 estos klaki du el nigra kaheloj. 		Figuro 15-6: La estraro post blanka, la dua movado.
Kiel vi povas vidi, ĉiu ludanto povas rapide rabi plimulto de la kaheloj sur la tabulo en nur unu aŭ du movojn. Ludantoj devas ĉiam fari movado kiu kaptas almenaŭ unu kahelo. La ludo finas kiam ludanto ĉu ne povas fari movon, aŭ la tabulo estas tute plena. La ludanto kun la plej azuleĥoj de ilia koloro gajnas.
La baza strategio de Reversi estas serĉi en kiu movado igus super la plej kaheloj. Sed vi devas ankaŭ konsideri preni movado kiu ne lasos vian kontraŭulon recaptura multaj azuleĥoj post via movado. Metante kahelo en la flankojn aŭ, eĉ pli bone, la anguloj estas bona ĉar estas malpli ŝanco ke tiuj kaheloj finos inter via kontraŭulo kaheloj. La AI ni faras por tiu ĉi ludo simple serĉi ajna angulo movas ili povas preni. Se ne estas angulo movas havebla, tiam la komputilo elektos la movado kiu postulas la plej kaheloj.
Vi povas lerni pli pri Reversi el Vikipedio: http://en.wikipedia.org/wiki/Reversi

Specimeno Run

Rimarku ke nia versio de Reverso ne uzas nigrajn kaj blankajn kahelojn ĉar la teksto kiun nia programo kreas ĉiam estos la sama koloro. Anstataŭe, ni uzos X kaj O po reprezenti la homan kaj komputikan ludojn.
Bonvenon Reverso!
Ĉu vi volas esti X aŭ O?
x
La ludanto iros unue.
1 2 3 4 5 6 7 8
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
1 | | | | | | | | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
2 | | | | | | | | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
3 | | | | | | | | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
4 | | | | X | ho | | | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
5 | | | | ho | X | | | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
6 | | | | | | | | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
7 | | | | | | | | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
8 | | | | | | | | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
Vi havas 2 punktoj. La komputilo havas 2 punktoj.
Entajpu vian movadon, aŭ tipo quit fini la ludon, aŭ aludojn al elŝalti / en aludoj.
53
1 2 3 4 5 6 7 8
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
1 | | | | | | | | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
2 | | | | | | | | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
3 | | | | | X | | | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
4 | | | | X | X | | | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
5 | | | | ho | X | | | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
6 | | | | | | | | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
7 | | | | | | | | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
8 | | | | | | | | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
Vi havas 4 punktoj. La komputilo havas 1 punktoj.
Premu Enter por vidi la komputilo movado.


... Saltis por mallongeco ...


1 2 3 4 5 6 7 8
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
1 | ho | ho | ho | ho | ho | ho | ho | ho |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
2 | ho | ho | ho | ho | ho | ho | ho | ho |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
3 | ho | ho | ho | ho | ho | ho | ho | ho |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
4 | ho | ho | X | ho | ho | ho | ho | ho |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
5 | ho | ho | ho | X | ho | X | ho | X |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
6 | ho | X | ho | X | X | ho | ho | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
7 | ho | X | X | ho | ho | ho | ho | ho |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
8 | ho | X | X | ho | | | X | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
Vi havas 12 punktoj. La komputilo havas 48 punktoj.
Entajpu vian movadon, aŭ tipo quit fini la ludon, aŭ aludojn al elŝalti / en aludoj.
86
X notis 15 punktoj. Ho notis 46 punktoj.
Vi perdis. La komputilo venkis vin por 31 punktoj.
Ĉu vi volas ludi denove? (Jes aŭ ne)
neniu
Kiel vi povas vidi, la AI estis sufiĉe bonaj en bati min. Por helpi la ludanto eksteren, ni plani nian ludon havigi aludoj. Se la ludanto tipoj 'aludoj' kiel ilia movado, ili povas Baskuligi la aludoj modon por sezonoj. Kiam aludoj modo estas ĉe, ĉiujn eblajn movojn de la ludanto povas fari montros sur la tabulo kiel '.' Karakteroj, kiel jene:
1 2 3 4 5 6 7 8
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
1 | | | | | | | | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
2 | | | |. | |. | | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
3 | | | | ho | ho | ho | | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
4 | | |. | Ho | ho | X | | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
5 | | |. | Ho | ho | ho | X | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
6 | | | |. | |. | | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
7 | | | | | | | | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
8 | | | | | | | | |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +

Reversi la Fonta Kodo

Reversi estas mamuto programo kompare al nia antaŭa ludoj. Ĝi venas en pli ol 300 linioj longaj! (Sed ne maltrankviliĝu, multaj el ĉi tiuj linioj estas nur komentoj aŭ malplenajn liniojn al spaco ekster la kodon kaj fari ĝin pli legebla.) Kiel ĉiam, vi ne devas tajpi en la programo antaŭ legi tiun ĉapitron. Kaj vi povas ankaŭ elŝuti la programon irante al ĉi tiu libro de afiŝinto ĉe la URL, http://inventwithpython.com/chapter15 kaj sekvante la instrukcioj en linio.
Kiel kun niaj aliaj programoj, ni unue krei plurajn funkciojn por efektivigi Reversi-rilataj taskoj kiuj la ĉefa sekcio de nia programo nomos. Proksimume la unuaj 250 linioj de kodo estas por tiuj helpanto funkcioj, kaj la lasta 50 linioj de kodo apliki la Reversi ludo mem.
reversi.py
Tiu kodo estas elŝutebla el http://inventwithpython.com/reversi.py
Se vi ricevas erarojn post tajpi tiun kodon en, kompari ĝin al la libro kodo kun la linio malsamoj ilo en http://inventwithpython.com/diff aŭ retpoŝtu la aŭtoro en al@inventwithpython.com
  1. # Reversi

  3. importi hazarda
  4. importado sys

  6. def drawBoard (tabulo):
  7. # Ĉi tiu funkcio presas el la estraro ke ĝi pasis. Revenas Neniu.
  8. HLINE = '+ --- + --- + --- + --- + --- + --- + --- + --- +'
  9. VLINE = '| | | | | | | | |'

  11. print ('1 2 3 4 5 6 7 8')
  12. print (HLINE)
  13. por y en gamo (8):
  14. print (VLINE)
  15. print (y +1, fino = '')
  16. por x en gamo (8):
  17. print ('|% s'% (estraro [x] [y]), fino = '')
  18. print ('|')
  19. print (VLINE)
  20. print (HLINE)


  23. def resetBoard (tabulo):
  24. # Blanks ekster la tabulo estas pasinta, krom la originala startanta pozicio.
  25. por x en gamo (8):
  26. por y en gamo (8):
  27. estraro [x] [y] = ''

  29. # Komencante pecoj:
  30. estraro [3] [3] = 'X'
  31. estraro [3] [4] = 'O'
  32. estraro [4] [3] = 'O'
  33. estraro [4] [4] = 'X'


  36. def getNewBoard ():
  37. # Kreas tute novaj, malplenan tabulo datumstrukturo.
  38. estraro = []
  39. por i en gamo (8):
  40. board.append ([''] * 8)

  42. revenu tabulo


  45. def isValidMove (tabulo, kahelo, xstart, ystart):
  46. # Returns Falsa se la ludanto movas la spaco xstart, ystart estas nevalida.
  47. # Se ĝi estas valida movo resendas liston de spacoj kiu igus la ludanto se ili faris movon tie.
  48. se estraro [xstart] [ystart]! = '' aŭ ne isOnBoard (xstart, ystart):
  49. revenu Falsaj

  51. estraro [xstart] [ystart] = kahelo # provizore fiksis la kahelo sur la tabulo.

  53. se kahelo == 'X':
  54. otherTile = 'O'
  55. alie:
  56. otherTile = 'X'

  58. tilesToFlip = []
  59. por xdirection, ydirection en [[0, 1], [1, 1], [1, 0] [1, -1], [0, -1], [-1, -1], [-1, 0], [-1, 1]]:
  60. x, y = xstart, ystart
  61. x + = xdirection # unua paŝo en la direkto
  62. y + = ydirection # unua paŝo en la direkto
  63. se isOnBoard (x, y) kaj estraro [x] [y] == otherTile:
  64. # Ne estas peco apartenanta al la alia ludanto apud nia peco.
  65. x + = xdirection
  66. y + = ydirection
  67. se ne isOnBoard (x, y):
  68. daŭrigi
  69. dum estraro [x] [y] == otherTile:
  70. x + = xdirection
  71. y + = ydirection
  72. se ne isOnBoard (x, y): # rompi dum ciklo, tiam restu en por buklo
  73. rompi
  74. se ne isOnBoard (x, y):
  75. daŭrigi
  76. se estraro [x] [y] == kahelo:
  77. # Ekzistas pecoj al klaki super. Eniru la inversa direkto, ĝis ni atingos la originala spaco, notanta ĉiuj kaheloj laŭ la vojo.
  78. dum Vera:
  79. x - = xdirection
  80. y - = ydirection
  81. se x == xstart kaj y == ystart:
  82. rompi
  83. tilesToFlip.append ([x, y])

  85. estraro [xstart] [ystart] = '"# revenigos la malplena spaco
  86. se len (tilesToFlip) == 0: # Se neniu azuleĥoj estis spegulita, tiu ne estas valida movo.
  87. revenu Falsaj
  88. revenu tilesToFlip


  91. def isOnBoard (x, y):
  92. # Returns True se la koordinatojn estas lokitaj sur la tabulo.
  93. reveno x> = 0 kaj x <= 7 kaj y> = 0 kaj y <= 7


  96. def getBoardWithValidMoves (tabulo, kahelo):
  97. # Returns nova estraro kun. markante la valida movas la donita ludanto povas fari.
  98. dupeBoard = getBoardCopy (tabulo)

  100. por x, y en getValidMoves (dupeBoard, kahelo):
  101. dupeBoard [x] [y] = '.'
  102. revenu dupeBoard


  105. def getValidMoves (tabulo, kahelo):
  106. # Returns listo de [x, y] listoj de validaj movas por la donita ludanto sur la donita tabulo.
  107. validMoves = []

  109. por x en gamo (8):
  110. por y en gamo (8):
  111. se isValidMove (tabulo, kahelo, x, y)! = False:
  112. validMoves.append ([x, y])
  113. revenu validMoves


  116. def getScoreOfBoard (tabulo):
  117. # Determinu la partituro de rakontante la kaheloj. Redonas vortaro kun klavoj 'X' kaj 'O'.
  118. xscore = 0
  119. oscore = 0
  120. por x en gamo (8):
  121. por y en gamo (8):
  122. se estraro [x] [y] == 'X':
  123. xscore + = 1
  124. se estraro [x] [y] == 'ho':
  125. oscore + = 1
  126. revenu {'X': xscore, 'ho': oscore}


  129. def enterPlayerTile ():
  130. # Estu Estas la ludanto tipo kiu teksas volas esti.
  131. # Returns lerta kun la ludanto kahelo kiel la unua ero, kaj la komputilo kahelo kiel la dua.
  132. kahelo =''
  133. dum ne (kahelo == 'X' aux kahelo == 'O'):
  134. presi ('Ĉu vi volas esti X aŭ O?')
  135. kahelo = input (). supra ()

  137. # La unua elemento de la opo estas la ludanto kahelo, la dua estas la komputilo kahelo.
  138. se kahelo == 'X':
  139. reveno ['X', 'ho']
  140. alie:
  141. reveno ['ho', 'X']


  144. def whoGoesFirst ():
  145. # Hazarde elekti la ludanto kiu iras unue.
  146. se random.randint (0, 1) == 0:
  147. reveno 'komputilo'
  148. alie:
  149. reveno 'ludanto'


  152. def playAgain ():
  153. # Ĉi tiu funkcio redonas True se la ludanto volas ludi denove, alie False.
  154. presi ('Ĉu vi volas ludi denove? (jes aŭ ne)')
  155. revenu enigo (). malsupreniri (). startswith ('y')


  158. def makeMove (tabulo, kahelo, xstart, ystart):
  159. # Metu la kahelo en la forumaro de xstart, ystart, kaj klaki iun el la kontraŭulo pecojn.
  160. # Returns Falsa se ĉi tiu estas nevalida movo True se ĝi estas valida.
  161. tilesToFlip = isValidMove (tabulo, kahelo, xstart, ystart)

  163. se tilesToFlip == Falsa:
  164. revenu Falsaj

  166. estraro [xstart] [ystart] = kahelo
  167. por x, y en tilesToFlip:
  168. estraro [x] [y] = kahelo
  169. revenu Vera


  172. def getBoardCopy (tabulo):
  173. # Faru duobligita de la estraro listo kaj redoni la duobligita.
  174. dupeBoard = getNewBoard ()

  176. por x en gamo (8):
  177. por y en gamo (8):
  178. dupeBoard [x] [y] = tabulo [x] [y]

  180. revenu dupeBoard


  183. def isOnCorner (x, y):
  184. # Returns True se la posteno estas en unu el la kvar anguloj.
  185. reveno (x == 0 kaj y == 0) aŭ (x == 7 kaj y == 0) aŭ (x == 0 kaj y == 7) aŭ (x == 7 kaj y == 7)


  188. def getPlayerMove (tabulo, playerTile):
  189. # Lasu la ludanto tipo en ilia movado.
  190. # Redonas movado kiel [x y] (aŭ revenas la kordoj 'aludoj' aŭ 'quit')
  191. DIGITS1TO8 = '1 2 3 4 5 6 7 8 '. Split ()
  192. dum Vera:
  193. print ('Entajpu vian movadon, aŭ tipo quit fini la ludon, aŭ aludojn al elŝalti / en aludoj.')
  194. movi = input (). malsupreniri ()
  195. se movado == 'quit':
  196. revenu 'quit'
  197. se movi == 'aludoj':
  198. reveno 'aludoj'

  200. se len (move) == 2 kaj movado [0] en DIGITS1TO8 kaj movado [1] en DIGITS1TO8:
  201. x = int (movado [0]) - 1
  202. y = int (movado [1]) - 1
  203. se isValidMove (tabulo, playerTile, x, y) == Falsa:
  204. daŭrigi
  205. alie:
  206. rompi
  207. alie:
  208. print ("Tio ne estas valida movo. Tajpu la x cifero (1-8), tiam la y cifero (1-8). ')
  209. print ('Ekzemple, 81 estos la supro-dekstra angulo.')

  211. revenu [x, y]


  214. def getComputerMove (tabulo, computerTile):
  215. # Donita estraro kaj la komputilo azuleĥo, determini kie
  216. # Movi kaj reveni kiuj movas kiel [x, y] listo.
  217. possibleMoves = getValidMoves (tabulo, computerTile)

  219. # Randomize la ordo de la ebla movas
  220. random.shuffle (possibleMoves)

  222. # Ĉiam iras por angulo se haveblaj.
  223. por x, y en possibleMoves:
  224. se isOnCorner (x, y):
  225. revenu [x, y]

  227. # Iru tra la tuta ebla movas kaj memori la plej bona komentario movado
  228. bestScore = -1
  229. por x, y en possibleMoves:
  230. dupeBoard = getBoardCopy (tabulo)
  231. makeMove (dupeBoard, computerTile, x, y)
  232. partituron = getScoreOfBoard (dupeBoard) [computerTile]
  233. se partituro> bestScore:
  234. bestMove = [x, y]
  235. bestScore = partituro
  236. revenu bestMove


  239. def showPoints (playerTile, computerTile):
  240. # Printas ekster la nuna partituro.
  241. partituroj = getScoreOfBoard (mainBoard)
  242. print ("Vi havas% s punktoj. La komputilo havas% s punktoj. '% (partituroj [playerTile], partituroj [computerTile]))



  246. print ('Bonvenon Reversi!')

  248. dum Vera:
  249. # Restarigi la estraro kaj ludo.
  250. mainBoard = getNewBoard ()
  251. resetBoard (mainBoard)
  252. playerTile, computerTile = enterPlayerTile ()
  253. showHints = False
  254. turni = whoGoesFirst ()
  255. print ('La' + siavice + 'iros unue.')

  257. dum Vera:
  258. se siavice == 'ludanto':
  259. # Ludanto laŭvice.
  260. se showHints:
  261. validMovesBoard = getBoardWithValidMoves (mainBoard, playerTile)
  262. drawBoard (validMovesBoard)
  263. alie:
  264. drawBoard (mainBoard)
  265. showPoints (playerTile, computerTile)
  266. movi = getPlayerMove (mainBoard, playerTile)
  267. se movado == 'quit':
  268. print ('Dankon pro ludi!')
  269. sys.exit () # nuligi la programo
  270. elif movi == 'aludoj':
  271. showHints = ne showHints
  272. daŭrigi
  273. alie:
  274. makeMove (mainBoard, playerTile, movi [0], movi [1])

  276. se getValidMoves (mainBoard, computerTile) == []:
  277. rompi
  278. alie:
  279. turni = 'komputilo'

  281. alie:
  282. # Computer turnon.
  283. drawBoard (mainBoard)
  284. showPoints (playerTile, computerTile)
  285. input ('Gazetaraj Entajpu vidi la komputilon \' s movado. ')
  286. x, y = getComputerMove (mainBoard, computerTile)
  287. makeMove (mainBoard, computerTile, x, y)

  289. se getValidMoves (mainBoard, playerTile) == []:
  290. rompi
  291. alie:
  292. turni = 'ludanto'

  294. # Montru la fina rezulto.
  295. drawBoard (mainBoard)
  296. partituroj = getScoreOfBoard (mainBoard)
  297. print ('X notis% s punktoj. ho notis% s punktoj.'% (partituroj ['X'], partituroj ['O']))
  298. se partituroj [playerTile]> partituroj [computerTile]:
  299. print ("Vi batis la komputilo de% s punktoj! Gratulon! '% (partituroj [playerTile] - partituroj [computerTile]))
  300. elif partituroj [playerTile] <partituroj [computerTile]:
  301. print ('Vi perdis. La komputilo venkis vin per% s punktoj.'% (partituroj [computerTile] - partituroj [playerTile]))
  302. alie:
  303. print ('La ludo estis egaleco!')

  305. se ne playAgain ():
  306. rompi

Kiel la Kodo Verkoj

La Ludo Estraro Datumoj Strukturo

Antaŭ doni la kodo, ni devus paroli pri la estraro datumstrukturo. Ĉi datumstrukturo estas listo de listoj, nur kiel la en nia antaŭa Soni ludo. La listo estas kreita por ke estraro [x] [y] reprezentos la karaktero de spaco jacas pozicio x en la X-akso (irante maldekstren / dekstren) kaj pozicio y en la Y-akso (suprenirantaj / sube). Tiu karaktero povas ĉu esti '' spaceto (por reprezenti malplenan spacon), a '.' Periodo karaktero (por reprezenti ebla movado en nerekta modo), aŭ 'X' aux 'O' (por reprezenti ludanto kahelo ). Kiam ajn vi vidas parametro nomata tabulo, ke parametro variablo estas intencita esti ĉi listo de lertaj tabulo datumstrukturo.

Importante Aliaj Moduloj

  1. # Reversi

  3. importi hazarda
  4. importado sys
Ni importi la hazarda modulo por lia randint () kaj elekto () funkcioj kaj la sys modulo por lia eliro () funkcio.

Desegno la Estraro Datumoj Strukturo de la ekrano

  1. def drawBoard (tabulo):
  2. # Ĉi tiu funkcio presas el la estraro ke ĝi pasis. Revenas Neniu.
  3. HLINE = '+ --- + --- + --- + --- + --- + --- + --- + --- +'
  4. VLINE = '| | | | | | | | |'

  6. print ('1 2 3 4 5 6 7 8')
  7. print (HLINE)
La drawBoard () funkcio estos presi la aktualan ludon tabulo bazita sur la datumstrukturo en tabulo. Rimarku ke ĉiu kvadrato de la estraro aspektas jene:
+ --- +
| |
| X |
| |
+ --- +
Ekde tuj presi la ŝnuro kun la horizontala linio (kaj plusoj en la intersekcoj) denove kaj denove, ni stoki ke en konstanta variablo nomata HLINE. Ankaŭ estas linioj supre kaj sube la centro de X aŭ O kahelo kiuj estas nenio krom '|' karakteroj (nomita "pipo" karakteroj) kun tri spacoj inter ili. Ni stokas tiun ĉenon en konstanta nomata VLINE.
Linio 11 estas la unua impreso () funkcio vokas ekzekutitaj, kaj ĝi presas el la etiketoj por la X-akso kune la supro de la tabulo. Linio 12 presas la supro horizontala linio de la tabulo.
  1. por y en gamo (8):
  2. print (VLINE)
  3. print (y +1, fino = '')
  4. por x en gamo (8):
  5. print ('|% s'% (estraro [x] [y]), fino = '')
  6. print ('|')
  7. print (VLINE)
  8. print (HLINE)
Presi ĉiu vico de spacoj de la tabulo estas sufiĉe repetitivos, do ni povas uzi buklo tie. Ni faros buklo ok fojojn, iam por ĉiu vico. Linio 15 presas la etikedo por la Y-akso sur la maldekstra flanko de la tabulo, kaj havas finon = '' sxlosilvorto argumento al la fino de ĝi por presi sola spaco anstataŭ nova linio. Ĉi tiu estas por ke ni povu havi alian buklo (kiu denove cikloj ok fojojn, iam por ĉiu spaco) presi ĉiu spaco (kune kun la 'X', 'ho', aŭ '' karaktero por tiu spaco dependanta sur kio estas stokita en tabulo ).
La impreso () funkcio alvokon ene de la interna buklo havas ankaŭ finon = '' sxlosilvorto argumento al la fino de tio, kio signifas spaco karaktero estas presita anstataŭ novan linion karaktero. Ĉi tio produktas la duan spacon en la pip-spaco-tile-spaco kordoj, ke ni presi, super kaj super dum ok fojojn. Kiu produktos sola linio sur la ekrano kiu similas '| X | X | X | X | X | X | X | X' (tio estas, se ĉiu el la estraro [x] [y] valoroj estis 'X' ). Post la interna buklo estas farita, la impreso () funkcion alvoko on line 18 gravuraĵoj el la fina '|' karaktero kune kun novan linion (pro tio ne finas kun pinto ŝlosilvorto argumento).
(La impreso () alvoko devigas nin al ĉiam presi novan linion karakteron aŭ la spaco pinte de ĉio kion ni presas. Se ni ne volas ke tiu lasta karaktero, tiam ni povas ĉiam uzi la sys.stdout.write () funkcio, kiu estas sola kordo parametro kiu presas eksteren. Nepre importi sys unue antaŭ nomante ĉi tiu funkcio.)
La kodo interne de la ekstera por buklo de linio 14 al vicigas 20 gravuraĵoj el tuta vico de la tabulo, kiel jene:
| | | | | | | | |
| X | X | X | X | X | X | X | X |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
Kiam la por buklo sur linio 13 gravuraĵoj la vico ok fojoj, ĝi formas la tutan tabulon (kompreneble, iu de la spacoj en la estraro havos 'O' aŭ '' anstataŭ 'X'):
| | | | | | | | |
| X | X | X | X | X | X | X | X |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
| X | X | X | X | X | X | X | X |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
| X | X | X | X | X | X | X | X |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
| X | X | X | X | X | X | X | X |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
| X | X | X | X | X | X | X | X |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
| X | X | X | X | X | X | X | X |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
| X | X | X | X | X | X | X | X |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +
| | | | | | | | |
| X | X | X | X | X | X | X | X |
| | | | | | | | |
+ --- + --- + --- + --- + --- + --- + --- + --- +

Recomposición la Game Estraro

Grava afero por memori estas ke la koordinatoj kiuj ni presi la ludanto estas de 1 ĝis 8, sed la indeksoj en la tabulo datumstrukturo estas de 0 ĝis 7.
  1. def resetBoard (tabulo):
  2. # Blanks ekster la tabulo estas pasinta, krom la originala startanta pozicio.
  3. por x en gamo (8):
  4. por y en gamo (8):
  5. estraro [x] [y] = ''
Ĉi tie ni uzu buklo ene ciklo por meti la tabulon datumstrukturo esti ĉiuj sola spaco kordoj fari malplenan Reversi tabulo. Ni vokos la resetBoard () funkcio kiam ni komencos novan ludon kaj volas forigi la tegoloj de antaŭa ludo.

Lancxi vian la Komencante Pecoj

  1. # Komencante pecoj:
  2. estraro [3] [3] = 'X'
  3. estraro [3] [4] = 'O'
  4. estraro [4] [3] = 'O'
  5. estraro [4] [4] = 'X'
Kiam ni komencos novan ludon de Reversi, ne estas sufiĉa por havi tute malplenan tabulo. Je la komenco, ĉiu ludanto havas du azuleĥoj jam difinitaj en la centro, do ni devos ankaŭ starigis tiuj.
Ni ne devas redoni la estraro variablo, ĉar tabulo estas referenco al listo. Eĉ kiam ni fari ŝanĝojn ene de la loka funkcia atingo, ĉi tiuj ŝanĝoj okazas al la originala listo kiu pasis kiel argumento. (Memoru, tio estas unu maniero listo variabloj estas malsama de ne-listo variabloj.)

Krei Nova Ludo Estraro Datumoj Strukturo

  1. def getNewBoard ():
  2. # Kreas tute novaj, malplenan tabulo datumstrukturo.
  3. estraro = []
  4. por i en gamo (8):
  5. board.append ([''] * 8)

  7. revenu tabulo
La getNewBoard () funkcio kreas novan tabulo datumstrukturo kaj revenas ĝi. Linio 38 kreas la eksteran listo kaj stokas referenco al tiu listo en tabulo. Linio 40 kreas la interna lertaj uzante listo replicación. ([''] * 8 taksas esti la sama kiel ['', '', '', '', '', '', '', ''] sed kun malpli tajpi.) La por buklo tie kuras linio 40 ok fojoj por krei la ok interna listoj. La spacoj reprezentas tute malplena tabulo.
Kio estraro finas esti estas listo de ok lertaj, kaj ĉiu el tiuj ok lertaj mem havas ok kordoj. La rezulto estas sesdek kvar (8 x 8 = 64) kordoj. Ĉiu linio estas (nun) sola spaceto.

Kontrolanta se Move estas Valida

  1. def isValidMove (tabulo, kahelo, xstart, ystart):
  2. # Returns Falsa se la ludanto movas la spaco xstart, ystart estas nevalida.
  3. # Se ĝi estas valida movo resendas liston de spacoj kiu igus la ludanto se ili faris movon tie.
  4. se estraro [xstart] [ystart]! = '' aŭ ne isOnBoard (xstart, ystart):
  5. revenu Falsaj

  7. estraro [xstart] [ystart] = kahelo # provizore fiksis la kahelo sur la tabulo.

  9. se kahelo == 'X':
  10. otherTile = 'O'
  11. alie:
  12. otherTile = 'X'

  14. tilesToFlip = []
isValidMove () estas unu el la plej komplikaj funkcioj. Donita tabulo datumstrukturo, la ludanto kahelo, kaj la XY koordinatoj ludanto movas, ĉi tiu funkcio devas reveni True se la Reversi ludo reguloj permesas movadon al tiuj koordinatoj kaj Falsa se ​​ili ne estas.
La plej facila ĉeko oni povas fari por descalifican movado estas vidi se la XY koordinatoj estas sur la tabulo aŭ se la spaco je XY estas ne malplena. Ĉi tio estas kion la se aserto on line 48 ĉekojn por. IsOnBoard () estas funkcio ni skribos kiu certigas ambaŭ la X kaj Y koordinatoj estas inter 0 kaj 7. Ni faras tion en linio 48 kaj 49.
Por la celoj de ĉi tiu funkcio, ni iros antaŭen kaj kopii la XY koordinato indikis per xstart kaj ystart kun la ludanto kahelo. Ni starigis tiun lokon sur la tabulo reen al spaco antaŭ ol ni forlasos ĉi tiu funkcio.
La ludanto kahelo (ĉu la homa ludanto aŭ la komputila ludanto) estis pasita al ni, sed ni bezonos por povi identigi la alia ludanto kahelo. Se la ludanto kahelo estas 'X' tiam evidente la alia ludanto kahelo estas 'ho', kaj inverse.
Fine, se la donita XY koordinato finas kiel valida pozicio, ni revenos liston de ĉiuj la kontraŭulo azuleĥoj kiu estus spegulita per ĉi tiu movo.
  1. por xdirection, ydirection en [[0, 1], [1, 1], [1, 0] [1, -1], [0, -1], [-1, -1], [-1, 0], [-1, 1]]:
La por buklo iterates tra liston de listoj kiuj reprezentas direktoj vi povas movi sur la tabulo. La tabulo estas karteziaj koordinatoj kun X kaj Y direkto. Estas ok direktoj vi povas movi: ĝis, sube, maldekstra, dekstra, kaj la kvar diagonalo direktoj. Ĉiu el la ok 2-ero lertaj en la listo en linio 59 reprezentas unu el tiuj direktoj. Ni movi ĉirkaŭ la tabulo en direkto per aldono de la unua valoro en la du-ero listo al nia X koordinato, kaj la dua valoro al nia Y koordinato.
Ĉar la ikso kunordigas kresko kiel vi iros dekstren, vi povas "movi" dekstre per aldoni 1 al la X koordinato. Movante la maldekstra estas la malo: vi subtrahi 1 (aŭ aldoni -1) de la X koordinato. Ni povas movi supren, suben, forlasita, kaj ĝuste per aldono aŭ subtrahanta al nur unu koordinato samtempe. Sed movi diagonale, ni bezonas adicii aŭ subtrahi al ambaŭ koordinatoj. Ekzemple, aldonante 1 al la X kunordigi movi dekstren kaj aldonante -1 al la Y koordinato movi supren okazigus movanta al la supre-dekstra diagonalo direkto.

Kontrolanta Ĉiu el la Ok Direktoj

Jen diagramo fari ĝin pli facile memori kiu du-ero listo reprezentas kiu direkto:

Figuro 15-7: Ĉiu du-ero listo reprezentas unu el la ok direktoj.
  1. por xdirection, ydirection en [[0, 1], [1, 1], [1, 0] [1, -1], [0, -1], [-1, -1], [-1, 0], [-1, 1]]:
  2. x, y = xstart, ystart
  3. x + = xdirection # unua paŝo en la direkto
  4. y + = ydirection # unua paŝo en la direkto
Linio 60 aroj x kaj y variablo esti la sama valoro kiel xstart kaj ystart, respektive. Ni ŝanĝos x kaj y al "movi" en la direkto kiu xdirection kaj ydirection dikti. Xstart kaj ystart restos la sama do ni povas memori kiu spaco ni origine intencis kontroli. (Memoru, ni bezonas meti ĉi lokon reen al spaco karaktero, do ni ne devus anstataŭigi la valorojn en ili.)
Ni faras la unuan paŝon en la direkto kiel la unua parto de nia algoritmo.
  1. se isOnBoard (x, y) kaj estraro [x] [y] == otherTile:
  2. # Ne estas peco apartenanta al la alia ludanto apud nia peco.
  3. x + = xdirection
  4. y + = ydirection
  5. se ne isOnBoard (x, y):
  6. daŭrigi
Memoru, en ordo por ĉi esti valida movado, la unua paŝo en tiu direkto devas esti 1) sur la tabulo kaj 2) devas esti okupitaj de la alia ludanto kahelo. Alie ne ekzistas ŝanco por klaki sur iu el la kontraŭulo kaheloj. En tiu kazo, la se aserto on line 63 ne estas Vera kaj ekzekuto superas al la por komunikaĵo por la venonta direkto.
Sed se la unua spaca faras havi la alia ludanto kahelo, tiam ni devus konservi elirantan en tiu direkto, ĝis ni atingos la de nia propra kaheloj. Se ni movus de la tabulo, tiam ni devus daŭrigi reen al la por komunikaĵo provi la venonta direkto.
  1. dum estraro [x] [y] == otherTile:
  2. x + = xdirection
  3. y + = ydirection
  4. se ne isOnBoard (x, y): # rompi dum ciklo, tiam restu en por buklo
  5. rompi
  6. se ne isOnBoard (x, y):
  7. daŭrigi
La dum ciklo sur linio 69 certigas ke x kaj y teni tuj en la nuna direkto tiel longe kiel ni daŭre vidas pulbazaro de la alia ludanto kaheloj. Se x kaj y movus de la estraro, ni rompi la buklo por kaj la fluo de ekzekuto movas al vicigas 74. Kion ni vere volas fari estas rompi la buklo dum sed restu en la por buklo. Sed se ni metis daŭrigi deklaro on line 73, kiu nur daŭre dume buklo sur linio 69.
Anstataŭe, ni recheck ne isOnBoard (x, y) sur linio 74 kaj tiam daŭrigu de tie, kiu iras al la sekvanta direkto en la por komunikaĵo on line 59. Estas grave scii ke ripozon kaj daŭrigi nur rompi aŭ daŭrigi en la buklo estas nomitaj de, kaj ne ekstera buklo kiun enhavas la buklo estas nomitaj de.

Finding Out se Esas Pecoj al Flip Dum

  1. se estraro [x] [y] == kahelo:
  2. # Ekzistas pecoj al klaki super. Eniru la inversa direkto, ĝis ni atingos la originala spaco, notanta ĉiuj kaheloj laŭ la vojo.
  3. dum Vera:
  4. x - = xdirection
  5. y - = ydirection
  6. se x == xstart kaj y == ystart:
  7. rompi
  8. tilesToFlip.append ([x, y])
Se la tempo buklo sur linio 69 haltis looping ĉar la kondiĉo estis Falsa, tiam ni trovis spacon en la estraro kiu tenas niajn proprajn kahelo aŭ malplenan spacon. Linio 76 ĉekojn se ĉi spaco sur la tabulo tenas unu el niaj kaheloj. Se jes, tiam ni trovis validan movon. Ni tiam komenci novan dum buklo, ĉifoje subtrahanta x kaj y por kopii en la kontraŭa direkto ni origine tuj. Ni notu ĉiun spacon inter niaj kaheloj sur la tabulo de appending la spaco por la tilesToFlip listo.
Ni rompi la buklo dum unufoje x kaj y esti revenita al la originala pozicio (kiu estis ankoraŭ stokita en xstart kaj ystart).
  1. estraro [xstart] [ystart] = '"# revenigos la malplena spaco
  2. se len (tilesToFlip) == 0: # Se neniu azuleĥoj estis spegulita, tiu ne estas valida movo.
  3. revenu Falsaj
  4. revenu tilesToFlip
Ni realigi ĉi ĉeko en ĉiuj ok direktoj, kaj poste la tilesToFlip listo enhavu XY kunordigas ĉiuj niaj kontraŭulo azuleĥoj kiu estus spegulita se la ludanto kopiis xstart, ystart. Memoru, la isValidMove () funkcio estas nur kontroli por vidi se la originala kopio estis valida, ĝi ne vere ŝanĝas la datumstrukturo de la tabulo.
Se neniu el la ok direktoj finis flipping almenaŭ unu el la kontraŭulo azuleĥoj, tiam tilesToFlip estus malplena listo kaj tiu movado ne estus valida. En tiu kazo, isValidMove () devus reveni False. Alie, ni devus redoni tilesToFlip.

Kontrolanta por Valida Koordinatoj

  1. def isOnBoard (x, y):
  2. # Returns True se la koordinatojn estas lokitaj sur la tabulo.
  3. reveno x> = 0 kaj x <= 7 kaj y> = 0 kaj y <= 7
isOnBoard () estas funkcio nomita de isValidMove (), kaj estas nur stenografio por la iom komplika Bulea esprimo kiu revenas True se ambaŭ x kaj y estas en inter 0 kaj 7. Ĉi tiu funkcio permesas al ni certigu ke la koordinatoj estas vere en la tabulo.

Duumaj Listo kun All Valida Movoj

  1. def getBoardWithValidMoves (tabulo, kahelo):
  2. # Returns nova estraro kun. markante la valida movas la donita ludanto povas fari.
  3. dupeBoard = getBoardCopy (tabulo)

  5. for x, y in getValidMoves(dupeBoard, tile):
  6. dupeBoard[x][y] = '.'
  7. revenu dupeBoard
    getBoardWithValidMoves () uzas por redoni tabulo datumstrukturo kiu havas '.' signoj por ĉiuj validaj movas sur la tabulo. Tiu estas uzita de la aludoj regimon montri al la ludanto estraro kun ĉiuj ebla movoj markis sur ĝi.
    Rimarku ke tiu funkcio kreas duplikatajn tabulo datumstrukturo anstataŭ modifi la pasinta al ĝi en la tabulo parametro. Linio 100 alvokoj getValidMoves (), kiu resendas liston de XY kunordigas kun ĉiuj leĝaj movas la ludanto povas fari. La estraro kopio estas poste markis kun periodo en tiuj spacoj. Kiel getValidMoves () verkoj priskribas tuj.

            def getValidMoves (tabulo, kahelo):
            # Returns listo de [x, y] listoj de validaj movas por la donita ludanto sur la donita tabulo.
            validMoves = []
            por x en gamo (8):
            por y en gamo (8):
            se isValidMove (tabulo, kahelo, x, y)! = False:
            validMoves.append ([x, y])
            revenu validMoves
    La getValidMoves () funkcio redonas liston de du-ero lertaj kiuj tenas la XY kunordigas por ĉiuj validaj movas por kahelo la ludanto, donita aparta tabulo datumstrukturo en tabulo.
    Ĉi tiu funkcio uzas du cikloj por kontroli ĉiun XY koordinato (ĉiuj sesdek kvar de ili) per la alvoko isValidMove () en tiu spaco kaj kontrolado se False aŭ liston de eblaj movoj (en kiu kazo ĝi estas valida movado). Ĉiu valida XY koordinato estas aldonita al la listo, validMoves.La bool () Funkcio
    Memoru, kiamaniere vi povus uzi la int () kaj str () funkcioj por akiri la entjera kaj kordoj valoro de aliaj datumtipoj? Ekzemple, str (42) revenus la kordo '42 ', kaj int ('100') revenus la entjero 100.
    Estas simila funkcio por la Bulea datumtipo, bool (). Plej aliaj datumtipoj havas valoro kiu estas konsiderita la Falsa valoro por tiu datumtipo, kaj ĉiu alia valoro estas konsideri Vera. La entjero 0, la glitpunkta nombro 0.0, la malplena linio, la malplenan liston, kaj la malplena vortaro estas ĉiuj konsiderata Falsa kiam uzata kiel la kondiĉo por se aŭ buklo komunikaĵo. Ĉiuj aliaj valoroj estas True. Provu eniri la sekva eo la interaga konko:>>> Bool (0)Falsaj>>> Bool (0.0)Falsaj>>> Bool ('')Falsaj>>> Bool ([])Falsaj>>> Bool ({})Falsaj>>> Bool (1)Bordo>>> Bool ('Saluton')Bordo>>> Bool ([1, 2, 3, 4, 5])Bordo>>> Bool ({'spamado': 'fromaĝo', 'Fizz': 'buzz'})Bordo>>>
    Kiam ajn vi havas kondiĉo, imagu ke la tuta kondiĉo estas metitaj ene alvokon al bool () kiel la parametro. Kondiĉoj aŭtomate interpretita kiel Bulea valoroj. Ĉi tio estas simila al kiel print () povas pasis ne-kordoj valoroj kaj aŭtomate interpretas ilin kiel kordoj kiam presi.
    Pro tio la kondiĉo sur linio 111 funkcias ĝuste. La alvoko al la isValidMove () funkcio ĉu redonas la Bulea valoro False aŭ ne-malplena listo. Se vi imagas ke la tuta kondiĉo estas metitaj ene alvokon al bool (), tiam la kondiĉo Falsa igas bool (Falsa) (kiu, kompreneble, evalutes al False). Kaj kondiĉo de ne-malplena listo metita kiel parametro por bool () revenos Vera. Jen kial la reveno valoro de isValidMove () povas esti uzata kiel kondiĉo.Havigo de la Partituro de la Ludo Estraro

            def getScoreOfBoard (tabulo):
            # Determinu la partituro de rakontante la kaheloj. Redonas vortaro kun klavoj 'X' kaj 'O'.
            xscore = 0
            oscore = 0
            por x en gamo (8):
            por y en gamo (8):
            se estraro [x] [y] == 'X':
            xscore + = 1
            se estraro [x] [y] == 'ho':
            oscore + = 1
            revenu {'X': xscore, 'ho': oscore}
    La getScoreOfBoard () funkcio uzas anidado por bukloj por kontroli ĉiujn 64 spacojn sur la tabulo (8 vicoj fojoj 8 kolumnoj po vico estas 64 spacoj) kaj vidu kion kahelo (se estas) estas sur ili. Por ĉiu 'X' kahelo, la kodo pliigoj xscore. Por ĉiu 'O' kahelo, la kodo pliigoj oscore.
    Rimarku ke tiu funkcio ne redonas du-ero listo de la interpunkcioj. Du-ero listo povus esti iom malklara, ĉar eble vi forgesas kiu listero estas por X kaj kiu artikolo estas por O. Anstataŭ la funkcio redonas vortaro kun klavoj 'X' kaj 'O' kies valoroj estas la interpunkciojn.Havigo de la ludanto Tile Elekto

            def enterPlayerTile ():
            # Estu Estas la ludanto tipo kiu teksas volas esti.
            # Returns lerta kun la ludanto kahelo kiel la unua ero, kaj la komputilo kahelo kiel la dua.
            kahelo =''
            dum ne (kahelo == 'X' aux kahelo == 'O'):
            presi ('Cu vidis volas esti X Au ho?')
            kahelo = input (). supra ()
    Ĉi tiu funkcio petas la ludanton kiu teksas ili volas esti, ĉu 'X' aux 'O'. La por buklo gardos looping ĝis la ludanto tipoj en 'X' aux 'O'.

            # La unua elemento de la opo estas la ludanto kahelo, la dua estas la komputilo kahelo.
            se kahelo == 'X':
            reveno ['X', 'ho']
            alie:
            reveno ['ho', 'X']
    La enterPlayerTile () funkcio tiam redonas du-ero listo, kie la ludanto kahelo elekto estas la unua ero kaj la komputilo kahelo estas la dua. Ni uzas liston ĉi tie anstataŭ vortaron tiel, ke la tasko deklaro alvokas tiun funkcion povas uzi la multnombraj asigno artifiko. (Vidu linio 252.)Determini Kiu Goes Unua

            def whoGoesFirst ():
            # Hazarde elekti la ludanto kiu Iras unue.
            se random.randint (0, 1) == 0:
            reveno 'komputilo'
            alie:
            reveno 'ludanto'
    La whoGoesFirst () funkcio hazarde selektas kiu iras unua, kaj revenas ĉu la ĉeno 'komputilo' aŭ ĉeno 'ludanto'.Petante la Ludanto Al Ludu Denove

            def playAgain ():
            # Ci tiu funkcio redonas Vera se la ludanto volas Ludi denove, alie False.
            presi ('Cu vidis volas Ludi denove? (yes au ne)')
            revenu enigo (). malsupreniri (). startswith ('y')
    Ni uzis la playAgain () en nia antaŭa ludoj. Se la ludanto tipoj en iu kiu komencas kun 'y', tiam la funkcio redonas Vera. Alie la funkcio False.Metante Sube oni Tile sur Ludo Estraro

            def makeMove (tabulo, kahelo, xstart, ystart):
            # Metu la kahelo en la forumaro de xstart, ystart, kaj klaki iun el la kontraŭulo pecojn.
            # Returns Falsa se ĉi tiu estas nevalida movo True se ĝi estas valida.
            tilesToFlip = isValidMove (tabulo, kahelo, xstart, ystart)
    makeMove () estas la funkcio oni nomas, kiam ni volas meti kahelo en la estraro kaj klaki la alia kaheloj laŭ la reguloj de Reversi. Ĉi tiu funkcio modifas la estraro datumstrukturo kiu pasis kiel parametro rekte. Ŝanĝoj faritaj al la estraro variablo (ĉar ĝi estas listo) estos farita al la tutmonda amplekso ankaŭ. La plejparto de la laboro estas farita de isValidMove (), kiu resendas liston de XY koordinatoj (en du-ero listo) de kaheloj kiuj bezonas esti spegulita. (Memoru, se la la xstart kaj ystart argumentoj punkto al nevalidan movado, tiam isValidMove () redonos la Bulea valoro False.)

            se tilesToFlip == Falsa:
            revenu Falsaj
            estraro [xstart] [ystart] = kahelo
            por x, y en tilesToFlip:
            estraro [x] [y] = kahelo
            revenu Bordo
    Sur linioj 163 kaj 164, se la reveno valoro de isValidMove () estis Falsa, tiam makeMove () ankaŭ revenos False.
    Alie, isValidMove () estus revenis listo de spacoj en la estraro por sufoki nian kaheloj (la 'X' aux 'O' ĉenon en kahelo). Linio 166 aroj la spaco kiun la ludanto movis on, kaj la por buklo post kiu elmontras la tutan azuleĥoj, kiuj estas en tilesToFlip.Kopiante la Estraro Datumoj Strukturo

            def getBoardCopy (tabulo):
            # Faru duobligita de la estraro listo kaj redoni la duobligita.
            dupeBoard = getNewBoard ()
            por x en gamo (8):
            por y en gamo (8):
            dupeBoard [x] [y] = tabulo [x] [y]
            revenu dupeBoard
    getBoardCopy () estas malsama de getNewBoard (). getNewBoad () kreos novan ludon tabulo datumstrukturo kiun havas nur malplenaj spacoj kaj la kvar startanta kaheloj. getBoardCopy () kreos novan ludon tabulo datumstrukturo, sed tiam kopii ĉiujn pecojn en la tabulo parametro. Ĉi tiu funkcio estas uzita de nia AI havi tabulo kiu povas ŝanĝi ĉirkaŭ tiel ke ĝi ne devas ŝanĝi la reala ludo tabulo. Ĉi tio estas kiel kiel vi povas imagi farante movas sur ekzempleron de la estraro en via menso, sed ne efektive metis pecoj sur la reela tabulo.
    Al alvoko al getNewBoard () manipulas atingi freŝan tabulo datumstrukturo. Tiam la du por maŝojn kopii ĉiu el la 64 azuleĥoj de estraro al nia duplikatajn tabulo datumstrukturo nomata dupeBoard.Determini se Spaco estas en Angulo

            def isOnCorner (x, y):
            # Returns True se la posteno estas en unu el la kvar anguloj.
            reveno (x == 0 kaj y == 0) aŭ (x == 7 kaj y == 0) aŭ (x == 0 kaj y == 7) aŭ (x == 7 kaj y == 7)
    Ĉi tiu funkcio estas multe ŝatas isOnBoard (). Ĉar ĉiuj Reversi tabuloj estas 8 x 8 en grandeco, ni nur bezonas la XY kunordigas esti pasis al tiu funkcio, ne estas ludo tabulo datumstrukturo mem. Ĉi tiu funkcio redonas True se la koordinatoj estas ĉe ambaŭ (0,0), (7,0), (0,7) aŭ (7.7). Alie isOnCorner () False.Havigo de la ludanto Move

            def getPlayerMove (tabulo, playerTile):
            # Lasu la ludanto tipo en ilia movado.
            # Redonas movado kiel [x y] (aŭ revenas la kordoj 'aludoj' aŭ 'quit')
            DIGITS1TO8 = '1 2 3 4 5 6 7 8 '. Split ()
    La getPlayerMove () funkcio estas nomita por ebligi, ke la ludanto tipo en la koordinatojn de lia proksima movado (kaj kontrolu ĉu la movado estas valida). La ludanto povas ankaŭ tajpi en 'aludoj' turni aludoj mode on (se ĝi estas for) aŭ off (se ĝi estas ĉe). La ludanto povas ankaŭ tajpi en 'quit' lasi la ludon.
    La DIGITS1TO8 konstanta variablo estas la listo ['1 ', '2', '3 ', '4', '5 ', '6', '7 ', '8']. Ni kreos ĉi konstanta ĉar estas pli facile tipo DIGITS1TO8 ol la tutan liston. (Ni ne povas uzi la isdigit () metodo cxar kiu permesus 0 kaj 9 esti eniris, kiuj ne estas validaj koordinatojn en nia 8x8 tabulo.)

            Dum Bordo:
            print ('Entajpu vian movadon, aŭ tipo quit fini la ludon, aŭ aludojn al elŝalti / en aludoj.')
            movi = input (). malsupreniri ()
            se movado == 'quit':
            revenu 'quit'
            se movi == 'aludoj':
            reveno 'aludoj'
    La dum buklo gardos looping ĝis la ludanto tajpita en valida movo. Unue ni kontrolu se la ludanto volas quit aux Baskuligi aludoj modo, kaj redoni la ĉeno 'Quit' aŭ 'aludoj'. Ni uzas la malsupra () metodon sur la kordo revenis por enigo () do la ludanto povas tajpi 'aludoj' aŭ 'Quit' sed ankoraŭ havas la komandon komprenata de nia ludo.
    La kodo kiu nomas getPlayerMove () manipulos kion fari se la ludanto volas quit aux Baskuligi aludoj modo.

            se len (move) == 2 kaj movado [0] en DIGITS1TO8 kaj movado [1] en DIGITS1TO8:
            x = int (movado [0]) - 1
            y = int (movado [1]) - 1
            se isValidMove (tabulo, playerTile, x, y) == Falsa:
            daŭrigi
            alie:
            rompi
    Nia ludo atendas ke la ludanto estus tajpitaj en la XY koordinatoj de ilia movado kiel du ciferoj sen ion en inter ili. La se aserto unue ĉekojn ke la grandeco de la kordo la ludanto tajpita en estas 2. Post tio, la se komunikaĵo ankaŭ kontrolas ke ambaŭ movado [0] (la unua signo en la linio) kaj movado [1] (la dua signo en la linio) estas kordoj kiuj ekzistas en DIGITS1TO8, kiun ni difinis komence de la funkcio.
    Memoru ke nia tabulo datumstrukturoj havas indeksas de 0 ĝis 7, ne 1 ĝis 8. Ni montros 1 al 8 kiam ni presi la estraro uzante drawBoard () ĉar la homo estas uzataj por nombroj komencante de 1 anstataŭ 0. Do kiam ni konverti la kordojn en movado [0] kaj movado [1] por entjeroj, ni ankaŭ subtrahi 1.
    Eĉ se la ludanto tajpita en ĝentila movado, ni ankoraŭ bezonas kontroli, ke la movado estas permesita per la reguloj de Reversi. Ni faras tion per nomante isValidMove (), pasante la tabulo datumstrukturo, la ludanto kahelo, kaj la XY kunordigas de la movado. Se isValidMove () False, tiam ni ekzekuti la Continue deklaron por ke la fluo de ekzekuto superas al la komenco de la tempo loop kaj petas la ludanton por la movado denove.
    Se isValidMove () ne revenas Falsa, tiam ni scios la ludanto tajpita en valida movado kaj ni devus rompi la buklo dum.

            alie:
            print ("Tio ne estas valida movo. Tajpu la x cifero (1-8), tiam la y cifero (1-8). ')
            print ('Ekzemple, 81 estos la supro-dekstra angulo.')
    Se la se aserto estas kondiĉo sur linio 200 estis Falsa, tiam la ludanto ne entajpi validan movon. Ni devas montri mesaĝon instruante ilin kiel enmeti movas ke nia Reversi programo povas kompreni. Poste, la ekzekuto movas reen al la dum komunikaĵo on line 192 ĉar linio 209 estas ne nur la lasta linio en la alia-bloko, sed ankaŭ la lasta linio en la dum-bloko.

            revenu [x, y]
    Fine, getPlayerMove () redonas du-ero listo kun la XY koordinatoj de la ludanto validan movon.Havigo de la Computer Move

            def getComputerMove (tabulo, computerTile):
            # Donita estraro kaj la komputilo azuleĥo, determini kie
            # Movi kaj reveni kiuj movas kiel [x, y] listo.
            possibleMoves = getValidMoves (tabulo, computerTile)
    getComputerMove () kaj estas kie nia AI algoritmo estas realigita. La getValidMoves () funkcio estas tre helpema por nia AI. Kutime ni uzas la rezultojn de getValidMoves () por aludoj modo. Aludoj mode presos '.' periodo karakteroj sur la tabulo por montri la ludanto ĉiujn eblajn movojn ili povas fari. Sed se ni nomas getValidMoves () kun la komputilo AI la kahelo (en computerTile), ni povas preni ĉiujn eblajn movojn ke la komputilo povas fari. Ni elektu la plej bona movado de ĉi tiu listo.

            # Randomize la ordo de la ebla movas
            random.shuffle (possibleMoves)
    Unue, ni tuj uzos la random.shuffle () funkcio randomize la ordo de movadoj en la possibleMoves listo. Memoru ke la random.shuffle () funkcio estos reorder la artikoloj en la listo ke vi parolu pri tio. La funkcio ankaŭ modifas la listo rekte, multe kiel nia resetBoard () funkcio faras kun la tabulo datumstrukturo.
    Ni klarigos kial ni volas barajar la possibleMoves listo, sed unue ni rigardu nian algoritmon.Angula Movoj estas la bona Movoj

            # Ĉiam iras por angulo se haveblaj.
            por x, y en possibleMoves:
            se isOnCorner (x, y):
            revenu [x, y]
    Unue, ni buklo tra ĉiu movo en possibleMoves kaj se iu el ili estas en la angulo, ni revenas ke nia movado. Angula movas estas bona ideo ĉar iam kahelo estis metitaj sur la angulo, ĝi neniam povas esti spegulita super. Ekde possibleMoves estas listo de du-ero lertaj, ni uzas la multnombraj asigno lertaĵo en nia por buklo meti x kaj y.
    Ĉar ni tuj revenos sur trovanta la unua angulo movado en possibleMoves, se possibleMoves enhavas multnombrajn angulo movas ni ĉiam iru kun la unua. Sed ĉar possibleMoves estis barajan on line 220, ĝi estas tute hazarda kio angulo movado estas la unua en la listo.Get a Listo de la bona interpunkcio Movoj

            # Iru tra la tuta ebla movas kaj memori la plej bona komentario movado
            bestScore = -1
            por x, y en possibleMoves:
            dupeBoard = getBoardCopy (tabulo)
            makeMove (dupeBoard, computerTile, x, y)
            partituron = getScoreOfBoard (dupeBoard) [computerTile]
            se partituro> bestScore:
            bestMove = [x, y]
            bestScore = partituro
            revenu bestMove
    Se ne estas angulo movas, ni iros tra la tutan liston kaj trovu kiu movado donas al ni la plej alta poentaro. La por buklo starigos x kaj y al ĉiu movo en possibleMoves. bestMove estos metita al la plej alta komentario movado ni trovis ĝis nun, kaj bestScore estos metita al la pli bona movado la partituro. Kiam la kodon en la buklo trovas movado kiu partituroj altaj ol bestScore, ni stoki kiuj movas kaj partituro kiel la novaj valoroj de bestMove kaj bestScore (vidu linioj 233, 234, kaj 235).Simuli Ĉiuj Eblaj Movoj en duobligi Estraro Datumoj Strukturoj
    Por kalkuli la interpunkcio de la ebla movado ni aktuale ripetanta, ni unue fari duplikatajn tabulo datumstrukturo per voko getBoardCopy () on line 230. Ni volas kopion do ni povas modifi sen ŝanĝi la reala tabulo datumstrukturo stokita en la tabulo variablo.
    Tiam ni nomas makeMove () on line 231, pasante la duplikatajn tabulo (stokita en dupeBoard) anstataŭ la realan tabulo. makeMove () manipulos metante la komputilo kahelo kaj la klakanta la ludanto kaheloj sur la duplikatajn tabulo.
    Ni nomas getScoreOfBoard () on line 232 kun la duplikatajn estraro, kiu resendas vortaron kie la klavoj estas 'X' kaj 'ho', kaj la valoroj estas la interpunkciojn. getScoreOfBoard () ne scias se la komputilo estas 'X' aux 'ho', tial ĝi redonas vortaro kun ambaŭ partituroj.
    Por fari duplikatajn estraro, ni povas simuli estonteco movado kaj testi la rezulton de tiu movado sen ŝanĝi la efektiva tabulo datumstrukturo. Ĉi tio estas tre utila por decidi kiu movo estas la plej bona ebla movado por fari.
    Pretendi ke getScoreOfBoard () redonas la vortaro {'X': 22, 'ho': 8} kaj computerTile estas 'X'. Tiam getScoreOfBoard (dupeBoard) [computerTile] estus taksi al {'X': 22, 'ho': 8} ['X'], kiu tiam taksi al 22. Se 22 estas pli granda ol bestScore, bestScore estas agordita por 22 kaj bestMove estas metita al la nuna x kaj y valoroj ni rigardas. Por la tempo ĉi por buklo estas finita, ni povas esti certaj, ke bestScore estas la plej alta ebla partituro movado povas fari, kaj ke movado estas stokita en bestMove.
    Vi eble rimarkis ke sur linio 228 ni unue starigis bestScore al -1. Ĉi tiu estas tiel, ke la unua movo ni rigardas en nia por buklo super possibleMoves estos metita al la unua bestMove. Tio garantias ke bestMove estas metita al unu el la movadoj, kiam ni revenos ĝin.
    Diri, ke la plej alta komentario movado en possibleMoves donus la komputilo interpunkcio de 42. Kio se estis pli ol unu movo en possibleMoves kiu donus ĉi partituro? La por buklo ni uzas ĉiam iru kun la unua movado kiu notis 42 punktoj, ĉar bestMove kaj bestScore nur ŝanĝas se la movado estas pli granda ol la plej alta poentaro. Al egaleco ne ŝanĝos bestMove kaj bestScore.
    Ni ne cxiam volas iri kun la unua movado en la possibleMoves listo se ĝi ne estis barajado on line 220, ĉar tio farus nia AI antaŭvideblaj de la ludanto. Kvankam nia kodo ĉiam elektas la unuan el tiuj ligitaj movas, estas hazardo, kiu el la movadoj estos la unua en la listo ĉar la ordo estas hazardo. Tio certigas, ke la AI ne estos antaŭvideblaj kiam estas pli ol unu bona movado.Presi la Partituroj al la ekrano

            def showPoints (playerTile, computerTile):
            # Printas ekster la nuna partituro.
            partituroj = getScoreOfBoard (mainBoard)
            print ("Vi havas% s punktoj. La komputilo havas% s punktoj. '% (partituroj [playerTile], partituroj [computerTile]))
    showPoints () simple nomas la getScoreOfBoard () funkcio kaj tiam presas el la ludanto interpunkcio kaj la komputilo partituro. Memoru ke getScoreOfBoard () resendas vortaron kun la ŝlosiloj 'X' kaj 'ho' kaj valoroj de la partituroj por la X kaj O ludantoj.
    Tio estas ĉiuj funkcioj ni difini por nia Reversi ludo. La kodo komenciĝanta linio 246 efektivigos la reala ludo kaj fari alvokojn al tiuj funkcioj kiam ili bezonas.La Komenco de la ĉagreniĝu

            print ('Bonvenon Reversi!')
            Dum Bordo:
            # Restarigi la estraro kaj ludo.
            mainBoard = getNewBoard ()
            resetBoard (mainBoard)
            playerTile, computerTile = enterPlayerTile ()
            showHints = False
            turni = whoGoesFirst ()
            print ('La' + siavice + 'iros unue.')
    La dum ciklo sur linio 248 estas la ĉefa ludo buklo. La programo estos buklo apogi al linio 248 ĉiufoje ni volas komenci novan ludon. Unue ni preni novan ludon tabulo datumstrukturo nomante getNewBoard () kaj starigis la startanta azuleĥoj nomante resetBoard (). mainBoard estas la ĉefa tabulo datumstrukturo ni uzos por tiu ĉi programo. La alvoko por enterPlayerTile () lasos la ludanto tipo en cxu ili deziras esti 'X' aux 'ho', kiu estas tiam stokitaj en playerTile kaj computerTile.
    showHints estas Bulea valoro kiu determinas se aludoj modo estas en aŭ ekstere. Ni origine starigis ĝin sur per opcio showHints al False.
    La deĵoro variablo estas kordo ĉu havas la kordoj valoro 'ludanto' aŭ 'komputilo', kaj gardos spuro de kies vico estas. Ni starigis turno al la reveno valoro de whoGoesFirst (), kiu hazarde elektas kiu iros unue. Ni tiam presi kiu iras unue al la ludanto on line 255.Kurante la ludanto Turn

            Dum Bordo:
            se siavice == 'ludanto':
            # Ludanto laŭvice.
            se showHints:
            validMovesBoard = getBoardWithValidMoves (mainBoard, playerTile)
            drawBoard (validMovesBoard)
            alie:
            drawBoard (mainBoard)
            showPoints (playerTile, computerTile)
    La dum buklo kiun komencas la linio 257 gardos looping ĉiufoje la ludanto aŭ komputilo prenas turnon. Ni rompos el cxi tiu buklo kiam la nuna ludo estas finita.
    Linio 258 havas se aserto kies korpo havas la kodon kiu funkcias se ĝi estas la ludanto laŭvice. (La alia-bloko kiu startas en linio 282 havas la kodon por la komputilo la vico.) La unua afero, kiun ni volas fari estas montri la tabulon al la ludanto. Se aludoj modo estas ĉe (kiu estas se showHints estas Vera), tiam ni volas akiri tabulo datumstrukturo kiu havas '.' periodo karakteroj sur ĉiu spaco la ludanto povis foriri.
    Nia getBoardWithValidMoves () funkcio faras tion, ĉiuj ni devas fari estas pasi la tabulo datumstrukturo kaj ĝi revenos kopion kiu ankaŭ enhavas '.' periodo gravuloj. Ni tiam pasas ĉi tabulon al la drawBoard () funkcio sur linio 262.
    Se aludoj modo estas malŝaltita, tiam ni ĵus pasis mainBoard al drawBoard () on line 264.
    Post presi ekster la tabulo por la ludanto, ni ankaŭ volas presi la aktualan partituro nomante showPoints () on line 265.

            movi = getPlayerMove (mainBoard, playerTile)
    Ni tuj lasis la ludanto tipo en ilia movado. getPlayerMove () manipulas tiun, kaj lia reveno valoro estas du-ero listo de la XY koordinato de la ludanto movas. getPlayerMove () certigas ke la movado de la ludanto tajpita en estas valida movado, do ni ne devas zorgi pri tio ĉi tie.Uzado la quit aux aludoj komandoj

            se movado == 'quit':
            print ('Dankon por Ludi!')
            sys.exit () # nuligi la programo
            elif movi == 'aludoj':
            showHints = ne showHints
            daŭrigi
            alie:
            makeMove (mainBoard, playerTile, movi [0], movi [1])
    Se la ludanto tajpita en la ĉeno 'quit' pro ilia movado, tiam getPlayerMove () estus respondis la ĉeno 'quit'. En tiu kazo, ni devus alvoki sys.exit () por fini la programon.
    Se la ludanto tajpita en la ĉeno 'aludoj' pro ilia movado, tiam getPlayerMove () estus respondis la ĉeno 'aludoj'. En tiu kazo, ni volas turni aludoj mode on (se ĝi estis ekstere) aŭ off (se ĝi estis). La showHints = ne showHints asigno deklaro manipulas ambaŭ de ĉi tiuj kazoj, ĉar ne Falsa taksas al Vera kaj ne Vera taksas al False. Tiam ni kuras la daŭrigu deklaro al buklo dorso (siavice ne ŝanĝis, do ankoraŭ estos la ludanto turnon kiam ni daŭrigas).Fari la ludanto Move
    Alie, se la ludanto ne quit aux Baskuligi aludoj modo, tiam nomos makeMove () por fari la ludanto movo sur la tabulo.

            se getValidMoves (mainBoard, computerTile) == []:
            rompi
            alie:
            turni = 'komputilo'
    Post fari la ludanto movas, ni nomas Falsa vidi se la komputilo povus fari ian movojn. Se Falsa revenas malplenan liston, do ne plu movas lasis ke la komputilo povis fari (plej verŝajne ĉar la tabulo estas plena). En tiu kazo, ni rompi la buklo dum kaj fini la aktualan ludon.
    Alie, ni starigis turni al 'komputilo'. La fluo de ekzekuto saltas la alian-bloko kaj atingas la finon de la tempo-blokon, tiel ekzekuto saltas reen al la dum komunikaĵo on line 257. Ĉi-foje, tamen, ĝi estos la komputilo turnon.Kurante la Computer Turn

            alie:
            # Komputila turnon.
            drawBoard (mainBoard)
            showPoints (playerTile, computerTile)
            input ('Gazetaraj Entajpu vidi la komputilon \' s movado. ')
            x, y = getComputerMove (mainBoard, computerTile)
            makeMove (mainBoard, computerTile, x, y)
    La unua aĵo kiun ni faras kiam estas la komputilo la vico estas alvoko drawBoard () por presi la estraro al la ludanto. Kial ni tion nun? Ĉar ĉu la komputilo estis selektita por fari la unua movo de la ludo, en kiu kazo ni devus montri la originala startanta foton de la tabulo al la ludanto antaŭ la komputilo faras lia movado. Aŭ la ludanto iris unue, kaj ni volas montri, kion la estraro aspektas kiel post la ludanto movis sed antaŭ la komputilo iris.
    Post presi ekster la tabulo kun drawBoard (), ni ankaŭ volas presi la aktualan partituro kun alvoko al showPoints () on line 284.
    Ni tuj havi alvokon al enigo () on line 285 paŭzi la skripto dum la ludanto povas rigardi la tabulo. Tiu estas multe ŝatis kiel ni uzas enigo () paŭzi la programo en nia Ŝercoj ĉapitro. Anstataŭ uzi print () alvoko por presi ĉenon antaux alvoko al enigo (), vi povas pasi la kordoj kiel parametro por enigo (). enigo () havas laŭvolan string parametro. La kordoj ni pasas en ĉi alvoko estas 'Premu Enter por vidi la komputilon \' s movado. .
    Post la ludanto rigardis la tabulo kaj premis Entajpu (ajna teksto la ludanto tajpita estas ignorita ekde ni ne atribuas la reveno valoro de enigo () al nenio), ni nomas getComputerMove () por ricevi la XY kunordigas la komputilo proksima movado . Ni stoki tiuj koordinatoj en variabloj x kaj y, respektive.
    Fine, ni pasas x kaj y, kune kun la tabulo datumstrukturo kaj la komputilo kahelo por la makeMove () funkcion por ŝanĝi la tabulo por reflekti la komputilo movado. Nia alvoko al getComputerMove () on line 286 atingis la komputilo movado (kaj stokitaj en variabloj x kaj y), kaj la alvokon al makeMove () on line 287 faras la movo sur la tabulo.

            se getValidMoves (mainBoard, playerTile) == []:
            rompi
            alie:
            turni = 'ludanto'
    Linioj 289 al 292 estas tre simila al linioj 276 al 279. Post la komputilo faris lia movado, ni kontrolu se ekzistas neniu ebla movas la homa ludanto povas fari. Se getValidMoves () redonas malplenan liston, do ne estas ebla movojn. Tio signifas la ludo estas finita, kaj ni devus rompi la buklo dum ke ni estas in
    Alie, ekzistas almenaŭ unu ebla movado la ludanto devas fari, do ni ekus turni al 'ludanto'. Ne estas pli kodon en la dum-bloko post linio 292, do ekzekuto cikloj reen al la dum komunikaĵo on line 257.Desegno Ĉiu sur la ekrano

            # Montru la fina rezulto.
            drawBoard (mainBoard)
            partituroj = getScoreOfBoard (mainBoard)
            print ('X notis% s punktoj. ho notis% s punktoj.'% (partituroj ['X'], partituroj ['O']))
            se partituroj [playerTile]> partituroj [computerTile]:
            print ("Vi batis la komputilo de% s punktoj! Gratulon! '% (partituroj [playerTile] - partituroj [computerTile]))
            elif partituroj [playerTile] <partituroj [computerTile]:
            print ('Vi perdis. La komputilo venkis vin per% s punktoj.'% (partituroj [computerTile] - partituroj [playerTile]))
            alie:
            print ('La ludo estis egaleco!')
    Linio 294 estas la unua linio trans la dum-bloko kiu komencis la linio 257. Tiu kodo estas ekzekutita kiam ni flankenmetis el tiu tempo buklo, aŭ sur linio 290 aŭ 277. (La dum deklaro de kondiĉo sur linio 257 estas simple la valoron True, do ni povas nur eliri la buklo tra ripozon deklaroj.)
    Je ĉi tiu punkto, la ludo estas finita. Ni devus presi la estraro kaj partiturojn, kaj determini kiu venkis. getScoreOfBoard () revenos vortaro kun klavoj 'X' kaj 'ho' kaj valoroj de ambaŭ ludantoj partituroj. Kontrolante se     adsfasdla ludanto partituro estas pli granda ol, malpli ol, aŭ egala al la komputilo partituro, ni povas scii se la ludanto gajnis, se la ludanto perdita, aŭ se la ludanto kaj komputilo ligitaj.
    Subtrahanta unu partituro de la alia estas facila maniero por vidi per kiom oni ludanto venkis super la alia. Nia impreso () alvokas liniojn 299 kaj 301 uzo string interpola meti la entjera rezulto de ĉi subtraho en la ĉeno kiu estas presita.Demandu la Ludanto al Ludu Denove

            se NE playAgain ():
            rompi
    La ludo estas nun finita kaj la gajnanto estis deklarita. Ni devas nomi nian playAgain () funkcio, kiu revenas True se la ludanto tajpita en kiu volas ludi alian ludon. Se playAgain () False (kiu faras la se aserto estas kondiĉo Vera), ni rompi la dum buklo (kiu komencis la linio 248), kaj ekde estas ne pli linioj de kodo post ĉi dum-bloko, la programo finiĝas.
    Alie, playAgain () revenis Vera (kiu faras la se aserto estas kondiĉo Falsa), kaj tiel ekzekuto cikloj reen al la dum komunikaĵo on line 248 kaj nova tabulo estas kreita.Ŝanĝi La drawBoard () Funkcio
    La tabulo ni desegni por nia Reversi ludo estas sufiĉe granda. Sed ni povus ŝanĝi la drawBoard () funkcio de kodo por nudigos multe pli malgranda tabulo, konservante la resto de la ludo kodo same. La nova, pli malgranda tabulo aspektus tiel:12345678+ -------- +1 | ho |2 | XOX |3 | ho |4 | XXXXX |5 |. OX |6 | OOO |7 | .. O.. |8 | ho |+ -------- +Vi havas 8 punktoj. La komputilo havas 9 punktoj.Entajpu vian movadon, aŭ tipo quit fini la ludon, aŭ aludojn al elŝalti / en aludoj.
    Jen la kodo por tiu nova drawBoard () funkcio, startanta je linio 6. Vi povas ankaŭ elŝuti tiun kodon de http://inventwithpython.com/reversi_mini.py

            def drawBoard (tabulo):
            # Ci tiu funkcio Prenitaj El la estraro Ke gi pasis. Revenas Neniu.
            HLINE = '+ -------- +'
            print ('12345678')
            print (HLINE)
            por y en gamo (8):
            print ('% s |'% (y +1), fino ='')
            por x en gamo (8):
            print (tabulo [x] [y], fino ='')
            print ('|')
            print (HLINE)
    Resumo: Reviziante la Reversi Ludo
    La AI povas simili preskaŭ nevenkebla, sed ĉi tio ne estas ĉar la komputilo estas tre inteligenta. La strategio sekvas estas tre simpla: movi sur la angulo, se vi povas, alie fari la movado kiu klaki sur la plej kaheloj. Ni povus fari tion, sed necesus ni longan tempon por eltrovi kiom da kaheloj estus spegulita por ĉiu ebla validan movon ni povus fari. Sed kalkuli tion por la komputilo estas tre simpla. La komputilo ne estas pli inteligenta ol ni, estas nur multe pli rapida!
    Tiu ludo estas tre simila al Soni ĉar ĝi faras uzon de krado por estraro. Estas ankaŭ kiel la Tic Tac Toe ludo ĉar estas AI kiu planas la plej bona movo por ĝi preni. Ĉi tiu ĉapitro nur enkondukis novan koncepton: uzante la bool () funkcio kaj la fakto ke malplena lertaj, malplenan kordoj, kaj la entjero 0 ĉiuj taksi al Falsa en la kunteksto de kondiĉo.
    Krom tio, ĉi tiu ludo uzas programado konceptoj ke vi jam sciis! Vi ne bezonas scii multe pri programado por krei interesajn ludojn. Tamen, ĉi tiu ludo estas streĉanta kiom vi povas akiri per ASCII arto. La estraro prenis preskaŭ la tutan ekranon por desegni, kaj la ludo ne havis neniun koloron.
    Poste en ĉi tiu libro, ni lernos kiel krei ludoj kun grafikaĵoj kaj kuraĝigo, ne nur tekston. Ni faros ĉi uzante modulo nomata Pygame, kiu aldonas novajn funkciojn kaj trajtojn al Python tiel ke ni povas rompi for de uzante nur tekston kaj klavaro enigo.
Postado por às

Nenhum comentário:

Postar um comentário

Assinar: Postar comentários (Atom)