Python - Problemas con un clon de Snake

   
Vista:
Imágen de perfil de Rodrigo Fernando

Problemas con un clon de Snake

Publicado por Rodrigo Fernando (2 intervenciones) el 17/01/2018 15:07:40
Hola amig@s:

Espero estén bien. Paso a explicar el problema. Resulta que he estado modificando un código de Snake (Viborita) para un trabajo académico (Pygame). El código estaba bien, hasta que implementé algunas mejoras y todo falló. Lo que pasa es que:

1) Por alguna razón que desconozco, la serpiente avanza rápido (ésto no lo he modificado, así que es raro).
2) Normalmente la serpiente cuando colisiona con su cuerpo termina el juego. Ahora pasa de largo y no hace Game Over.
3) Supuestamente, si se suman 3 puntos, la serpiente debe aumentar su velocidad en 1. Tampoco.

Adjunto código para mejor comprensión.

Gracias por su ayuda de antemano. Saludos.

:8)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
import pygame
import time
import os #, pygame
import random
 
def load_image(name):
    path = os.path.join('', name)
    return pygame.image.load(path).convert()
 
pygame.init()
 
icono = pygame.image.load("icon.png")
pygame.display.set_icon(icono)
 
 
Blanco = (255, 255, 255)
Negro = (0, 0, 0)
Rojo = (255, 0, 0)
Azul = (0, 0, 255)
Verde = (0, 128, 0)
Lila = (128, 149, 192)
Otro = (147, 231, 253)
 
ancho = 1280
altura = 720
 
 
superficie = pygame.display.set_mode((ancho,altura))
pygame.display.set_caption('Serpiente')
 
azarManzanaVerdeX = round(random.randrange(0, ancho - 20)/20.0)*20.0
azarManzanaVerdeY = round(random.randrange(0, altura - 20)/20.0)*20.0
azarManzanaLilaX = round(random.randrange(0, ancho - 20)/20.0)*20.0
azarManzanaLilaY = round(random.randrange(0, altura - 20)/20.0)*20.0
 
background = load_image('f_game.jpg')
gover_brackground = load_image('f_gameover.jpg')
pause_brackground = load_image('f_gamepause.jpg')
 
superficie.blit(background, [0, 0])
 
 
reloj = pygame.time.Clock()
 
serp_tamano = 20
 
 
font = pygame.font.SysFont("arial.ttf", 35)
 
 
def pausa():
    pausado = True
 
    while pausado:
 
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_c:
                    pausado = False
 
                elif event.key == pygame.K_q:
                    pygame.quit()
                    quit()
        superficie.blit(pause_brackground, [0, 0])
        #superficie.fill(Blanco)      
        message_to_screen("Pausa", Negro, -100)
        pygame.display.update()
        reloj.tick(5)
 
 
def puntos(score):
    text = font.render("Puntos: "+str(score), True, Negro)
    superficie.blit(text, [0,0])
 
 
def Rapidez(score):
    text = font.render("Rapidez: "+str(score), True, Verde)
    superficie.blit(text, [800,0])
 
def intro_juego():
    intro = True
    while intro:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_c:
                    intro = False
                if event.key == pygame.K_q:
                    pygame.quit()
                    quit()
 
        intro_background = load_image('f_gameintro.jpg')
        superficie.blit(intro_background, [0, 0])
        message_to_screen("Bienvenido, bienvenida", Blanco, -100)
        message_to_screen("El objetivo del juego es controlar una serpiente usando", Otro, -50)
        message_to_screen("teclas flechas de movimiento para comer manzanas", Otro, 0)
        message_to_screen("Si la serpiente toca el borde o se toca a si misma, pierdes.", Blanco, 50)
        message_to_screen("Para pausar partida, presiona tecla P.", Otro, 100)
        message_to_screen("Para continuar partida, presiona tecla C.", Otro, 150)
        message_to_screen("Para terminar de jugar y salir, presiona tecla Q.", Blanco, 200)
        pygame.display.update()
        reloj.tick(15)
 
