Páginas

domingo, 3 de março de 2013

skribu-kun-python-cxap13

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

Temoj Kovritaj dum tiu ĉapitro:

  • Datumstrukturoj.
  • La forigi() listaj metodoj.
  • La isdigit() kordaj metodoj.
  • La sys.exit() funkcio.
La ludo de ĉi tiu ĉapitro nur enkondukas kelkajn novajn helpema metodoj kiuj venis kun Python, la forigi () listo metodo kaj la isdigit () kordoj metodo. Sed ĉi tiu estas la unua programo kiu uzas Karteziaj koordinatoj kaj la matematikaj konceptoj ni lernis en la ĉapitro 11. Ĉi tiu programo ankaŭ uzos uzi datumstrukturoj (kiu estas vere nur ornama maniero diri variabloj kiuj enhavas listojn de listoj.) Kiel niaj ludoj fariĝis pli komplika, ni bezonos por stoki niajn datumojn en bone organizita manieroj.
Soni estas teknologio kiu ŝipoj uzi por lokalizi celojn sub la maro. En ĉi tiu ĉapitro estas ludo, la ludanto metas soni mekanismoj ĉe diversaj lokoj en la oceano por lokalizi subakvigita trezoro brustojn. La soni mekanismoj (en nia ludo) povas diri la ludanto kiom malproksime trezoron brusto estas el la soni mekanismo, sed ne en kiu direkto. Sed metante multnombraj soni mekanismoj sube, la ludanto povas diveni kie ĝuste la trezorkesto estas.
Estas tri kestoj por kolekti, sed la ludanto havas nur dek ses soni mekanismoj uzi por trovi ilin. Imagu, ke ni ne povis vidi la trezorkesto en la sekvaj bildoj. Ĉar ĉiu soni mekanismo povas nur trovi la distanco sed ne direkto, la ebla lokoj la trezoro povus esti estas ie en ringo ĉirkaŭ la soni aparato (vidu Figuron 13-1).

Figuro 13-1: La unua soni aparato montras ringo
de eblaj lokoj la trezoro povus loki.

Figuro 13-2: Kombinante la ringoj de la tri soni
mekanismoj montras nur unu ebla loko por la trezoro.
Sed se ni havas plurajn soni mekanismoj laborante kune, ni povas malpligrandigi gxin al akurata loko kie ĉiuj ringoj sekci unu la alian. (Vidu Figuro 13-2)

Specimeno Run

Soni!

Ĉu vi volas vidi la instrukciojn? (Jes / ne)
neniu
1 2 3 4 5
012345678901234567890123456789012345678901234567890123456789