def serpiente(serp_tamano, listaSerpiente):
    for i in listaSerpiente:
        pygame.draw.rect(superficie, Negro, [i[0],i[1],serp_tamano,serp_tamano])
 
def text_objetos(text, color):
    textSuperficie = font.render(text, True, color)
    return textSuperficie, textSuperficie.get_rect()
def message_to_screen(msg, color, y_displace=0):
    textSur, textRect = text_objetos(msg, color)
    textRect.center = (ancho/2), (altura/2)+ y_displace
    superficie.blit(textSur, textRect)
    #pantalla_texto = font.render(msg, True, color)
    #superficie.blit(pantalla_texto,[ancho/2, altura/2])
 
 
 
def gameLoop():
    gameExit = False
    gameOver = False
    velX = 0
    mover_x = 300
    mover_y = 300
    puntos1 = 0
    CPS = 15
 
    mover_x_cambio = 0
    mover_y_cambio = 0
 
    listaSerpiente = []
    largoSerpiente = 1
 
    azarManzanaX = round(random.randrange(0, ancho - 20)/20.0)*20.0
    azarManzanaY = round(random.randrange(0, altura - 20)/20.0)*20.0
# otras manzanas  *****   Verdes  ***** Lilas
    azarManzanaVerdeX = round(random.randrange(0, ancho - 20)/20.0)*20.0
    azarManzanaVerdeY = round(random.randrange(0, altura - 20)/20.0)*20.0
    azarManzanaLilaX = round(random.randrange(0, ancho - 20)/20.0)*20.0
    azarManzanaLilaY = round(random.randrange(0, altura - 20)/20.0)*20.0
 
    pulsar_sonido = pygame.mixer.Sound("song.ogg")
    pulsar_sonido.set_volume(0.50)
    pulsar_sonido.play(18)
 
 
 
    while not gameExit:
 
        while gameOver == True:
 
 
 
            superficie.fill(Blanco)
            superficie.blit(gover_brackground, [0, 0])
            #pulsar_sonido.stop()
            message_to_screen("Game Over", Negro, -50)
            message_to_screen("Para continuar presione C. Para terminar presione Q", Rojo, 50)
            pygame.display.update()
 
            for event in pygame.event.get():
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_q:
                        gameExit = True
                        gameOver = False
                    if event.key == pygame.K_c:
                        gameLoop()
 
 
 
 
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
 
                gameExit = True
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_LEFT:
                    mover_x_cambio = -serp_tamano
                    mover_y_cambio = 0
 
                elif event.key == pygame.K_RIGHT:
                    mover_x_cambio = serp_tamano
                    mover_y_cambio = 0
 
                elif event.key == pygame.K_UP:
                    mover_y_cambio = -serp_tamano
                    mover_x_cambio = 0
 
                elif event.key == pygame.K_DOWN:
                    mover_y_cambio = serp_tamano
                    mover_x_cambio = 0
 
                elif event.key == pygame.K_p:
                    pulsar_sonido.set_volume(0.0)
                    pausa()
                    pulsar_sonido.set_volume(0.50)
 
                elif event.key == pygame.K_q:
                    pulsar_sonido.set_volume(0.0)
                    gameExit = True
                    gameOver = False
                    pulsar_sonido.set_volume(0.50)
 
 
 
        if mover_x >= ancho or mover_x < 0 or mover_y >= altura or mover_y < 0:
            gameOver = True
 
 
        mover_x += mover_x_cambio
        mover_y += mover_y_cambio
        ##superficie.fill(blanco)
        #superficie.blit(background, [0, 0])
 
        pygame.draw.rect(superficie, Rojo, [azarManzanaX, azarManzanaY, 20, 20])
        pygame.draw.rect(superficie, Lila, [azarManzanaLilaX, azarManzanaLilaY, 20, 20])
        pygame.draw.rect(superficie, Verde, [azarManzanaVerdeX, azarManzanaVerdeY, 20, 20])
 
        cabezaSerpiente = []
        cabezaSerpiente.append(mover_x)
        cabezaSerpiente.append(mover_y)
        listaSerpiente.append(cabezaSerpiente)
        if len(listaSerpiente) > largoSerpiente:
            del listaSerpiente[0]
 
        for eachSegment in listaSerpiente[:-1]:
            if eachSegment == cabezaSerpiente:
                gameOver = True
 
 
        serpiente(serp_tamano,listaSerpiente)
        puntos(puntos1)
        Rapidez(velX)
        #CPS +=1
 
        pygame.display.update()
 
 
 
        if mover_x == azarManzanaX and mover_y == azarManzanaY:
# Cambiar el sonido
            #pygame.mixer.music.load("Sonig.ogg")
            azarManzanaX = round(random.randrange(0, ancho-20)/20.0)*20.0
            azarManzanaY = round(random.randrange(0, altura-20)/20.0)*20.0
            largoSerpiente += 1
            puntos1 += 1
            if puntos1 == 3:
                velX +=1
 
 
 
            #pygame.mixer.music.play(0)
 
        if mover_x == azarManzanaLilaX and mover_y == azarManzanaLilaY:
            #pygame.mixer.music.load("Sonig.ogg")
            azarManzanaLilaX = round(random.randrange(0, ancho-20)/20.0)*20.0
            azarManzanaLilaY = round(random.randrange(0, altura-20)/20.0)*20.0
            #largoSerpiente += 1
 
            #pygame.mixer.music.play(0)
        if mover_x == azarManzanaVerdeX and mover_y == azarManzanaVerdeY:
 
            #pygame.mixer.music.load("Sonig.ogg")
            azarManzanaVerdeX = round(random.randrange(0, ancho-20)/20.0)*20.0
            azarManzanaVerdeY = round(random.randrange(0, altura-20)/20.0)*20.0
            #largoSerpiente += 1
 
            #pygame.mixer.music.play(0)    
        reloj.tick(CPS)
 
 
    pygame.quit()
    quit()
 
intro_juego()
gameLoop()
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Antoni Masana

Problemas con un clon de Snake

Publicado por Antoni Masana (9 intervenciones) el 18/01/2018 07:33:21
Te comento las cosas que veo que pueden hacer que deje de funcionar bien.

Líneas mal alineadas: 142, 247
Líneas comentadas que no deberian de estarlo: 240, 264, 272
Líneas comentadas que quizas no deberian de estar: 68, 120, 121, 218, 219
Líneas comentadas que no afectan al funcionamiento: 248, 258, 261, 269, 274.

Por lo demás no puedo probarlo por que me faltan ficheros.

Saludos.
\\//_
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar
Imágen de perfil de Rodrigo Fernando

Problemas con un clon de Snake

Publicado por Rodrigo Fernando (2 intervenciones) el 20/01/2018 20:16:50
Después de muchos días donde no encontraba ni siquiera una aproximación, decidí rehacer el código desde 0. Gracias a ello, logré que la serpiente se comiera la manzana y que cada tres puntos aumentara la velocidad. Ahora surgió un nuevo problema. Resulta que debí incluir dos manzanas más (creo que también estaban en el código anterior). Se crean de forma aleatoria igual que la roja pero cuando intento asignarle las nuevas instrucciones a las nuevas (Si come la verde aumenta la velocidad en 1 y si come la lila se alarga en 10 cuadros) o muestra errores en variables o bien pasa la serpiente de largo y no hace nada. Adjunto el código nuevo aquí y de paso agradezco al usuario Antoni Masana por los comentarios sobre el código.

Muchas gracias de antemano.
:8)

PD: Espero no sea problema que aparezcan en el código llamadas a archivos de imagen cuando los quieran revisar. Si quieren los pueden cambiar por el color de su preferencia.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
import pygame
import time
import random
 
pygame.init()
Blanco = (255, 255, 255)
Negro = (0, 0, 0)
Rojo = (255, 0, 0)
Azul = (0, 0, 255)
Verde = (0, 128, 0)
Lila = (128, 149, 192)
 
Ancho = 1280
Alto = 720
 
FPS = 8
 
 
 
gameDisplay = pygame.display.set_mode((Ancho, Alto))
pygame.display.set_caption('Snake')
 
pygame.display.update()
 