0 `~ ~ ~` ~ ~ ~ `~` ~ ~ '~ ~ ~ ~ ~ `~ `` ~ ~ ~ ~` ~ `~ ~ ~` ~ `` `` ~ ~ ~ `` `` ~ `~ `` `~` ~ ~ ~ ~ `` 0
1 ~ `~ ~ ~ ``` ~ ~ ~ ~ `~` ~ ~ '~ `` ~ `~ ~ ``` ~ `~` ~ ~' ~ '~ ~ ~ ~ ~ ~ `~ `` `` `~` ~ ~ '~ ~ ~ ~ `1
2 `~ `` `` ~ ~ ~ ~` ~ `` ~ `~` ~ `` ~ `` `` `~ ~ ~ ~ ~ ~ ~ ~ ~` ~ `~ ~ '~ `` ~ ~ ~ ~ ~ `` `~ ~ '~ ``` 2
3 `` ~ `~ ~ ~ ``` ~ `` ~ `~` ~ `~ ~ '~' ~ ~` ~ `~ `` ~ ~ ~` ~ `` `` `` ~ ~ `` `` `` ~ ~ ~ ~ ~ `` `` 3
4 `` ~ ~ `~ ~ ~ ~ `` `` ~ ~ `` `` ~` ~ '~' ~ `` ~ ~ ~ ~ ~ `` `` `~` ~ ~ `~ ~ '~' ~ `~ ~ '~ ~ ~ ~ ``` 4
5 ~ ~ `` `~ ~ ~` ~ `~ ~ ~ ``` ~ `` `` `~ ~ '~ ~` ~ ~ ~ ~ ~ `~ ~ ~ ``` ~ `~ ~ ~` ~ ~ `~ '~' ~ '~ ~ ~` 5
6 `` ~ ~ `` `` `~ ~ ~ ~` ~ `~ ~ ~ ``` ~ ~ ~ ~ `~ ~ '~ ~` ~ ~ `` `~ ~' ~ ~ ~` ~ ~ ~ ` `~` ~ ~ ~ `` ~ ~ ~ 6
7 `~ `` `` `` ``` ~ `` `~ `` `` ~ ~ ~` ~ ~ ~ ~ `~ ~ ~ `` `` ~ ~ ~ ``` ~ `~ ~ '~' `~ `` ~ ~ ``` ~ ~ 7
8 `~ `` `` ``` ~ ~ `~ ~ '~ ~ ~` ~ ~ `` ~ ~ ~ ~ `` `~ `` ~ ~ ~ ~ ``` ~ `` `` `~' ~ ~ `` `~` ~ ~ ~ ~ `8
9 ~ `` `~ ~ '~' ~ `` `` ~ ~ ~ ~ `` `` ``` ~ ~ '~ `` ~ ~ ~ ~ `~' ~ '~ ~ ~` ~' ~ '~ `~ ~ ~ ~ ~ `` ``` 9
10 `` `~` ~ `` `~ `` `` ~ ~` ~ ~ '~ `` `` `` ~ ~ `` ~ ~ ~ `~ ~' ~ ~ `` ~ ~ ~ ~` ~ ~ ~ `~` ~ ~ `` `` ~ 10
11 `` `~ ``` ~ ~ ~ `~ ``` ~ ~ '~ ~ ~ `~ `` ``` ~ `~ ~' ~ '~ ~` ~ ~' ~ '~ ~ `~ ~ ~ `` `` `` `` ~ ~ `11
12 ~ ~ ~ `~` ~ ~ ~ `` ~ ~ ~ ~ ~ ~ `~ ~ ~ ~ ``` ~ `~ ~ '~' ~ ~` ~ `` `~ ~ ~ ``` ~ ~ '~ ~ `~ `` `` ~ ~` ~ 12
13 `~ ~ `` `` ~ ~ ~ `` ``` ~ ~ ~ `~ ``` ~ `~ ~ ~ ~ ~ ~ ~ ~ ~` ~ ~ ~ ~ ~ `` ~ ~ `` `` ` ~ `~` ~ `` ~ ~ ~ ~ 13
14 `~ ~ '~' ~ `` `` ``` ~ ~ '~' ~ `` `~ ~ '~ ~ ~ ~` ~ `` `~ `` `` ~ ~ `` ~ ~ ~ `` `` ~ ~ `` `` `` ~ 14

012345678901234567890123456789012345678901234567890123456789
1 2 3 4 5
Vi havas 16 soni aparatoj restis. 3 trezoro brustojn restanton.
Kie vi deziras forlasi la sekvanta soni artefakto? (0-59 0-14) (aŭ tipo Quit)
10 10
1 2 3 4 5
012345678901234567890123456789012345678901234567890123456789

0 `~ ~ ~` ~ ~ ~ `~` ~ ~ '~ ~ ~ ~ ~ `~ `` ~ ~ ~ ~` ~ `~ ~ ~` ~ `` `` ~ ~ ~ `` `` ~ `~ `` `~` ~ ~ ~ ~ `` 0
1 ~ `~ ~ ~ ``` ~ ~ ~ ~ `~` ~ ~ '~ `` ~ `~ ~ ``` ~ `~` ~ ~' ~ '~ ~ ~ ~ ~ ~ `~ `` `` `~` ~ ~ '~ ~ ~ ~ `1
2 `~ `` `` ~ ~ ~ ~` ~ `` ~ `~` ~ `` ~ `` `` `~ ~ ~ ~ ~ ~ ~ ~ ~` ~ `~ ~ '~ `` ~ ~ ~ ~ ~ `` `~ ~ '~ ``` 2
3 `` ~ `~ ~ ~ ``` ~ `` ~ `~` ~ `~ ~ '~' ~ ~` ~ `~ `` ~ ~ ~` ~ `` `` `` ~ ~ `` `` `` ~ ~ ~ ~ ~ `` `` 3
4 `` ~ ~ `~ ~ ~ ~ `` `` ~ ~ `` `` ~` ~ '~' ~ `` ~ ~ ~ ~ ~ `` `` `~` ~ ~ `~ ~ '~' ~ `~ ~ '~ ~ ~ ~ ``` 4
5 ~ ~ `` `~ ~ ~` ~ `~ ~ ~ ``` ~ `` `` `~ ~ '~ ~` ~ ~ ~ ~ ~ `~ ~ ~ ``` ~ `~ ~ ~` ~ ~ `~ '~' ~ '~ ~ ~` 5
6 `` ~ ~ `` `` `~ ~ ~ ~` ~ `~ ~ ~ ``` ~ ~ ~ ~ `~ ~ '~ ~` ~ ~ `` `~ ~' ~ ~ ~` ~ ~ ~ ` `~` ~ ~ ~ `` ~ ~ ~ 6
7 `~ `` `` `` ``` ~ `` `~ `` `` ~ ~ ~` ~ ~ ~ ~ `~ ~ ~ `` `` ~ ~ ~ ``` ~ `~ ~ '~' `~ `` ~ ~ ``` ~ ~ 7
8 `~ `` `` ``` ~ ~ '~ ~ `~ ~ ~` ~ ~ `` ~ ~ ~ ~ `` `~ `` ~ ~ ~ ~ ``` ~ `` `` `~' ~ ~ `` `~` ~ ~ ~ ~ `8
9 ~ `` `~ ~ '~' ~ `` `` ~ ~ ~ ~ `` `` ``` ~ ~ '~ `` ~ ~ ~ ~ `~' ~ '~ ~ ~` ~' ~ '~ `~ ~ ~ ~ ~ `` ``` 9
10 `` `~` ~ `` `~ 5` ~ `` ~ `~ ~ '~ `` `` `` ~ ~ `` ~ ~ ~` ~ ~' ~ ~ `` ~ ~ ~ ~ `~ ~ ~ `~` ~ ~ `` `` ~ 10
11 `` `~ ``` ~ ~ ~ `~ ``` ~ ~ '~ ~ ~ `~ `` ``` ~ `~ ~' ~ '~ ~` ~ ~' ~ '~ ~ `~ ~ ~ `` `` `` `` ~ ~ `11
12 ~ ~ ~ `~` ~ ~ ~ `` ~ ~ ~ ~ ~ ~ `~ ~ ~ ~ ``` ~ `~ ~ '~' ~ ~` ~ `` `~ ~ ~ ``` ~ ~ '~ ~ `~ `` `` ~ ~` ~ 12
13 `~ ~ `` `` ~ ~ ~ `` ``` ~ ~ ~ `~ ``` ~ `~ ~ ~ ~ ~ ~ ~ ~ ~` ~ ~ ~ ~ ~ `` ~ ~ `` `` ` ~ `~` ~ `` ~ ~ ~ ~ 13
14 `~ ~ '~' ~ `` `` ``` ~ ~ '~' ~ `` `~ ~ '~ ~ ~ ~` ~ `` `~ `` `` ~ ~ `` ~ ~ ~ `` `` ~ ~ `` `` `` ~ 14

012345678901234567890123456789012345678901234567890123456789
1 2 3 4 5
Trezoro detektita je distanco de 5 de la soni mekanismo.
Vi havas 15 soni aparatoj restis. 3 trezoro brustojn restanton.
Kie vi deziras forlasi la sekvanta soni artefakto? (0-59 0-14) (aŭ tipo Quit)
15 6
1 2 3 4 5
012345678901234567890123456789012345678901234567890123456789

0 `~ ~ ~` ~ ~ ~ `~` ~ ~ '~ ~ ~ ~ ~ `~ `` ~ ~ ~ ~` ~ `~ ~ ~` ~ `` `` ~ ~ ~ `` `` ~ `~ `` `~` ~ ~ ~ ~ `` 0
1 ~ `~ ~ ~ ``` ~ ~ ~ ~ `~` ~ ~ '~ `` ~ `~ ~ ``` ~ `~` ~ ~' ~ '~ ~ ~ ~ ~ ~ `~ `` `` `~` ~ ~ '~ ~ ~ ~ `1
2 `~ `` `` ~ ~ ~ ~` ~ `` ~ `~` ~ `` ~ `` `` `~ ~ ~ ~ ~ ~ ~ ~ ~` ~ `~ ~ '~ `` ~ ~ ~ ~ ~ `` `~ ~ '~ ``` 2
3 `` ~ `~ ~ ~ ``` ~ `` ~ `~` ~ `~ ~ '~' ~ ~` ~ `~ `` ~ ~ ~` ~ `` `` `` ~ ~ `` `` `` ~ ~ ~ ~ ~ `` `` 3
4 `` ~ ~ `~ ~ ~ ~ `` `` ~ ~ `` `` ~` ~ '~' ~ `` ~ ~ ~ ~ ~ `` `` `~` ~ ~ `~ ~ '~' ~ `~ ~ '~ ~ ~ ~ ``` 4
5 ~ ~ `` `~ ~ ~` ~ `~ ~ ~ ``` ~ `` `` `~ ~ '~ ~` ~ ~ ~ ~ ~ `~ ~ ~ ``` ~ `~ ~ ~` ~ ~ `~ '~' ~ '~ ~ ~` 5
6 `` ~ ~ `` `` `~ ~ ~ ~` ~ 4 ~ ~ ~ `` `~ ~ ~ ~` ~ ~ '~ ~ `~ ~ ``` ~ ~' ~ ~ ~ `~ ~ ~` `~` ~ ~ ~ `` ~ ~ ~ 6
7 `~ `` `` `` ``` ~ `` `~ `` `` ~ ~ ~` ~ ~ ~ ~ `~ ~ ~ `` `` ~ ~ ~ ``` ~ `~ ~ '~' `~ `` ~ ~ ``` ~ ~ 7
8 `~ `` `` ``` ~ ~ `~ ~ '~ ~ ~` ~ ~ `` ~ ~ ~ ~ `` `~ `` ~ ~ ~ ~ ``` ~ `` `` `~' ~ ~ `` `~` ~ ~ ~ ~ `8
9 ~ `` `~ ~ '~' ~ `` `` ~ ~ ~ ~ `` `` ``` ~ ~ '~ `` ~ ~ ~ ~ `~' ~ '~ ~ ~` ~' ~ '~ `~ ~ ~ ~ ~ `` ``` 9
10 `` `~` ~ `` `~ 5` ~ `` ~ `~ ~ '~ `` `` `` ~ ~ `` ~ ~ ~` ~ ~' ~ ~ `` ~ ~ ~ ~ `~ ~ ~ `~` ~ ~ `` `` ~ 10
11 `` `~ ``` ~ ~ ~ `~ ``` ~ ~ '~ ~ ~ `~ `` ``` ~ `~ ~' ~ '~ ~` ~ ~' ~ '~ ~ `~ ~ ~ `` `` `` `` ~ ~ `11
12 ~ ~ ~ `~` ~ ~ ~ `` ~ ~ ~ ~ ~ ~ `~ ~ ~ ~ ``` ~ `~ ~ '~' ~ ~` ~ `` `~ ~ ~ ``` ~ ~ '~ ~ `~ `` `` ~ ~` ~ 12
13 `~ ~ `` `` ~ ~ ~ `` ``` ~ ~ ~ `~ ``` ~ `~ ~ ~ ~ ~ ~ ~ ~ ~` ~ ~ ~ ~ ~ `` ~ ~ `` `` ` ~ `~` ~ `` ~ ~ ~ ~ 13
14 `~ ~ '~' ~ `` `` ``` ~ ~ '~' ~ `` `~ ~ '~ ~ ~ ~` ~ `` `~ `` `` ~ ~ `` ~ ~ ~ `` `` ~ ~ `` `` `` ~ 14

012345678901234567890123456789012345678901234567890123456789
1 2 3 4 5
Trezoro detektita je distanco de 4 de la soni mekanismo.
Vi havas 14 soni aparatoj restis. 3 trezoro brustojn restanton.
Kie vi deziras forlasi la sekvanta soni artefakto? (0-59 0-14) (aŭ tipo Quit)
15 10
1 2 3 4 5
012345678901234567890123456789012345678901234567890123456789

0 `~ ~ ~` ~ ~ ~ `~` ~ ~ '~ ~ ~ ~ ~ `~ `` ~ ~ ~ ~` ~ `~ ~ ~` ~ `` `` ~ ~ ~ `` `` ~ `~ `` `~` ~ ~ ~ ~ `` 0
1 ~ `~ ~ ~ ``` ~ ~ ~ ~ `~` ~ ~ '~ `` ~ `~ ~ ``` ~ `~` ~ ~' ~ '~ ~ ~ ~ ~ ~ `~ `` `` `~` ~ ~ '~ ~ ~ ~ `1
2 `~ `` `` ~ ~ ~ ~` ~ `` ~ `~` ~ `` ~ `` `` `~ ~ ~ ~ ~ ~ ~ ~ ~` ~ `~ ~ '~ `` ~ ~ ~ ~ ~ `` `~ ~ '~ ``` 2
3 `` ~ `~ ~ ~ ``` ~ `` ~ `~` ~ `~ ~ '~' ~ ~` ~ `~ `` ~ ~ ~` ~ `` `` `` ~ ~ `` `` `` ~ ~ ~ ~ ~ `` `` 3
4 `` ~ ~ `~ ~ ~ ~ `` `` ~ ~ `` `` ~` ~ '~' ~ `` ~ ~ ~ ~ ~ `` `` `~` ~ ~ `~ ~ '~' ~ `~ ~ '~ ~ ~ ~ ``` 4
5 ~ ~ `` `~ ~ ~` ~ `~ ~ ~ ``` ~ `` `` `~ ~ '~ ~` ~ ~ ~ ~ ~ `~ ~ ~ ``` ~ `~ ~ ~` ~ ~ `~ '~' ~ '~ ~ ~` 5
6 `` ~ ~ `` `` `~ ~ ~ ~` ~ ho ~ ~ ~ `` `~ ~ ~ ~` ~ ~ '~ ~ `~ ~ ``` ~ ~' ~ ~ ~ `~ ~ ~` `~` ~ ~ ~ `` ~ ~ ~ 6
7 `~ `` `` `` ``` ~ `` `~ `` `` ~ ~ ~` ~ ~ ~ ~ `~ ~ ~ `` `` ~ ~ ~ ``` ~ `~ ~ '~' `~ `` ~ ~ ``` ~ ~ 7
8 `~ `` `` ``` ~ ~ `~ ~ '~ ~ ~` ~ ~ `` ~ ~ ~ ~ `` `~ `` ~ ~ ~ ~ ``` ~ `` `` `~' ~ ~ `` `~` ~ ~ ~ ~ `8
9 ~ `` `~ ~ '~' ~ `` `` ~ ~ ~ ~ `` `` ``` ~ ~ '~ `` ~ ~ ~ ~ `~' ~ '~ ~ ~` ~' ~ '~ `~ ~ ~ ~ ~ `` ``` 9
10 `` `~` ~ `` `~ ho` ~ `` Ho `~ ~ '~ `` `` `` ~ ~ `` ~ ~ ~` ~ ~' ~ ~ `` ~ ~ ~ ~ `~ ~ ~ `~` ~ ~ `` `` ~ 10
11 `` `~ ``` ~ ~ ~ `~ ``` ~ ~ '~ ~ ~ `~ `` ``` ~ `~ ~' ~ '~ ~` ~ ~' ~ '~ ~ `~ ~ ~ `` `` `` `` ~ ~ `11
12 ~ ~ ~ `~` ~ ~ ~ `` ~ ~ ~ ~ ~ ~ `~ ~ ~ ~ ``` ~ `~ ~ '~' ~ ~` ~ `` `~ ~ ~ ``` ~ ~ '~ ~ `~ `` `` ~ ~` ~ 12
13 `~ ~ `` `` ~ ~ ~ `` ``` ~ ~ ~ `~ ``` ~ `~ ~ ~ ~ ~ ~ ~ ~ ~` ~ ~ ~ ~ ~ `` ~ ~ `` `` ` ~ `~` ~ `` ~ ~ ~ ~ 13
14 `~ ~ '~' ~ `` `` ``` ~ ~ '~' ~ `` `~ ~ '~ ~ ~ ~` ~ `` `~ `` `` ~ ~ `` ~ ~ ~ `` `` ~ ~ `` `` `` ~ 14

012345678901234567890123456789012345678901234567890123456789
1 2 3 4 5
Vi trovis subakvigita trezorkesto!
Vi havas 13 soni aparatoj restis. 2 trezoro brustojn restanton.
Kie vi deziras forlasi la sekvanta soni artefakto? (0-59 0-14) (aŭ tipo Quit)


... Saltis super por mallongeco ....


1 2 3 4 5
012345678901234567890123456789012345678901234567890123456789

0 `~ ~ ~` ~ ~ ~ `~` ~ ~ '~ ~ ~ ~ ~ `~ `` ~ ~ ~ ~` ~ `~ ~ ~` ~ `` `` ~ ~ ~ `` `` ~ `~ `` `~` ~ ~ ~ ~ `` 0
1 ~ `~ ~ ~ ``` ~ ~ ~ ~ `~` ~ ~ '~ `` ~ `~ ~ ``` ~ ho ~ `~ ~' ~ '~ ~ ~ ~ ~ ~` ~ `` `` `~` ~ ~ '~ ~ ~ ~ `1
2 `~ `` `` ~ ~ ~ ~` ~ `` ~ `~` ~ `` ~ `` `` `~ ~ ho ~ ~ ~ ~ ~ ho` ~ `~ ~ '~ `` ~ ~ ~ ~ ~ `` `~ ~ '~ ``` 2
3 `` ~ 3 ~ ~ `` 8 `~ `` ~` ~ `~` ~ ~ '~' ~ ~ `~` ~ `` ~ ~ ~ `~` ho ~ `` `` `` `` ~ `` ~ ~ ~ ~ ~ `` `` 3
4 `` ~ ~ `~ ~ ~ ~ `` `` ~ ~ `` `` ~` ~ '~' ~ ho `~ ~ ho `` ~ ~ ``` ~ `~ ~` ~ ~ '~' ~ `~ ~ '~ ~ ~ ~ ``` 4
5 ~ ~ `` `~ ~ ~` ~ `~ ~ ~ ``` ~ `` `` `~ ~ '~ ~` ~ ~ ~ ~ ~ `~ ~ ~ ``` ~ `~ ~ ~` ~ ~ `~ '~' ~ '~ ~ ~` 5
6 `` ~ ~ `` `` `~ ~ ~ ~` ~ ho ~ ~ ~ `` `~ ~ ~ ~` ~ ~ '~ ~ `~ ~ ``` ~ ~' ~ ~ ~ `~ ~ ~` `Ho` ~ ~ ~ `` ~ ~ ~ 6
7 `~ `` `` `` ``` ~ `` `~ `` `` ~ ~ ~` ~ ~ ~ ~ `~ ~ ~ `` `` ~ ~ ~ ``` ~ `~ ~ '~' `~ `` ~ ~ ``` ~ ~ 7
8 `~ `` `` ``` ~ ~ `~ ~ '~ ~ ~` ~ ~ `` ~ ~ ~ ~ `` `~ `` ~ ~ ~ ~ ``` ho `` `0` ~' ~ ~ `` `~` ~ ~ ~ ~ `8
9 ~ `` `~ ~ '~' ~ `` `` ~ ~ ~ ~ `` `` ``` ~ ~ ~ ho `` ~ ~ ~ ~ `~ '~' ~ ~ ~` ~ '~' ~ `~ ~ ~ ~ ~ `` ``` 9
10 `` `~` ~ `` `~ ho` ~ `` Ho `~ ~ '~ `` `` `` ~ ~ `` ~ ~ ~` ~ ~' ~ ~ `` ~ ~ ~ ~ `~ ~ ~ `~` ~ ~ `` `` ~ 10
11 `` `~ ``` ~ ~ ~ `~ ``` ~ ~ '~ ~ ~ `~ `` ``` ~ `~ ~' ~ '~ ~` ~ ~' ~ '~ ~ `~ ~ ~ `` `` `` `` ~ ~ `11
12 ~ ~ ~ `~` ~ ~ ~ `` ~ ~ ~ ~ ~ ~ `~ ~ ~ ~ ``` ~ `~ ~ '~' ~ ~` ~ `` `~ ~ ~ ``` ~ ~ '~ ~ `~ `` `` ~ ~` ~ 12
13 `~ ~ `` `` ~ ~ ~ `` ``` ~ ~ ~ `~ ``` ~ `~ ~ ~ ~ ~ ~ ~ ~ ~` ~ ~ ~ ~ ~ `` ~ ~ `` `` ` ~ `~` ~ `` ~ ~ ~ ~ 13
14 `~ ~ '~' ~ `` `` ``` ~ ~ '~' ~ `` `~ ~ '~ ~ ~ ~` ~ `` `~ `` `` ~ ~ `` ~ ~ ~ `` `` ~ ~ `` `` `` ~ 14

012345678901234567890123456789012345678901234567890123456789
1 2 3 4 5
Trezoro detektita je distanco de 4 de la soni mekanismo.
Ni ne plu havas soni aparatoj! Nun ni devas turni la ŝipon ĉirkaŭe kaj estras
por domo kun trezoron brustojn ankoraŭ tie! Ludo finita.
La ceteraj kestoj estis tie:
0, 4
Ĉu vi volas ludi denove? (Jes aŭ ne)
neniu

Soni la Fonta Kodo

Sciante pri karteziaj koordinatoj, nombro linioj, negativaj nombroj, kaj absolutaj valoroj helpos nin kun niaj Soni ludo. Se vi ne opinias, ke vi komprenu tiujn konceptojn, reiru al la ĉapitro 12. Sube estas la fontkodon por la ludo. Tajpu ĝin en novan dosieron, tiam konservi la dosieron kiel sonar.py kaj ruli ĝin premante la F5 ŝlosilo. Vi ne bezonas kompreni la kodo por tajpi ĝin en aŭ ludi la ludon, la fonta kodo estos klarigita poste.
Ankaŭ, vi povas elŝuti la fontkodon de la libro de afiŝinto ĉe la URL http://inventwithpython.com/chapter13 .
sonar.py
Tiu kodo estas elŝutebla el http://inventwithpython.com/sonar.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. # Soni

  3. importi hazarda
  4. importado sys

  6. def drawBoard (tabulo):
  7. # Eltiru la estraro datumstrukturo.

  9. hline = '' # komenca spaco por la nombroj laŭ la maldekstra flanko de la tabulo
  10. por i en gamo (1, 6):
  11. hline + = ('' * 9) + str (i)

  13. # Presi la numeroj trans la supron
  14. print (hline)
  15. print ('' + ('0123456789 '* 6))
  16. print ()

  18. # Presi ĉiun el la 15 vicoj
  19. por i en gamo (15):
  20. # Sola-ciferaj nombroj bezonas esti vatita kun ekstra spaco
  21. se i <10:
  22. extraSpace = ''
  23. alie:
  24. extraSpace =''
  25. print ('% s% s% s% s'% (extraSpace, i, getRow (tabulo, i), i))

  27. # Presi la numeroj tra la fundo
  28. print ()
  29. print ('' + ('0123456789 '* 6))
  30. print (hline)


  33. def getRow (tabulo, vico):
  34. # Reveno ĉenon de la tabulo datumstrukturo en certa vico.
  35. boardRow =''
  36. por i en gamo (60):
  37. boardRow + = tabulo [i] [vico]
  38. revenu boardRow

  40. def getNewBoard ():
  41. # Kreu novan 60x15 tabulo datumstrukturo.
  42. estraro = []
  43. por x en gamo (60): # la ĉefa listo estas listo de 60 lertaj
  44. board.append ([])
  45. por y en gamo (15): # ĉiu lerta en la ĉefa listo havas 15 simpla karaktero ŝnuroj
  46. # Uzas malsamajn karakterojn por la oceano por fari ĝin pli legebla.
  47. se random.randint (0, 1) == 0:
  48. estraro [x]. append ('~')
  49. alie:
  50. estraro [x]. append ('`')
  51. revenu tabulo

  53. def getRandomChests (numChests):
  54. # Krei liston de brusto datumstrukturoj (du-ero lertaj de x, y int koordinatoj)
  55. brustojn = []
  56. por i en gamo (numChests):
  57. chests.append ([random.randint (0, 59), random.randint (0, 14)])
  58. reveno brustojn

  60. def isValidMove (x, y):
  61. # Reveno True se la koordinatoj estas sur la tabulo, alie False.
  62. reveno x> = 0 kaj x <= 59 kaj y> = 0 kaj y <= 14

  64. def makeMove (tabulo, brustoj, x, y):
  65. # Ŝanĝi la estraro datumstrukturo kun soni mekanismo karaktero. Forigi trezoro brustojn
  66. # El la brustojn listo kiel ili estas trovitaj. Reveno Falsa se ĉi tiu estas nevalida movado.
  67. # Alie, redoni la kordoj de la rezulto de ĉi tiu movo.
  68. se ne isValidMove (x, y):
  69. revenu Falsaj

  71. smallestDistance = 100 # ajna brusto estos pli ol 100.
  72. por cx, cy en brustojn:
  73. se abs (cx - x)> abs (cy - y):
  74. distanco = abs (cx - x)
  75. alie:
  76. distanco = abs (cy - y)

  78. se distanco <smallestDistance: # Ni volas ke la plej proksimaj trezorkesto.
  79. smallestDistance = distanco

  81. se smallestDistance == 0:
  82. # Xy estas rekte sur trezorkesto!
  83. chests.remove ([x, y])
  84. revenu 'Vi trovis subakvigita trezorkesto!
  85. alie:
  86. se smallestDistance <10:
  87. estraro [x] [y] = str (smallestDistance)
  88. reveno 'Trezoro detektita je distanco de% s el la soni mekanismo.' % (SmallestDistance)
  89. alie:
  90. estraro [x] [y] = 'O'
  91. reveno 'Soni ne detektis nenion. Ĉiuj trezoro brustojn el gamo.


  94. def enterPlayerMove ():
  95. # Lasu la ludanto tipo en ŝia movado. Reveno de du ero listo de int xy koordinatoj.
  96. print ('Kie vi volas lasi la sekvanta soni artefakto? (0-59 0-14) (aŭ tipo quit)')
  97. dum Vera:
  98. movi = input ()
  99. se move.lower () == 'quit':
  100. print ('Dankon pro ludi!')
  101. sys.exit ()

  103. movi = move.split ()
  104. se len (move) == 2 kaj movado [0]. isdigit () kaj movado [1]. isdigit () kaj isValidMove (_int_ (movi [0]), int (movi [1])):
  105. reveno [int (movi [0]), int (movi [1])]
  106. print ('Tajpu numeron de 0 al 59, spaco, tiam nombro de 0 al 14.')


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


  115. def showInstructions ():
  116. print ('' 'Instrukcioj:
  117. Vi estas la kapitano de la Simon, trezoron-ĉasado ŝipo. Viaj nunaj misio
  118. estas trovi la tri subakvigita trezoro brustojn kiuj kasxigxas en la parto de la
  119. oceano vi estas en kaj kolekti ilin.

  121. Ludi, eniri la koordinatojn de la punkto en la oceano vi deziras faligis
  122. soni mekanismo. La soni povas eltrovi kiel malproksime la plej proksima brusto estas al ĝi.
  123. Ekzemple, la d sube markas kie la aparato estis forigita, kaj la 2 de
  124. reprezenti distancoj de 2 for de la aparato. La 4 La reprezenti
  125. distancoj de 4 for de la aparato.

  127. 444444444
  128. 4 4
  129. 4 22222 4
  130. 4 2 2 4
  131. 4 2 d 2 4
  132. 4 2 2 4
  133. 4 22222 4
  134. 4 4
  135. 444444444
  136. Premu eniri por daŭrigi ...'' ')
  137. enigo ()

  139. print ('' 'Ekzemple, jen estas trezoro brusto (la c) lokita distanco de 2 for
  140. el la soni mekanismo (la d):

  142. 22222
  143. c 2
  144. 2 d 2
  145. 2 2
  146. 22222

  148. La punkto kie la aparato estis forigita estos markita kun 2.

  150. La trezoron brustojn ne movi. Soni aparatoj povas detekti trezoro
  151. brustojn ĝis distanco de 9. Se ĉiuj kestoj estas el teritorio, la punkto
  152. estos markita kun O

  154. Se mekanismo estas rekte falis sur trezoro brusto, vi trovis
  155. la situo de la brusto, kaj estos kolektitaj. La soni mekanismo volo
  156. resti tie.

  158. Kiam vi enspezi brusto, ĉiuj soni mekanismoj ĝisdatigos lokalizi la venonta
  159. plej proksima subakvigita trezorkesto.
  160. Premu eniri por daŭrigi ...'' ')
  161. enigo ()
  162. print ()


  165. print ('soni!')
  166. print ()
  167. presi ('Ĉu vi volas vidi la instrukciojn? (jes / ne)')
  168. se enigo (). malsupreniri (). startswith ('y'):
  169. showInstructions ()

  171. dum Vera:
  172. # Ludo instalinstrukciojn
  173. sonarDevices = 16
  174. theBoard = getNewBoard ()
  175. theChests = getRandomChests (3)
  176. drawBoard (theBoard)
  177. previousMoves = []

  179. dum sonarDevices> 0:
  180. # Komenco de turno:

  182. # Montri soni mekanismo / brusto stato
  183. se sonarDevices> 1: extraSsonar = 's'
  184. else: extraSsonar =''
  185. se len (theChests)> 1: extraSchest = 's'
  186. else: extraSchest =''
  187. print ("Vi havas% s soni aparato% s maldekstren.% s trezorkesto% s ceteraj. '% (sonarDevices, extraSsonar, len (theChests), extraSchest))

  189. x, y = enterPlayerMove ()
  190. previousMoves.append ([x, y]) # Ni devas spuri cxiujn movojn por ke soni aparatoj eblas ĝisdatigita.

  192. moveResult = makeMove (theBoard, theChests, x, y)
  193. se moveResult == Falsa:
  194. daŭrigi
  195. alie:
  196. se moveResult == 'Vi trovis subakvigita trezorkesto!':
  197. # Ĝisdatigi ĉiujn soni aparatoj nuntempe sur la mapo.
  198. por x, y en previousMoves:
  199. makeMove (theBoard, theChests, x, y)
  200. drawBoard (theBoard)
  201. print (moveResult)

  203. se len (theChests) == 0:
  204. print ('Vi trovis ĉiujn subakvigita trezoro brustojn! Congratulations kaj bona ludo!)
  205. rompi

  207. sonarDevices - = 1

  209. se sonarDevices == 0:
  210. print ("Ni \ 've elĉerpas de soni aparatoj! Nun ni devas turni la ŝipon ĉirkaŭ kaj kapo')
  211. print ('por domo kun trezoron brustojn ankoraŭ tie! Ludo finita.')
  212. print ('La ceteraj kestoj estis tie:')
  213. por x, y en theChests:
  214. print ('% s,% s'% (x, y))

  216. se ne playAgain ():
  217. sys.exit ()

Desegni la Programo

Soni estas speco de komplika, do ĝi povus esti pli bonaj por tajpi en la ludo kodo kaj ludi ĝin kelkajn fojojn unue kompreni kio okazas. Post vi ludis la ludon kelkaj tempoj, vi povas ia fari ideon de la sekvenco de okazaĵoj en ĉi tiu ludo.
La Soni ludo uzas listoj de listoj kaj aliaj komplikaj variabloj. Tiuj komplika variabloj estas konataj kiel datumstrukturoj. Datumstrukturoj lasos nin stoki aranĝoj de valoroj en sola variablo por reprezenti ion (kiel la lokojn de la trezoro brustojn en Soni). Ni uzos datumstrukturoj por la lokoj de la trezoro brustoj kaj faligis soni mekanismoj. Unu ekzemplo de datumstrukturo estis la tabulo variablo en la Tic Tac Toe ĉapitro.
Ĝi estas ankaŭ utila por skribi el la aĵoj kiujn ni bezonas nian programon por fari, kaj supreniru kun iu funkcio nomoj kiuj manipuli tiujn agojn. Memoru nomi funkcioj post kio ili specife fari. Alie ni povus fini forgesante funkcio, aŭ tajpante en du malsamaj funkcioj, kiuj faras la samon.
Tabelo 13-1: Listo de ĉiu funkcio la Soni ludo bezonas.
Kion la kodo devas fari. La funkcio kiu faros.
Presas la tabulo sur la ekrano bazita sur la tabulo datumstrukturo estas pasinta, inkludante la koordinatojn kune la supro, malsupro, kaj maldekstra kaj dekstra flankoj. drawBoard ()
Krei novan tabulo datumstrukturo. getNewBoard ()
Krei novan brustojn datumstrukturo kiun havas plurajn brustojn hazarde disĵetitaj tra la tabulo. getRandomChests ()
Kontrolu ke la XY koordinatoj kiuj pasis al ĉi tiu funkcio estas situita sur la tabulo aŭ ne. isValidMove ()
Lasu la ludanto tipo en la XY kunordigas de lia proksima movado kaj observados petante ĝis ili tajpu la koordinatojn ĝuste. enterPlayerMove ()
Meti soni mekanismo sur la tabulo, kaj ĝisdatigi la estraro datumstrukturo tiam revenu ĉenon kiu priskribas kio okazis. makeMove ()
Demandu la ludanto se ili volas ludi alia ludo de Soni. playAgain ()
Presi instrukciojn por la ludo. showInstructions ()
Tiuj povus ne esti ĉiuj funkcioj ni bezonas, sed lerta kiel ĉi estas bona ideo por helpi vin komenci kun programado viajn proprajn ludojn. Ekzemple, kiam desegni la drawBoard () funkcio en la Soni ludo, ni trovi ni ankaŭ bezonas funkcio kiu faras kio getRow () faras. Skribi funkcio fojon kaj tiam nomante ĝin dufoje estas preferinde skribi la kodon dufoje. La tuta punkto de funkcioj estas redukti duplikatajn kodo malsupren al unu loko, do se ni iam bezonos fari ŝanĝojn al tiu kodo oni nur bezonas ŝanĝi unu loko en nia programo.

Kiel la Kodo Verkoj: Linioj 1 ĝis 38

  1. # Soni

  3. importi hazarda
  4. importado sys
Ĉi tie ni importi du moduloj, hazarda kaj sys. La sys modulo enhavas la eliro () funkcio, kiu kaŭzas la programo tuj finiĝi. Ni nomas tiun funkcion poste en nia programo.

Desegno La Ludo Estraro

  1. def drawBoard (tabulo):
La dorso tick (') kaj supersigno (~) gravuloj lokita apud la 1 klavo en via klavaro. Ili similas al la ondoj de la oceano. Ie en tiu oceano estas tri trezoro brustojn, sed vi ne scias kie. Vi povas diveni ĝin per planti soni aparatoj, kaj diru al la ludo programo kie por tajpi en la X kaj Y koordinatoj (kiu estas presitaj sur la kvar flankoj de la ekrano.)
La drawBoard () funkcio estas la unua funkcio ni difinos por nia programo. La soni ludo tabulo estas ASCII-arto oceano kun koordinatoj iranta laŭ la X-kaj Y-akso, kaj aspektas jene:
1 2 3 4 5
012345678901234567890123456789012345678901234567890123456789

0 ~ ~ ~ `~ `` ~ ~ ~ `` ~ ~ ~ ~ ~ ``` ~ '~' ~ '~ ~ `~ ~ ~` ~ ~' ~ `` `` `` ~ ~ `~ `` ~ `~ ~ ``` ~ '~' 0
1 `~` ~ `` `` ~ ~ ~ `` `~ ``` ~ `` `~ ``` ~ `~ ~ ~ ~ ~ ``` ~ ~ ~ `` `` `` ~ `~ ' `~ ~ ~ ~ ``` ~ ~ '1
2 `` `~ ~ ~ ~` ~ `~ ~ ``` ~ ~ ~ ~ `` `` `` ~ ~ `~` ~ ~ '~' ~ '~ `` `~ ~' ~ `` ~ ~ `~` ~ ~ ~ ~ ~ ~ `~ 2
3 ~ ~ ~ ~ `~ ~ ~ ~ `` ``` ~ `` ~ ~ `~` ~ ~ '~' ~ ~ ~ `` `` `` ~ `~ `` `` ``` ~ ~ ' ~ `~` ~ `` `` `~ 3
4 ~ `` `~ ~ ~ ~ ~` ~ ~ `` `` ~ ~ ~ ~ `` `~ ~ ~` ~ '~' ~ `` `` ~ `~ ~ '~' ~ ~ `` ~ ~ `~ `` ~` ~ `` ~ ~ 4
5 `~ ``` ~ `~` ~ ~ '~ ~ ~ `` `~ ~ ~ `` `` `` `` `` ~ ~ ~` ~ `~ ~ ~ ~` ~ ~ `` ~ ~ ~ ~ ~ ~ `~ ``` ~ ~ `5
6 `` ~ ~ `~ ~ '~ `` ~ `` ``` ~ `` `` ~ ~ ~ `` `~ ~ ~ ~` ~ ~ `` `~ ~ ~ ~ ``` ~ `~ ~ `` ~ ~ ~ `` `~ ~ ~ 6
7 `` `` ~ ~ ~ ~ ~ ~ ~ `` `~` ~ `` `~ ~ ~ ~ ``` ~ `` ~ `~ ~ ~ ~ ~ ~ `` `` ``` ~ ~ ~ ` ~ ~ `~ ~ '~ ~` ~ ~ 7
8 ~ ~ `~` ~ ~ `` `~ `` ~ ~ `` ~ ~ ~ ~ ~ ``` ~ `~ ~ '~' ~ ``` ~ `` `~ ~ ~ ``` ~ ~ ~ ~ ~ ~ `~` ~ ~ ~ ~ `8
9 `` `~ `` ~` ~ ~ ~ `~ ~ ``` ~ `` `` ~ ~ ~ ~ `` `~ `` `` ``` ~ ~ '~ ~ `~ ~ ~ ~ ~` ~ `` ~ ~ ~ ~ ~ `` `9
10 `~ ~ ~ ~ ``` ~ `~ `` `` ~` ~ `~ ~ ~ ``` ~ ~ ~ ~ `~ `` `` ~ ~ ``` ~ ~ `` `` `` ` ~ `~ `` ~ `` ``` 10
11 ~ ~ `~` ~ ~ '~ `` ~ `~ ~ ~ `` `` `` `` `` `` `` `` ~ ~ `` ``` ~ `~ ~ ~ ``` ~ ~ ~ ~ `~ ~ ~` ~ ~ '~ 11
12 ~ ~ `~ ~ ~ ~ ``` ~ ~ ~ `` `` `~ ~ ~ ``` ~ `~ ~ `` `` `` ~` ~ ~ ~ `` `` `` `` `~ ~ `` ~ ~ ~ `~ ~ '~ 12
13 `~ `` `` `` `` ~ ~ ~` ~ ~ ~ `` `~ ~ ~ ~ ``` ~ ~ '~' ~ ~ ~ `~ `` `` ``` ~ ~ '~' `` `` ~ ~ `~ ~ ~ ~ 13
14 ~ ~ ~ ~ `` `` `~ `` ``` ~ ~ '~' ~ `` ~ ~ `~ `` ~` ~ ~ '~' ~ `` ~ `~ `` ~ ~ ~ `` `~ `` ``` ~ ~ ~ ~ 14

012345678901234567890123456789012345678901234567890123456789
1 2 3 4 5
Ni disigas la desegno en la drawBoard () funkcio en kvar paŝoj. Unue, ni kreas ĉenon variablo de la linio kun 1, 2, 3, 4, kaj 5 interspacigitaj evi larĝa breĉoj (por marki la koordinatojn por 10, 20, 30, 40, kaj 50). Due, ni uzas tiun ĉenon por montri la X-akso koordinatoj kune la supro de la ekrano. Trie, ni presi ĉiu vico de la oceano apud la Y-akso koordinatojn en ambaŭ flankoj de la ekrano. Kaj la kvara, ni presi la X-akso denove ĉe la malsupro. Havante la koordinatojn en ĉiuj flankoj faciligas por la ludanto movi siajn Finger kune la spacojn por vidi kie precize ili volas plani soni mekanismo.

Desegno la X-koordinatojn Kune la Top

  1. # Eltiru la estraro datumstrukturo.

  3. hline = '' # komenca spaco por la nombroj laŭ la maldekstra flanko de la tabulo
  4. por i en gamo (1, 6):
  5. hline + = ('' * 9) + str (i)
Ni rigardu denove ĉe la supra parto de la tabulo, ĉifoje kun plusoj anstataŭ malplenan spacoj tiel ni povas kalkuli la spacoj pli facila:

Figuro 13-3: La Interspacigo ni uzas por presi la supro de la tabulo.
La nombroj en la unua linio kiu markas la dekoj pozicio ĉiuj havas naŭ spacoj inter ili, kaj estas dek tri spacoj antaŭ la 1. Ni tuj krei ĉenon kun ĉi linion kaj konservi ĝin en variablo nomata hline.
  1. # Presi la numeroj trans la supron
  2. print (hline)
  3. print ('' + ('0123456789 '* 6))
  4. print ()
Por presi la numeroj trans la supro de la soni tabulo, ni unua presi la enhavo de la hline variablo. Tiam en la sekvanta linio, ni presas tri spacoj (por ke ĉi vico regiono korekte), kaj tiam presi la kordo '012345678901234567890123456789012345678901234567890123456789 '. Sed tio estas teda por tajpi en la fonto, tiel anstataŭ ni tipo ('0123456789 '* 6) kiu taksas la sama ŝnuro.

Desegno la Linioj de Oceano

  1. # Presi ĉiun el la 15 vicoj
  2. por i en gamo (15):
  3. # Sola-ciferaj nombroj bezonas esti vatita kun ekstra spaco
  4. se i <10:
  5. extraSpace = ''
  6. alie:
  7. extraSpace =''
  8. print ('% s% s% s% s'% (extraSpace, i, getRow (tabulo, i), i))
Nun ni presas la ĉiu vico de la tabulo, inkludante la numeroj laŭ la flanko etiquetar la Y-akso. Ni uzas la por buklo presi vicoj 0 tra 14 en la tabulo, kune kun la vico nombroj sur ĉiu flanko de la tabulo.
Ni havas malgrandan problemon. Nombroj kun nur unu cifero (kiel 0, 1, 2, kaj tiel plu) nur prenu unu spaco kiam ni presas ilin, sed nombroj kun du ciferoj (kiel 10, 11, kaj 12) levu du spacoj. Tio signifas la vicoj eble ne laŭliniigi kaj devus aspekti jene:
8 ~ ~ `~` ~ ~ `` `~ `` ~ ~ `` ~ ~ ~ ~ ~ ``` ~ `~ ~ '~' ~ ``` ~ `` `~ ~ ~ ``` ~ ~ ~ ~ ~ ~ `~` ~ ~ ~ ~ `8
9 `` `~ `` ~` ~ ~ ~ `~ ~ ``` ~ `` `` ~ ~ ~ ~ `` `~ `` `` ``` ~ ~ '~ ~ `~ ~ ~ ~ ~` ~ `` ~ ~ ~ ~ ~ `` `9
10 `~ ~ ~ ~ ``` ~ `~ `` `` ~` ~ `~ ~ ~ ``` ~ ~ ~ ~ `~ `` `` ~ ~ ``` ~ ~ `` `` `` ` ~ `~ `` ~ `` ``` 10
11 ~ ~ `~` ~ ~ '~ `` ~ `~ ~ ~ `` `` `` `` `` `` `` `` ~ ~ `` ``` ~ `~ ~ ~ ``` ~ ~ ~ ~ `~ ~ ~` ~ ~ '~ 11
La solvo estas facila. Ni nur aldonu spaco antaŭ ĉiuj la sola-ciferaj nombroj. La se - alia aserto ke komencas la linio 21 tion faras. Ni presas la variablo extraSpace kiam ni presi la vico, kaj se mi estas malpli ol 10 (kiu signifas ke ĝi havas nur unu cifero), ni atribui sola spaco ŝnuro al extraSpace. Alie, ni starigis extraSpace esti malplenan ĉenon. Tiel, ĉiuj niaj vicoj vicigas kiam ni presi ilin.
La getRow () funkcio estos redoni ĉeno reprezentas la vico numeron ni pasi ĝin. Liaj du parametroj estas la tabulo datumstrukturo stokita en la tabulo ŝanĝiĝema kaj vico nombro. Ni rigardu tiun funkcion poste.

Desegno la X-koordinatojn Kune la Fundo

  1. # Presi la numeroj tra la fundo
  2. print ()
  3. print ('' + ('0123456789 '* 6))
  4. print (hline)
Tiu kodo estas simila al linioj 13 al 16. Ĉi presos la X-akso koordinatoj sur la fundo de la ekrano.

Havigo de la ŝtato de Vico en la Oceano

  1. def getRow (tabulo, vico):
  2. # Reveno ĉenon de la tabulo datumstrukturo en certa vico.
  3. boardRow =''
  4. por i en gamo (60):
  5. boardRow + = tabulo [i] [vico]
  6. revenu boardRow
Ĉi tiu funkcio konstruas ŝnuro nomita boardRow el la karakteroj stokitaj en tabulo. Unue ni aro boardRow la malplenan ĉenon. La vico nombro (kiu estas la Y koordinato) estas pasita kiel parametro. La kordoj ni volas estas farita per concatenating estraro [0] [vico], estraro [1] [vico], estraro [2] [vico], kaj tiel plu ĝis estraro [59] [vico]. (Ĉi tiu estas ĉar la vico konsistas el 60 signoj, de indekso 0 al indekso 59.)
La por buklo iterates de entjeroj 0 al 59. Sur ĉiu ripeto la venonta signo en la tabulo datumstrukturo estas kopiita al la fino de boardRow. Por la momento la buklo estas farita, boardRow estas plene formita, do ni redoni ĝin.

Kiel la Kodo Verkoj: Linioj 40 al 62

Nun ke ni havas funkcion por presi donita tabulo datumstrukturo al la ĉeno, ni turnas nin al la aliaj funkcioj, ke ni bezonas. Je la komenco de la ludo, ni bezonos por krei novan ludon tabulo datumstrukturo (ia kiel malplenan Tic Tac Toe tabulo) kaj ankaŭ meti trezoro brustojn hazarde ĉirkaŭ la tabulo. Ni devas ankaŭ krei funkcio kiu povas diri se la koordinatojn eniris por la ludanto estas valida movado aŭ ne.

Krei Nova Ludo Estraro

  1. def getNewBoard ():
  2. # Kreu novan 60x15 tabulo datumstrukturo.
  3. estraro = []
  4. por x en gamo (60): # la ĉefa listo estas listo de 60 lertaj
  5. board.append ([])
Je la komenco de ĉiu nova ludo, ni bezonos dolĉa tabulo datumstrukturo. La estraro datumstrukturo estas listo de listoj de kordoj. La unua listo reprezentas la X koordinato. Ekde nia ludo tabulo estas 60 signoj larĝa, tiu unua listo bezonas enhavi 60 listojn. Do ni krei por buklo kiu aldonas 60 malplenan lertaj al ĝi.
  1. por y en gamo (15): # ĉiu lerta en la ĉefa listo havas 15 simpla karaktero ŝnuroj
  2. # Uzas malsamajn karakterojn por la oceano por fari ĝin pli legebla.
  3. se random.randint (0, 1) == 0:
  4. estraro [x]. append ('~')
  5. alie:
  6. estraro [x]. append ('`')
Sed tabulo estas pli ol nur liston de 60 malplenan listoj. Ĉiu el la 60 lertaj reprezentas la Y koordinato de nia ludo tabulo. Estas 15 vicoj en la tabulo, tiel ĉiu el tiuj 60 lertaj devas havi 15 signoj en ili. Ni havas alian por buklo aldoni 15 simpla karaktero ŝnuroj kiu reprezentas la oceano. La "oceano" estos nur esti faskon da '~' kaj '`' kordoj, do ni hazarde elektas inter tiuj du. Ni povas fari ĉi tion generante hazarda nombro inter 0 kaj 1 kun alvoko al random.randint (). Se la reveno valoro de random.randint () estas 0, ni aldonos la '~' kordoj. Alie ni aldonos la '`' kordoj.
Ĉi tio estas kiel decidi kiu karaktero de uzi por ĵetanta monero. Kaj ĉar la reveno valoro de random.randint () estos 0 proksimume duono de la tempo, la duono de la oceano gravuloj estos '~' kaj la alia duono estos '`'. Ĉi donos niajn oceano hazarda, choppy rigardon al ĝi.
Memoru ke la estraro variablo estas listo de 60 lertaj kiu havas 15 kordojn. Tio signifas atingi la kordo en koordinata 26, 12, ni devus havi aliron estraro [26] [12], kaj ne estraro [12] [26]. La X koordinato estas unua, tiam la Y koordinato.
Figuro 13-4 estas la portreto por pruvi la indeksoj de listo de lertaj nomata x. La ruĝa sagoj indikas indeksas de la interna lertaj mem. La bildo estas ankaŭ spegulita sur lia flanko por plifaciligi legi:

Figuro 13-4: La indicoj de listo de listoj.
  1. revenu tabulo
Fine, ni revenas al la estraro variablo. Memoru ke en ĉi tiu kazo, ni revenas referenco al la listo por ke ni faris. Ĉiuj ŝanĝoj kiujn ni faris al la listo (aux la lertaj interne la listo) en nia funkcio estos ankoraŭ esti tie ekstere de la funkcio.

Kreante la Trezoro Hazarda brustojn

  1. def getRandomChests (numChests):
  2. # Krei liston de brusto datumstrukturoj (du-ero lertaj de x, y int koordinatoj)
  3. brustojn = []
  4. por i en gamo (numChests):
  5. chests.append ([random.randint (0, 59), random.randint (0, 14)])
  6. reveno brustojn
Alia tasko ni bezonas fari en la komenco de la ludo estas decidi kie la kaŝitan trezoron brustojn estas. Ni reprezentas la trezoro brustojn en nia ludo kiel listo de listoj de du entjeroj. Tiuj du entjeroj estos la X kaj Y koordinatoj. Ekzemple, se la brusto datumstrukturo estis [[2, 2], [2, 4], [10-0]], tiam tio signifus ke estas tri trezoro brustoj, unu cxe 2, 2, alia ĉe 2, 4 , kaj tria unu ĉe 10, 0.
Ni pasos la numChests parametro diri la funkcio kiom trezoro brustojn ni volas ke ĝi generas. Ni starigis por buklo persisti tiu nombro de fojoj, kaj sur ĉiu ripeto ni aldonas liston de du hazardaj entjeroj. La X koordinato povas esti ie ajn de 0 al 59, kaj la Y koordinato povas esti ie ajn inter 0 kaj 14. La esprimo [random.randint (0, 59), random.randint (0, 14)] kiu estas pasita al la append metodo taksos al iu kiel [2, 2] aŭ [2, 4] aŭ [10, 0] . Ĉi datumstrukturo estas poste revenis.

Determini se Move estas Valida

  1. def isValidMove (x, y):
  2. # Reveno True se la koordinatoj estas sur la tabulo, alie False.
  3. reveno x> = 0 kaj x <= 59 kaj y> = 0 kaj y <= 14
La ludanto tajpi en X kaj Y koordinatoj de kie ili volas faligis soni mekanismo. Sed ili ne enmeti koordinatoj kiuj ne ekzistas en la tabulo. La ikso koordinatoj devas esti inter 0 kaj 59, kaj la Y koordinato devas esti inter 0 kaj 14. Ĉi tiu funkcio uzas simplan esprimon kiu uzas kaj operatoroj por certigi ke ĉiu parto de la kondiĉo estas vera. Se nur unu estas Falsa, tiam la tuta esprimo taksas al False. Ĉi Bulea valoro estas redonata de la funkcio.

Kiel la Kodo Verkoj: Linioj 64 al 91

Metante Movi en la Estraro

  1. def makeMove (tabulo, brustoj, x, y):
  2. # Ŝanĝi la estraro datumstrukturo kun soni mekanismo karaktero. Forigi trezoro brustojn
  3. # El la brustojn listo kiel ili estas trovitaj. Reveno Falsa se ĉi tiu estas nevalida movado.
  4. # Alie, redoni la kordoj de la rezulto de ĉi tiu movo.
  5. se ne isValidMove (x, y):
  6. revenu Falsaj
En nia Soni ludo, la tabulo estas ĝisdatigita por montri kelkajn por ĉiu soni mekanismo falis. La nombro montras kiel malproksime la plej proksima trezorkesto estas. Do kiam la ludanto faras movon, donante la programo de X kaj Y koordinato, ni ŝanĝos la estraro bazita sur la pozicioj de la trezoron brustojn. Jen kial nia makeMove () funkcio prenas kvar parametroj: la tabulo datumstrukturo, la trezoro brustojn datumstrukturoj, kaj la X kaj Y koordinatoj.
Ĉi tiu funkcio estos redoni la Falsa Bulea valoro se la X kaj Y koordinatoj se estis aprobita ne ekzistas sur la tabulo. Se isValidMove () False, tiam makeMove () revenos False.
Se la koordinatojn landon rekte sur la trezoron, makeMove () redonos la ĉenon 'Vi trovis subakvigita trezorkesto!'. Se la XY koordinatoj estas ene de distanco de 9 aŭ malpli de trezoro brusto, ni revenas al la ĉeno 'Trezoro detektita je distanco de% s el la soni mekanismo.' (Kie% s estas la distanco). Alie, makeMove () redonos la ĉenon 'Soni ne detektis nenion. Ĉiuj trezoro brustojn el gamo. '.
  1. smallestDistance = 100 # ajna brusto estos pli ol 100.
  2. por cx, cy en brustojn:
  3. se abs (cx - x)> abs (cy - y):
  4. distanco = abs (cx - x)
  5. alie:
  6. distanco = abs (cy - y)

  8. se distanco <smallestDistance: # Ni volas ke la plej proksimaj trezorkesto.
  9. smallestDistance = distanco
Donita la XY kunordigas de kie la ludanto volas faligi la soni mekanismo, kaj listo de XY kunordigas la trezoro brustojn (en la brustojn listo de listoj), ni bezonas algoritmon por eltrovi kio trezorkesto estas plej proksima.

An algoritmo por trovi la Plej proksima Trezoro Brusto

Dum la x kaj y variabloj estas nur entjeroj (diri, 5 kaj 0), ili kune reprezentas la situo sur la tabulo (kiu estas kartezia koordinatsistemo) kie la ludanto divenis. La brustojn variablo povas havi valoron kiel [[5, 0], [0, 2], [4, 2]], tiun valoron reprezentas la lokojn de tri trezoro brustojn. Kvankam tiuj variabloj estas aro da nombroj, ni povas bildigi ĝin tiamaniere:

Figuro 13-5: La lokojn sur la tabulo kiu [[5, 0], [0, 2], [4, 2]] reprezentas.
Postado por às

Nenhum comentário:

Postar um comentário

Assinar: Postar comentários (Atom)