reloj = pygame.time.Clock()
 
tamano_bloque = 20
 
font = pygame.font.Font("Pokemon-Red.ttf", 25)
 
img_gameover = pygame.image.load('f_gameover.jpg')
img_fondojuego = pygame.image.load('f_game.jpg')
img_pausajuego = pygame.image.load('f_gamepause.jpg')
img_intro = pygame.image.load('f_gameintro.jpg')
 
icon = pygame.image.load('Martin-Berube-Animal-Snake.ico')
pygame.display.set_icon(icon)
 
def text_objetos(text, color):
    textSuperficie = font.render(text, True, color)
    return textSuperficie, textSuperficie.get_rect()
def message_to_screen(msg, color, y_displace=0):
    textSur, textRect = text_objetos(msg, color)
    textRect.center = (Ancho/2), (Alto/2)+ y_displace
    gameDisplay.blit(textSur, textRect)
 
 
def azarManzana():
    azarManzanaX = round(random.randrange(0, Ancho - tamano_bloque))  # /10.0)*10.0
    azarManzanaY = round(random.randrange(0, Alto - tamano_bloque))  # /10.0)*10.0
    return azarManzanaX, azarManzanaY
 
 
def azarManzanaLila():
    azarManzanaLilaX = round(random.randrange(0, Ancho - tamano_bloque))  # /10.0)*10.0
    azarManzanaLilaY = round(random.randrange(0, Alto - tamano_bloque))  # /10.0)*10.0
    return azarManzanaLilaX, azarManzanaLilaY
 
def azarManzanaVerde():
    azarManzanaVerdeX = round(random.randrange(0, Ancho - tamano_bloque))  # /10.0)*10.0
    azarManzanaVerdeY = round(random.randrange(0, Alto - tamano_bloque))  # /10.0)*10.0
    return azarManzanaVerdeX, azarManzanaVerdeY
 
 
def pausa():
    pausado = True
 
    while pausado:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()
 
            if event.type == pygame.KEYDOWN:
              if event.key == pygame.K_c:
                  pulsar_sonido.set_volume(0.0)
                  pausado = False
                  pulsar_sonido.set_volume(0.50)
              elif event.key == pygame.K_q:
                  pygame.quit()
                  quit()
        gameDisplay.blit(img_pausajuego, [0, 0])
        message_to_screen("Pausa", Negro, -100)
        message_to_screen("Presiona C para continuar o Q para salir.", Negro, 25)
        pygame.display.update()
        reloj.tick(5)
 
 
 
def puntaje(puntos):
    text = font.render("Puntos: "+str(puntos), True, Negro)
    gameDisplay.blit(text, [0, 0])
 
 
def velocidad(vel):
    text = font.render("Rapidez: " + str(vel), True, Verde)
    gameDisplay.blit(text, [300, 0])
 
 
 
 
def game_intro():
    intro = True
    while intro:
 
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()
 
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_c:
                    intro = False
                if event.key == pygame.K_q:
                    pygame.quit()
                    quit()
 
        gameDisplay.blit(img_intro, [0, 0])
        message_to_screen("Bienvenido, bienvenida", Rojo, -100)
        message_to_screen("El objetivo del juego es controlar una serpiente usando", Negro, -50)
        message_to_screen("teclas flechas de movimiento para comer manzanas", Negro, 0)
        message_to_screen("Si la serpiente toca el borde o se toca a si misma, pierdes.", Rojo, 50)
        message_to_screen("Para pausar partida, presiona tecla P.", Negro, 100)
        message_to_screen("Para continuar partida, presiona tecla C.", Negro, 150)
        message_to_screen("Para terminar de jugar y salir, presiona tecla Q.", Rojo, 200)
        pygame.display.update()
        reloj.tick(15)
 
def serpiente(tamano_bloque, lista_serpiente):
    for XnY in lista_serpiente:
        pygame.draw.rect(gameDisplay, Negro, [XnY[0], XnY[1], tamano_bloque, tamano_bloque])
 
 
def gameLoop():
 
    gameExit = False
    gameOver = False
    mover_x = Ancho / 2
    mover_y = Alto / 2
    mover_x_cambio = 0
    mover_y_cambio = 0
 
    aumentoVelocidad = 0
    veli = 0
 
    lista_serpiente = []
    largo_serpiente = 1
 
    azarManzanaX, azarManzanaY = azarManzana()
    azarmanzanaLilaX, azarmanzanaLilaY = azarManzanaLila()
    azarManzanaVerdeX, azarManzanaVerdeY = azarManzanaVerde()
 
    pulsar_sonido= pygame.mixer.Sound("01. princip-Song.ogg")
    pulsar_sonido.set_volume(0.50)
    pulsar_sonido.play(18)
 
    while not gameExit:
 
        while gameOver == True:
            pulsar_sonido.set_volume(0.0)
            pulsar_sonido.stop()
            gameDisplay.blit(img_gameover, [0, 0])
            message_to_screen("GAME OVER", Rojo, -50)
            message_to_screen("Para continuar presione C. Para terminar presione Q", Rojo, 50)
            pulsar_sonido.set_volume(0.50)
            pygame.display.update()
 
            for event in pygame.event.get():
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_q:
                        gameExit = True
                        gameOver = False
                    if event.key == pygame.K_c:
                        gameLoop()
 
        for event in pygame.event.get():
            # print(event)
            if event.type == pygame.QUIT:
                gameExit = True
                gameOver = False
 
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_LEFT:
                    mover_x_cambio = -tamano_bloque
                    mover_y_cambio = 0
                elif event.key == pygame.K_RIGHT:
                    mover_x_cambio = tamano_bloque
                    mover_y_cambio = 0
 
                elif event.key == pygame.K_UP:
                    mover_y_cambio = -tamano_bloque
                    mover_x_cambio = 0
                elif event.key == pygame.K_DOWN:
                    mover_y_cambio = tamano_bloque
                    mover_x_cambio = 0
                elif event.key == pygame.K_p:
                    pulsar_sonido.set_volume(0.0)
                    pausa()
                    pulsar_sonido.set_volume(0.50)
 
        if mover_x > Ancho or mover_x < 0 or mover_y > Alto or mover_y < 0:
            gameOver = True
 
        mover_x += mover_x_cambio
        mover_y += mover_y_cambio
        gameDisplay.blit(img_fondojuego, [0, 0])
        truco_manzana = 15
        pygame.draw.rect(gameDisplay, Rojo, [azarManzanaX, azarManzanaY, truco_manzana, truco_manzana])
        pygame.draw.rect(gameDisplay, Lila, [azarmanzanaLilaX, azarmanzanaLilaY, truco_manzana, truco_manzana])
        pygame.draw.rect(gameDisplay, Verde, [azarManzanaVerdeX, azarManzanaVerdeY, truco_manzana, truco_manzana])
 
 
        cabeza_serpiente = []
        cabeza_serpiente.append(mover_x)
        cabeza_serpiente.append(mover_y)
        lista_serpiente.append(cabeza_serpiente)
 
 
 
        if len(lista_serpiente) > largo_serpiente:
            del lista_serpiente[0]
 
        for eachSegment in lista_serpiente[:-1]:
            if eachSegment == cabeza_serpiente:
                gameOver = True
 
 
        serpiente(tamano_bloque, lista_serpiente)
 
        puntaje(largo_serpiente-1)
 
 
 
        velocidad(veli)
 
 
 
        pygame.display.update()
 
        if mover_x - truco_manzana < azarManzanaX < mover_x + tamano_bloque and mover_y - truco_manzana < azarManzanaY < mover_y + tamano_bloque:
            azarManzanaX, azarManzanaY = azarManzana()
            largo_serpiente += 1
            aumentoVelocidad += 1
            pygame.mixer.music.load("nam.ogg")
            pygame.mixer.music.play(0)
 
            if aumentoVelocidad == 3:
                veli += 3
                aumentoVelocidad = 0
 
 
 
 
 
        reloj.tick(FPS+veli)
 
    pygame.quit()
    quit()
 
game_intro()
gameLoop()
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar