class Game:
def __init__(self, gameWindow, mainBatch, backgroundGroup, middlegroundGroup, foregroundGroup):
self.mainBatch = mainBatch
self.backgroundGroup = backgroundGroup
self.middlegroundGroup = middlegroundGroup
self.foregroundGroup = foregroundGroup
#背景图与方框
self.background = pyglet.sprite.Sprite(img=Resources.background_image,x=0,y=0,batch=mainBatch,group=backgroundGroup)
x1 = GameConfig.basePoint[0]
y1 = GameConfig.basePoint[1]
ww = GameConfig.maxX * GameConfig.defaultImageWidth
hh = GameConfig.maxY * GameConfig.defaultImageHeight
self.rect_vertex_list = mainBatch.add(4, pyglet.gl.GL_LINE_LOOP, middlegroundGroup,
('v2f', (x1,y1,x1+ww,y1,x1+ww,y1+hh,x1,y1+hh)), ('c3B', GameConfig.rectColor*4))
#整体文本信息
self.msg_label = pyglet.text.Label(text="Welcome!",
x=GameConfig.msg1_x, y=GameConfig.msg1_y,
batch=mainBatch, group=middlegroundGroup,
color=GameConfig.textColor, font_size=GameConfig.textSize)
#初始食物
self.bread = GameObject.Bread(GameConfig.firstFood, self.mainBatch, middlegroundGroup)
#障碍物们
self.walls = Walls(mainBatch, middlegroundGroup)
self.walls.newWalls(GameConfig.logicMap)
#蛇
self.snake = Snake(mainBatch,middlegroundGroup)
self.snake.newSnake(GameConfig.startPoint, GameConfig.startDirection)
gameWindow.push_handlers(self.snake)
#飘过的云
self.clouds = Clouds(mainBatch, foregroundGroup)
def update(self, dt):
self.snake.update(dt, self.walls, self.bread)
self.clouds.update(dt)
class GUI:
DEFAULT_REFRESH_TIMER = 30
def __init__(self):
self.fenetre = Tk()
self.fenetre.geometry('480x480')
self.canvas = Canvas(self.fenetre, bg='black', highlightthickness=0)
self.canvas.pack(fill='both', expand=1)
self.timer = GUI.DEFAULT_REFRESH_TIMER
self.snake = Snake(self.canvas, randint(0, 480),
randint(0, 480), random()*2*pi)
self.refresh()
self.canvas.focus_set()
self.canvas.bind('<Key>', self.keyPressed)
def refresh(self):
self.snake.move()
self.current_loop = self.fenetre.after(self.timer, self.refresh)
def keyPressed(self, e):
touche = e.keysym
if touche in ('Right', 'Left'):
self.snake.angle += 0.15 * {'Right': 1, 'Left': -1}[touche]
elif touche == 'q':
self.fenetre.after_cancel(self.current_loop)
def start(self):
self.fenetre.mainloop()
def move():
snakeObj = Snake()
data = bottle.request.json
mapObj.setData(data)
# pprint(data)
# True/False for every spot on the board for visited nodes in BFS
if (len(originalDictionary) < 1):
generateDictionaryTF(mapObj, originalDictionary)
turnDictionary = originalDictionary.copy()
# Remove spots that are completely unavailable
# Makes list for other snakes by looking at all snakes with name != ours
for snake in data['snakes']['data']:
if snake['id'] == data['you']['id']:
ourSnake = snake
snakeObj.ourSnake = ourSnake
snakeObj.headOfOurSnake = ourSnake['body']['data'][0]
snakeObj.ourSnake['health'] = ourSnake['health']
snakeObj.ourSnake['length'] = len(ourSnake['body']['data'])
else:
snakeObj.otherSnakes.append(snake)
# If it's the first few turns we want to not remove the tail from nodes that can be removed from the list
# as the snake extends out in the first 3 turns
coordsToIterateThrough = snake['body']['data'][:-1]
if data['turn'] < 2:
coordsToIterateThrough = snake['body']['data']
# removes all snake bodies/tail (not head) from list of
# possible co-ordinates
for coord in coordsToIterateThrough:
x = coord['x']
y = coord['y']
# removes move directions that are directly onto enemy snakes
if not turnDictionary.get((x, y), None) is None:
del turnDictionary[(x, y)]
# dictionary of all 4 directions
t = (snakeObj.headOfOurSnake['x'], snakeObj.headOfOurSnake['y'])
directionsCanGo = getDirectionsCanGo(t,
turnDictionary)
# dictionary holding all possible directions in form:
# [direction, heuristicValue]
directionHeuristics = {}
removeSnakeCollisions(snakeObj, turnDictionary, directionHeuristics)
# set collision directions == 5 (Danger)
currMove = determineMovePriority(directionsCanGo,
turnDictionary,
mapObj,
directionHeuristics,
snakeObj)
# danger check should happen after food evaluation
# send determined move to server
return {
'move': currMove,
'taunt': "Arrays start at 2. Change my mind"
# 'taunt': tauntGenerator(mapObj)
}
def game(self,screen): # MAIN FUNCTION TO START THE GAME
clock = pygame.time.Clock()
spots = self.make_board()
snake = Snake(self)
spots[0][0] = 1
with self.lock:
self.food.pos = self.find_food(spots)
thread.start_new_thread(self.food.move_food,(snake,)) # THREAD FOR MOVING FOOD PARTICLE
self.Signal=True
while True:
clock.tick(15)
# Event processing
self.done = False
events = pygame.event.get()
for event in events:
if event.type == pygame.QUIT:
print("Quit given")
self.done = True
self.Signal=False
break
if self.done:
return False
snake.populate_nextDir(events, "arrows")
# Game logic
next_head = snake.move() # MOVING SNAKE TO NEXT COORDINATE
next_head=snake.get_head(next_head)
if (self.end_condition(spots, next_head)):
self.Signal=False
return snake.tailmax
if self.is_food(spots, next_head):
snake.tailmax += 4
self.end=pygame.time.get_ticks();
count=snake.tailmax/4-2;
self.food.btimer=float(self.food.btimer*((count+2))/(count+1))+50-float(self.end-self.start)/((count+1)*300);
print self.food.btimer;
self.start=pygame.time.get_ticks();
with self.lock:
self.food.pos = self.find_food(spots)
snake.deque.append(next_head)
if len(snake.deque) > snake.tailmax:
snake.deque.popleft()
# Draw code
screen.fill(self.BLACK) # makes screen black
spots = self.update_board(screen, snake)
pygame.display.update()
def create_snakes(self):
the_Snake = Snake()
the_Snake.initial_parts(initial_length)
the_Snake.initial_pos()
self.add_widget(the_Snake)
self.da_snakes.append(the_Snake)
#Put the following part in a function
self.da_food = SnakeFoo()
self.da_food.size = snake_part_size
self.da_food.position(Window.width, Window.height)
self.add_widget(self.da_food)
def __init__(self): """ Inicialización del juego. """ self.wii = WiiNunchuck() self.snake = Snake(3) self.display = Display() self.direction = self.snake.direction self.food = None
def __init__(self):
self._running = False
self._main_clock = pygame.time.Clock()
self._display_surf = None
self.size = self.width, self.height = 640, 480
self._game = Game()
self._snake = Snake()
self._snake.set_position(100, 100)
class World():
'''
classdocs
'''
def __init__(self):
'''
Constructor
'''
self.snake = Snake()
def move(self):
self.snake.plot()
def plot(self):
self.snake.plot()
def __init__(self):
self.fenetre = Tk()
self.fenetre.geometry('480x480')
self.canvas = Canvas(self.fenetre, bg='black', highlightthickness=0)
self.canvas.pack(fill='both', expand=1)
self.timer = GUI.DEFAULT_REFRESH_TIMER
self.snake = Snake(self.canvas, randint(0, 480),
randint(0, 480), random()*2*pi)
self.refresh()
self.canvas.focus_set()
self.canvas.bind('<Key>', self.keyPressed)
def __init__(self):
print("Game engine")
pygame.init()
self.screen = pygame.display.set_mode((640, 480))
pygame.display.set_caption("Snake challenge")
# Fill background with black
self.background = pygame.Surface(self.screen.get_size())
self.background = self.background.convert()
self.background.fill((0, 0, 0))
self.running = True
self.apple = Apple()
self.snake = Snake()
class Game(_Scene):
"""This scene is active during the gameplay phase."""
def __init__(self):
_Scene.__init__(self, "DEAD")
self.reset()
def reset(self):
"""Prepare for next run."""
_Scene.reset(self)
self.snake = Snake()
self.walls = self.make_walls()
self.apple = Apple(self.walls, self.snake)
def make_walls(self):
"""Make the borders, and load a random level."""
walls = set()
for i in range(-1, BOARD_SIZE[0]+1):
walls.add((i, -1))
walls.add((i, BOARD_SIZE[1]))
for j in range(-1, BOARD_SIZE[1]+1):
walls.add((-1, j))
walls.add((BOARD_SIZE[0], j))
walls |= random.choice(LEVELS)
return walls
def get_event(self, event):
"""Pass any key presses on to the snake."""
if event.type == pg.KEYDOWN:
self.snake.get_key_press(event.key)
def update(self, now):
"""Update the snake and check if it has died."""
_Scene.update(self, now)
self.snake.update(now)
self.snake.check_collisions(self.apple, self.walls)
if self.snake.dead:
self.done = True
def draw(self, surface):
"""Draw the food, snake, and walls."""
surface.fill(COLORS["background"])
draw_cell(surface, self.apple.position,
self.apple.color, PLAY_RECT.topleft)
for wall in self.walls:
draw_cell(surface, wall, COLORS["walls"], PLAY_RECT.topleft)
self.snake.draw(surface, offset=PLAY_RECT.topleft)
class GameEngine:
def __init__(self):
print("Game engine")
pygame.init()
self.screen = pygame.display.set_mode((640, 480))
pygame.display.set_caption("Snake challenge")
# Fill background with black
self.background = pygame.Surface(self.screen.get_size())
self.background = self.background.convert()
self.background.fill((0, 0, 0))
self.running = True
self.apple = Apple()
self.snake = Snake()
# Starting point of the game
def start(self):
clock = pygame.time.Clock()
# Simplefied Game loop
while self.running:
clock.tick(50)
self.handle_events()
self.update()
self.render()
# Call rendering for all game objects
def render(self):
# Clear the screen
self.screen.blit(self.background, (0, 0))
# Render objects
self.apple.render()
self.snake.render()
# Update screen
pygame.display.flip()
# Call updates on all game objects
def update(self):
self.apple.update()
self.snake.update(self.apple)
# Handle events such as key presses or exits
def handle_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.running = False
else:
self.snake.handle_event(event)
def __init__(self, height, width, speed, placeObstacles=False): # Integer height of the plane self.height = height # Integer width of the plane self.width = width # Integer delay between frames of the of the game self.speed = speed # Integer score that is the length of the snake self.score = 0 # The snake, starting on the left side of the plane self.snake = Snake(Square(height // 2, width // 2, self.width)) # Boolean indicating whether to place obstacles or not self.placeObstacles = placeObstacles # Set of squares representing obstacles self.obstacles = set() # Square representing the food self.food = None
def gameLoop():
global dirn, k, highscore, namehighscore
pyExit = False
pyOver = False
#stop intro music and play in game music infinite loop
intro_sound.stop()
game_sound.play(-1)
score = 0
world_num = 0
scorestr = "Score:0"
# Initialize the game
snake = Snake(200, 200, img)
food = Food(int(width / 2), int(height / 2))
blocks = worlds(width - 200, height, world_num)
# Keeps track of the direction of the snake.
dx, dy = 0, 0
lossreason = ''
while not pyExit:
if pyOver == True:
#play end music
endgame_sound.play(-1)
while pyOver:
image = pygame.image.load(python_path)
game_display.blit(image, (0, 0))
message("Game Over! Press C to play Again, Q to Quit",
(255, 0, 0), -20)
message(lossreason, (255, 0, 0), 30)
# display score on game over
message("Your" + scorestr, (255, 0, 0), 80)
if totalscore > highscore:
# message("Highscore!!!",(255,0,0),120)
# write new highscore
highscorefile = open('highscore.txt', 'wt')
highscorefile.write(str(totalscore) + "\n")
# name window
def namewrite():
highscorefile.write(v.get())
scorewindow.destroy()
scorewindow = Tk()
scorewindow.geometry('300x100')
frame = Frame(scorewindow, width=100, height=100)
frame.pack()
scorewindow.title("congratulations")
Label(frame, text='you\'ve made highscore!!!!').pack(side='top')
v = StringVar()
v.set("type your name")
textbox = Entry(frame, textvariable=v)
textbox.pack(side='top')
okbutton = Button(frame, text="ok", fg="black",
bg="white", command=namewrite)
okbutton.pack(side='bottom')
scorewindow.mainloop()
highscorefile.close()
# incase user wants to countinue after creating highscore
# to read his new score
highscorefile = open('highscore.txt', 'rt')
highscore = highscorefile.readline()
highscore = int(highscore)
namehighscore = highscorefile.readline()
highscorefile.close()
else:
message("Highscore by " + namehighscore +
":" + str(highscore), (255, 0, 0), 120)
pygame.display.update()
for event in pygame.event.get():
keyp = action()
if keyp != None or event.type == pygame.KEYDOWN:
try:
if keyp == 'q' or event.key == pygame.K_q:
pyExit = True
pyOver = False
except:
blank = [] # bypass the exception
try:
if keyp == 'c' or event.key == pygame.K_c:
#stop endgame music
endgame_sound.stop()
gameLoop()
except:
blank = [] # bypass the exception
""" Events """
#the conditions are modified to work with the buttons
for event in pygame.event.get():
keyp = action()
# blank is not used anywhere
# it is just used to jump the exception
if event.type == pygame.QUIT:
pyExit = True
if event.type == pygame.KEYDOWN or keyp != None:
try:
if keyp == 'lt' or event.key == pygame.K_LEFT and dirn != "right":
dirn = "left"
dx = -1
dy = 0
except:
blank = []
try:
if keyp == 'rt' or event.key == pygame.K_RIGHT and dirn != "left":
dirn = "right"
dx = 1
dy = 0
except:
blank = []
try:
if keyp == 'up' or event.key == pygame.K_UP and dirn != "down":
dirn = "up"
dy = -1
dx = 0
except:
blank = []
try:
if keyp == 'dn' or event.key == pygame.K_DOWN and dirn != "up":
dirn = "down"
dy = 1
dx = 0
except:
blank = []
try:
if keyp == 'p' or event.key == pygame.K_p:
pause(scorestr)
except:
blank = []
try:
if keyp == 'q' or event.key == pygame.K_q:
pygame.quit()
quit(0)
except:
blank = []
# level changer value
if score > 10:
score = 0
world_num += 1
blocks = worlds(width - 200, height, world_num)
food.x, food.y = int(width / 2), int(height / 2)
# Engage boost of pressing shift
keyp=action()
keyPresses = pygame.key.get_pressed()
boost_speed = keyPresses[pygame.K_LSHIFT] or keyPresses[pygame.K_RSHIFT] or keyp=='st'
# if boost_speed is true it will move 2 blocks in one gameloop
# else it will just move one block
iterations = [1]
if boost_speed == 1:
iterations.append(2)
for i in iterations:
""" Update snake """
snake.move(dx, dy, 10)
snake.check_boundary(width, height)
snake_rect = snake.get_rect()
food_rect = food.get_rect()
""" Snake-Snake collision """
if snake.ate_itself():
#stop game sound
game_sound.stop()
pyOver = True
lossreason = 'Oooops You Hit YOURSELF'
""" Snake-Block collision """
for block in blocks:
block_rect = block.get_rect()
if block_rect.colliderect(snake_rect):
#stop game sound
game_sound.stop()
pyOver = True
lossreason = 'Ooops You Hit a BLOCKER'
""" Snake-Food collision """
# if snake collides with food, increase its length.
if food_rect.colliderect(snake_rect):
score += 1
snake.increment_length()
sound = pygame.mixer.Sound(point_path)
sound.set_volume(0.3)
sound.play()
# generate food at random x, y.
food.generate_food(width, height)
# try generating the food at a position where blocks are not present.
while food_collides_block(food.get_rect(), blocks):
food.generate_food(width - food.size, height - food.size)
""" Draw """
game_display.fill((255, 255, 255))
showButton()
# draw the food and snake.
snake.draw(game_display, dirn, (0, 155, 0))
food.draw(game_display, (0, 255, 0))
# draw the blocks.
for block in blocks:
block.draw(game_display, (255, 0, 0))
# count and display score on screen
totalscore = total(score, world_num)
scorestr = 'Score: ' + str(totalscore)
font = pygame.font.SysFont(None, 30)
text = font.render(scorestr, True, (0, 0, 255))
game_display.blit(text, (0, 0, 20, 20))
pygame.display.update()
clock.tick(FPS)
pygame.quit()
quit()
import pygame, time, sys, random
pygame.init()
from GameWindow import GameWindow
from Snake import Snake
from Collectible import Collectible
if __name__ == "__main__":
window = GameWindow(800, 600)
snake = Snake()
collectibles = []
clock = pygame.time.Clock()
running = True
while running:
window.window.fill(GameWindow.white)
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
#generate new collectibles
if not collectibles:
collectibles.append(Collectible())
if random.randint(
0, 120
) == 1: #should generate 1 new collectible every 2 seconds???
collectibles.append(Collectible())
#handles keypresses and moves the snake
pressed = pygame.key.get_pressed()
if pressed[pygame.K_LEFT] and snake.direction != 'east':
from Border import Border from Ball import Ball from move import Move from Tail import Tail from sketch import Sketch delay = 0.001 start_tail = 1 score = 0 # Set up the screen screen = turtle.Screen() screen.setup(width=1000, height=600) # SNAKE PART # Snake head snake = Snake() snakehead = snake.snakehead() # long border bor = Border() border = bor.setUpBorder() # Snake tail segments = [] # Paddle # You can move the paddle with 'z' and 's' pad = Paddle() paddle = pad.paddle() # Ball of circle shape Ball = Ball() # Global part #Sets key bindings to the right thing.
DIRECTION = RIGHT # Always start the game with a moving right snake
FRUIT_COLOR = (0, 255, 0)
LEVEL_UP = 5 # Must eat 4 (5 - 1 = 4) fruits to go to the next level
# Setting up the GUI
pygame.display.set_caption("Classic Snake 2D")
screen = pygame.display.set_mode(SCREEN_SIZE, 0, 32)
icon = pygame.image.load("icon.png")
pygame.display.set_icon(icon)
large_font = pygame.font.Font("font.ttf", 35)
small_font = pygame.font.Font("font.ttf", 18)
screen.fill(BACKGROUND_COLOR)
# The snake of the game
snake = Snake(SCREEN_SIZE[0], SCREEN_SIZE[1], Snake.MIN_LENGTH)
# The fruit
fruit = None
# The boolean flag to tell the reason why the snake is dead
eat_self = False
eat_gate = False
# Open/close the gate flag
gate_open = False
# The gate
gate = None
# Stop the game
is_running = True
def newRound(self):
self.time = 0
self.numSnake = 0
self.snake = Snake()
class Program(object): """ TODO: Mejorar el tiempo de refresco de pantalla """ # Condición que un hilo debe revisar para terminar su ejecución keep_playing = True def __init__(self): """ Inicialización del juego. """ self.wii = WiiNunchuck() self.snake = Snake(3) self.display = Display() self.direction = self.snake.direction self.food = None def read_control(self): """ Mientras el juego siga activo, lee el control de Wii y mueve la serpiente o termina el juego. """ while (self.keep_playing): self.wii.read_data() self.change_direction() if self.wii.data.button_c is True: print "Boton C" self.game_over(None) sleep(0.01) def change_direction(self): """ Interpreta la dirección del joystick para cambiar la dirección en la que avanza la serpiente. """ if self.wii.data.joystick_y < 70: #Down arrow self.direction = "DOWN" elif self.wii.data.joystick_y > 180: #Up arrow self.direction = "UP" if self.wii.data.joystick_x < 70: #Up arrow self.direction = "LEFT" elif self.wii.data.joystick_x > 180: #Up arrow self.direction = "RIGHT" def update_snake(self): """ Mientras el juego siga activo, actualiza la posición de la serpiente moviéndola hacia adelante cada 0.2 seg y verifica colisiones.""" while(self.keep_playing): self.snake.move(self.direction) self.check_collisions() sleep(0.2) def check_collisions(self): """ Revisar si la cabeza de la serpiente colisionó con el resto del cuerpo o con comida """ for p in self.snake.body[2:]: if ( self.snake.body[0].x == p.x and self.snake.body[0].y == p.y ): self.game_over(-1) if self.food is not None: if ( self.snake.body[0].x == self.food.place.x and self.snake.body[0].y == self.food.place.y ): self.snake.eat() self.food = None def make_food(self): """ Mientras el juego siga activo, actualiza la posición del objeto de comida cada 3 seg. """ while(self.keep_playing): self.food = Food() sleep(3) def update_screen(self): """ Mientras el juego siga activo, refresca la pantalla con la posición de la serpiente y de la comida """ while(self.keep_playing): array_points = list(self.snake.body) if self.food is not None: array_points.append(self.food.place) self.display.show(array_points) def game_over(self, end_code): """ Controla cómo terminará el juego. Al perder, espera 3 seg y luego saldrá. Args: end_code: Un número entero negativo usado para saber por qué terminó el juego. """ if end_code is -1: print "You lost." print "End of game!" self.keep_playing = False sleep(3)
from Snake import Snake
from Food import Food
from Scoreboard import Score
# Storage for Variables and Lists
game_over = False
# Screen setup
screen = Screen()
screen.setup(width=600, height=600)
screen.bgcolor("black")
screen.title("Snake")
screen.tracer(0) # 0 = off
# Creating the snake and food using the Class imported above
snake = Snake()
food = Food()
Score = Score()
# Key's for movement
screen.listen()
screen.onkey(key="w", fun=snake.Up)
screen.onkey(key="s", fun=snake.Down)
screen.onkey(key="a", fun=snake.Left)
screen.onkey(key="d", fun=snake.Right)
while 1:
screen.update()
time.sleep(0.1)
snake.move()
def gameLoop():
global dirn, k, highscore, namehighscore
pyExit = False
pyOver = False
#stop intro music and play in game music infinite loop
intro_sound.stop()
game_sound.play(-1)
score = 0
world_num = 0
scorestr = "Score:0"
# Initialize the game
snake = Snake(200, 200, img)
food = Food(int(width / 2), int(height / 2))
blocks = worlds(width - 200, height, world_num)
# Keeps track of the direction of the snake.
dx, dy = 0, 0
lossreason = ''
while not pyExit:
if pyOver == True:
#play end music
endgame_sound.play(-1)
while pyOver:
image = pygame.image.load(python_path)
game_display.blit(image, (0, 0))
message("Game Over! Press C to play Again, Q to Quit", (255, 0, 0),
-20)
message(lossreason, (255, 0, 0), 30)
# display score on game over
message("Your" + scorestr, (255, 0, 0), 80)
if totalscore > highscore:
# message("Highscore!!!",(255,0,0),120)
# write new highscore
highscorefile = open('highscore.txt', 'wt')
highscorefile.write(str(totalscore) + "\n")
# name window
def namewrite():
highscorefile.write(v.get())
scorewindow.destroy()
scorewindow = Tk()
scorewindow.geometry('300x100')
frame = Frame(scorewindow, width=100, height=100)
frame.pack()
scorewindow.title("congratulations")
Label(frame,
text='you\'ve made highscore!!!!').pack(side='top')
v = StringVar()
v.set("type your name")
textbox = Entry(frame, textvariable=v)
textbox.pack(side='top')
okbutton = Button(frame,
text="ok",
fg="black",
bg="white",
command=namewrite)
okbutton.pack(side='bottom')
scorewindow.mainloop()
highscorefile.close()
# incase user wants to countinue after creating highscore
# to read his new score
highscorefile = open('highscore.txt', 'rt')
highscore = highscorefile.readline()
highscore = int(highscore)
namehighscore = highscorefile.readline()
highscorefile.close()
else:
message("Highscore by " + namehighscore + ":" + str(highscore),
(255, 0, 0), 120)
pygame.display.update()
for event in pygame.event.get():
keyp = action()
if keyp != None or event.type == pygame.KEYDOWN:
try:
if keyp == 'q' or event.key == pygame.K_q:
pyExit = True
pyOver = False
except:
blank = [] # bypass the exception
try:
if keyp == 'c' or event.key == pygame.K_c:
#stop endgame music
endgame_sound.stop()
gameLoop()
except:
blank = [] # bypass the exception
""" Events """
#the conditions are modified to work with the buttons
for event in pygame.event.get():
keyp = action()
# blank is not used anywhere
# it is just used to jump the exception
if event.type == pygame.QUIT:
pyExit = True
if event.type == pygame.KEYDOWN or keyp != None:
try:
if keyp == 'lt' or event.key == pygame.K_LEFT and dirn != "right":
dirn = "left"
dx = -1
dy = 0
except:
blank = []
try:
if keyp == 'rt' or event.key == pygame.K_RIGHT and dirn != "left":
dirn = "right"
dx = 1
dy = 0
except:
blank = []
try:
if keyp == 'up' or event.key == pygame.K_UP and dirn != "down":
dirn = "up"
dy = -1
dx = 0
except:
blank = []
try:
if keyp == 'dn' or event.key == pygame.K_DOWN and dirn != "up":
dirn = "down"
dy = 1
dx = 0
except:
blank = []
try:
if keyp == 'p' or event.key == pygame.K_p:
pause(scorestr)
except:
blank = []
try:
if keyp == 'q' or event.key == pygame.K_q:
pygame.quit()
quit(0)
except:
blank = []
# level changer value
if score > 10:
score = 0
world_num += 1
blocks = worlds(width - 200, height, world_num)
food.x, food.y = int(width / 2), int(height / 2)
# Engage boost of pressing shift
keyp = action()
keyPresses = pygame.key.get_pressed()
boost_speed = keyPresses[pygame.K_LSHIFT] or keyPresses[
pygame.K_RSHIFT] or keyp == 'st'
# if boost_speed is true it will move 2 blocks in one gameloop
# else it will just move one block
iterations = [1]
if boost_speed == 1:
iterations.append(2)
for i in iterations:
""" Update snake """
snake.move(dx, dy, 10)
snake.check_boundary(width, height)
snake_rect = snake.get_rect()
food_rect = food.get_rect()
""" Snake-Snake collision """
if snake.ate_itself():
#stop game sound
game_sound.stop()
pyOver = True
lossreason = 'Oooops You Hit YOURSELF'
""" Snake-Block collision """
for block in blocks:
block_rect = block.get_rect()
if block_rect.colliderect(snake_rect):
#stop game sound
game_sound.stop()
pyOver = True
lossreason = 'Ooops You Hit a BLOCKER'
""" Snake-Food collision """
# if snake collides with food, increase its length.
if food_rect.colliderect(snake_rect):
score += 1
snake.increment_length()
sound = pygame.mixer.Sound(point_path)
sound.set_volume(0.3)
sound.play()
# generate food at random x, y.
food.generate_food(width, height)
# try generating the food at a position where blocks are not present.
while food_collides_block(food.get_rect(), blocks):
food.generate_food(width - food.size, height - food.size)
""" Draw """
game_display.fill((255, 255, 255))
showButton()
# draw the food and snake.
snake.draw(game_display, dirn, (0, 155, 0))
food.draw(game_display, (0, 255, 0))
# draw the blocks.
for block in blocks:
block.draw(game_display, (255, 0, 0))
# count and display score on screen
totalscore = total(score, world_num)
scorestr = 'Score: ' + str(totalscore)
font = pygame.font.SysFont(None, 30)
text = font.render(scorestr, True, (0, 0, 255))
game_display.blit(text, (0, 0, 20, 20))
pygame.display.update()
clock.tick(FPS)
pygame.quit()
quit()
class BoardManager():
def __init__(self, nw_tile, nh_tile):
self.nw_tile = nw_tile # Set number of tile in x
self.nh_tile = nh_tile # Set number of tile in y
self.number_body = 3 # Set number of snake's body
self.score = 0 # Set score of sanke
self.db_save_size = 6 # Column size of data base
self.id = 0 # index of database's column
self.type = 1
self.x = 2
self.y = 3
self.s = 4
self.t = 5
self.enemy_dict = {} # Enemy snake dictionary
self.client_state_dict = {
'OK': 0,
'notNStart': 1,
'notNExit': 2
} # KList state of client
self.client_state = self.client_state_dict[
'notNStart'] # State of cleint
self.play_state = False # Playing state
self.game_time = 0 # time of game
self.tile_mng = TileManager(width, height, self.nw_tile,
self.nh_tile) # Set TileManager
self.snake = Snake(1, 1, self.tile_mng, green, SNAKE,
raw_input("Enter : "),
self.number_body) # Set my sanke
self.apple = Apple(0, 0, self.tile_mng, red, 0) # Set apple
self.hud = HUD() # Set HUD
# Update board
def update(self):
for event in pygame.event.get(): # Check all event
if event.type == pygame.QUIT: # Click Quit to quit program
pygame.quit() # quit programe
quit()
if event.type == pygame.KEYDOWN: # If pressed keyboard
if event.key == pygame.K_LEFT and not self.snake.get_move_list(
'right'): # Pressed left and not go right
self.snake.set_left() # Go left
elif event.key == pygame.K_RIGHT and not self.snake.get_move_list(
'left'): # Pressed right and not go left
self.snake.set_right() # Go right
elif event.key == pygame.K_UP and not self.snake.get_move_list(
'down'): # Pressed up and not go down
self.snake.set_up() # Go up
elif event.key == pygame.K_DOWN and not self.snake.get_move_list(
'up'): # Pressed down and not go up
self.snake.set_down() # Go down
elif event.key == pygame.K_x: # Press x
self.snake.snake_slide(self.snake.get_move(),
self.apple) # Use slide snake skill
elif event.key == pygame.K_c: # Press c
self.snake.snake_running() # Use running snake skill
x_pos_ls = [
int(self.snake.get_x_pos()[i] / self.tile_mng.get_sizew_tile())
for i in range(self.snake.get_number_body())
] # set x's list
y_pos_ls = [
int(self.snake.get_y_pos()[i] / self.tile_mng.get_sizeh_tile())
for i in range(self.snake.get_number_body())
] # set y's list
x_pos_n = self.client.pos_pattern(
x_pos_ls) # save in string in postion pattern (x, y)
y_pos_n = self.client.pos_pattern(y_pos_ls)
pattern = self.client.set_pattern(self.snake.get_id(), [
self.snake.get_type(), x_pos_n, y_pos_n,
self.snake.get_score(), 0
]) # set pattern of all data
# id,type,xs,ys,score,time
if self.client_state == self.client_state_dict[
'OK']: # Client state is "OK"
self.snake.snake_eat_apple(
self.apple) # Check does snake eat apple ?
self.snake.update() # Update snake
if self.apple.get_eaten(): # Apple is eaten by snake
pattern = "eaten" # pattern is "eaten"
self.apple.set_eaten(False) # Apple is not eaten
self.client.send(pattern) # Send pattern to client
data, addr = self.client.recv() # Receive data from server
if data == None: # Data is none => exit method
return
if data == "notNStart": # data is notNStart => set client state
self.client_state = self.client_state_dict['notNStart']
elif data == "notNExit": # data is notNExit => set client state
self.client_state = self.client_state_dict['notNExit']
else: # otherwise
self.client_state = self.client_state_dict[
'OK'] # Set client state to "OK"
split_list = self.client.split(data) # Split data
for ls in split_list:
self.game_time = int(ls[self.t]) # set time
if ls[self.id] == "*": # See id of apple
self.apple = Apple(int(ls[self.x]), int(ls[self.y]),
self.tile_mng, red, str(ls[self.type]))
elif ls[self.id] != self.snake.get_id() and ls[
self.id] != "*": # See enemy snake's id
self.enemy_dict[ls[self.id]] = Snake(
0, 0, self.tile_mng, blue, ls[self.type], ls[self.id],
0) # Save in dictionary of enemy snake
x_pos = self.client.pos_split(ls[self.x])
y_pos = self.client.pos_split(ls[self.y])
x_list = [
int(x_pos[i] * self.tile_mng.get_sizew_tile())
for i in range(len(x_pos))
]
y_list = [
int(y_pos[i] * self.tile_mng.get_sizeh_tile())
for i in range(len(y_pos))
]
self.enemy_dict[ls[self.id]].set_pos(
x_list, y_list) # Set postion enemy snake
# Render board
def render(self): # Render board
game_display.fill(white) # Background
if self.client_state == self.client_state_dict[
'OK']: # Client state is OK
if self.snake.state == 'dead': # If dead
# Draw dead HUD
self.hud.dead_hud(game_display, self.snake.get_dead_ellapse(),
self.snake.get_dead_delay(), width / 2,
height / 2, width / 3, height / 3)
else:
self.apple.render(game_display) # Render Apple
self.snake.render(game_display,
self.snake.get_number_body() -
1) # render snake
for key in self.enemy_dict: # Render enemy snake
self.enemy_dict[key].render(
game_display,
self.enemy_dict[key].get_number_body() - 1)
# Draw time's hud, score' hud, gauge's hud
self.hud.time_hud(game_display, self.game_time, width / 2,
height * 0.05)
self.hud.score_hud(game_display, self.snake.get_score(),
width * 0.8, height * 0.05)
self.hud.gauge_hud(
game_display,
min(
self.snake.get_slide_ellapse() /
self.snake.get_slide_delay(), 1), 0.6 * width,
0.95 * height, 0.4 * width, 0.02 * height)
self.hud.gauge_hud(
game_display,
min(
self.snake.get_run_use_ellapse() /
self.snake.get_run_use_delay(), 1), 0.6 * width,
0.97 * height, 0.4 * width, 0.02 * height)
pygame.display.update() # Update display
def loop(self): # Loop to play always
self.ip = raw_input("IP : ") # Get IP
self.client = ClientManager(self.ip, 8000) # Set client
packet = str(
"tile:" + str(width) + "," + str(height) + "," +
str(self.nw_tile) + "," + str(self.nh_tile)
) # Set pattern : width, height program and number of tile program
self.client.send(packet) # Send data to server
self.client.close() # Disconnnet socket
while True:
try:
self.client = ClientManager(self.ip, 8000) # Set client
self.update() # Update program
self.render() # Render program
self.client.close() # Disconnect from socket
except KeyboardInterrupt:
pygame.quit() # Quit program
quit()
pygame.quit() # Quit program
quit()
class Game(object):
board = Board()
snake = Snake()
food = Food()
direction_flag = 'R'
def __init__(self):
pass
# self.new_food()
# self.board.clear()
# self.board.put_snake(self.snake.getPoints())
# self.board.put_food(self.food)
def run(self):
while True:
frame_rate = pygame.time.Clock().tick(20)
self.board = Board()
# 检测例如按键等pygame事件
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_RIGHT:
self.direction_flag = 'R'
elif event.key == pygame.K_LEFT:
self.direction_flag = 'L'
elif event.key == pygame.K_UP:
self.direction_flag = 'U'
elif event.key == pygame.K_DOWN:
self.direction_flag = 'D'
food_position = copy.deepcopy(self.food.food_list())
# food_position[0] += 20
# food_position[1] += 20
food_image = Utils.load_image('food.png').convert()
self.board.screen.blit(food_image, (food_position[0], food_position[1]))
snake_position = self.snake.pos_list
for pos in snake_position:
snake_head = Utils.load_image('snake_head.png').convert()
self.board.screen.blit(snake_head, (pos[0], pos[1]))
if len(snake_position) > 1:
snake_image = Utils.load_image('snake_head.png').convert()
self.board.screen.blit(snake_image, (pos[0], pos[1]))
# pygame.draw.rect(self.self.board.screen, (255, 0, 0), temp_rect)
pygame.display.update()
snake_head = snake_position[0]
if self.direction_flag == 'R':
if snake_head[0] < 560:
self.snake.change_direction(self.direction_flag)
self.snake.move_direction()
else:
self.direction_flag = 'D'
elif self.direction_flag == 'D':
if snake_head[1] < 400:
self.snake.change_direction(self.direction_flag)
self.snake.move_direction()
else:
self.direction_flag = 'L'
elif self.direction_flag == 'L':
if snake_head[0] > 20:
self.snake.change_direction(self.direction_flag)
self.snake.move_direction()
else:
self.direction_flag = 'U'
elif self.direction_flag == 'U':
if snake_head[1] > 20:
self.snake.change_direction(self.direction_flag)
self.snake.move_direction()
else:
self.direction_flag = 'R'
if snake_head == food_position:
self.snake.eat_food(food_position)
self.food.update_food()
class MyGame(arcade.Window):
# define the initials
def __init__(self, width, height, title):
super().__init__(width, height, title, update_rate=10)
# add snake
self.snake = Snake()
self.direction = UP
self.grid = []
self.defeat = False
self.state = 0 # 1 instruction 0 menu 2 game 3 defeat
# add apple
self.apple = Apple()
self.apple.produce(self.snake)
for row in range(ROW_COUNT):
# Add an empty array that will hold each cell
# in this row
self.grid.append([])
for column in range(COLUMN_COUNT):
self.grid[row].append(0) # Append a cell
self.add_snake_to_grid()
def add_snake_to_grid(self):
# add a cell for each block
for i in range(ROW_COUNT):
for j in range(COLUMN_COUNT):
self.grid[i][j] = 0
for i in range(1, self.snake.length):
row = self.snake.body[i][0]
col = self.snake.body[i][1]
self.grid[row][col] = SNAKE
# give a value to a block represent different types of apple
if self.apple.score == 1:
apple_x = self.apple.x
apple_y = self.apple.y
self.grid[apple_x][apple_y] = APPLE
elif self.apple.score == 5:
apple_x = self.apple.x
apple_y = self.apple.y
self.grid[apple_x][apple_y] = APPLE5
# define the first snake body is snake head
head = self.snake.body[0]
self.grid[head[0]][head[1]] = S_HEAD
def draw_menu(self):
# button_i for instruction, button_s for start
xi, yi, wi, hi = button_i
xs, ys, ws, hs = button_s
arcade.start_render()
arcade.set_background_color(arcade.color.VANILLA)
# display buttons and texts
arcade.draw_text("Snakes",
width / 4 + 40,
height / 4 * 3,
arcade.color.BLACK,
font_size=50)
arcade.draw_xywh_rectangle_filled(xi, yi, wi, hi,
arcade.color.WHITE_SMOKE)
arcade.draw_xywh_rectangle_filled(xs, ys, ws, hs,
arcade.color.WHITE_SMOKE)
arcade.draw_text("* Instructions",
width / 4 + 30,
height / 2 - 80,
arcade.color.BLACK,
font_size=35)
arcade.draw_text(
"* Start",
width / 4 + 30,
height / 2 + 50,
arcade.color.BLACK,
font_size=35,
)
def on_mouse_press(self, x, y, button, modifiers):
# if click the buttons, change the state
if self.state == 0:
i_x, i_y, i_w, i_h = button_i
s_x, s_y, s_w, s_h = button_s
if x > i_x and x < i_x + i_w and y > i_y and y < i_y + i_h:
self.state = 1
self.snake.body = []
self.draw_game()
elif x > s_x and x < s_x + s_w and y > s_y and y < s_y + s_h:
self.state = 2
elif self.state == 1:
b_x, b_y, b_w, b_h = button_b
if x > b_x and x < b_x + b_w and y > b_y and y < b_y + b_h:
# start a new game
self.setup()
elif self.state == 3:
b2_x, b2_y, b2_w, b2_h = button_b2
if x > b2_x and x < b2_x + b2_w and y > b2_y and y < b2_y + b2_h:
# start a new game
self.setup()
# setup function reset all values to origin
def setup(self):
self.state = 0
self.snake.body = []
self.snake.direction = UP
self.snake.length = 0
self.snake.tail = []
self.snake.add_body(4, 4)
self.snake.score = 0
self.snake.add_body(3, 4)
self.snake.add_body(2, 4)
self.angle = (self.direction - 10) * 90
self.direction = UP
def draw_instruction(self):
# draw instruction interface
arcade.draw_rectangle_filled(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2,
SCREEN_WIDTH, SCREEN_HEIGHT,
arcade.color.ROSE_GOLD)
arcade.draw_text("Instructions",
width / 2 - 95,
600,
arcade.color.BLUE_GRAY,
font_size=35)
arcade.draw_text("""
- The player as a snake in this game,
the player can use the keyboard
(up, down, right, left) to control the snake.
- The goal for the player is to eat as
many apples as they can.
- Only one apple is available for the player
at each time.
- There will be random golden apple available
for the player to eat,
they can get five bonus if they successfully eat it,
the golden apple will disappear if the player
didn't eat it for a while.
- The head of the snake cannot touch its body,
or any places out to the grid.
If they do so, they will lose.
- Do not choose the direction which opposite with
the direction that the snake is moving on.
""",
5,
height / 4,
arcade.color.BLACK,
font_size=18)
xb, yb, wb, hb = button_b
arcade.draw_xywh_rectangle_filled(xb, yb, wb, hb,
arcade.color.WHITE_SMOKE)
arcade.draw_text("* Back",
xb,
yb,
arcade.color.ROSE_GOLD,
font_size=20)
def draw_defeat(self):
# draw defeat interface
arcade.draw_rectangle_filled(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2,
SCREEN_WIDTH, SCREEN_HEIGHT,
arcade.color.RED)
arcade.draw_text("YOU LOSE",
SCREEN_WIDTH / 2 - 70,
SCREEN_HEIGHT / 2,
arcade.color.WHITE_SMOKE,
font_size=35)
# display your scores
arcade.draw_text(f"Score: {str(self.snake.score)}",
SCREEN_WIDTH / 2 - 50,
SCREEN_HEIGHT / 2 - 50,
arcade.color.BLACK,
font_size=35)
xb2, yb2, wb2, hb2 = button_b2
arcade.draw_xywh_rectangle_filled(xb2, yb2, wb2, hb2,
arcade.color.WHITE_SMOKE)
arcade.draw_text("* Back",
xb2,
yb2,
arcade.color.ROSE_GOLD,
font_size=20)
def draw_game(self):
"""
Render the screen.
"""
# This command has to happen before we start drawing
arcade.start_render()
# Draw the grid
if self.defeat:
arcade.set_background_color(arcade.color.ALLOY_ORANGE)
arcade.draw_text("LOSE", 50, 50, arcade.color.BLACK)
for row in range(ROW_COUNT):
for column in range(COLUMN_COUNT):
# Figure out what color to draw the box
if self.grid[row][column] != SNAKE:
color = arcade.color.ARYLIDE_YELLOW
# Do the math to figure out where the box is
x = (MARGIN + WIDTH) * column + MARGIN + WIDTH // 2
y = (MARGIN + HEIGHT) * row + MARGIN + HEIGHT // 2
# Draw the box
arcade.draw_rectangle_filled(x, y, WIDTH, HEIGHT, color)
# Draw sprite
if self.grid[row][column] == S_HEAD:
angle = (self.direction - 10) * 90
snake_head.draw(x, y, WIDTH, HEIGHT, angle=angle)
elif self.grid[row][column] == APPLE:
red_apple.draw(x, y, WIDTH, HEIGHT)
elif self.grid[row][column] == APPLE5:
golden_apple.draw(x, y, WIDTH, HEIGHT)
elif self.grid[row][column] == SNAKE:
snake_body.draw(x, y, WIDTH, HEIGHT)
def on_draw(self):
# draw different interfaces
if self.state == 0:
self.draw_menu()
elif self.state == 2:
self.draw_game()
elif self.state == 1:
self.draw_instruction()
elif self.state == 3:
self.draw_defeat()
def update(self, delta_time: float):
# update all functions
if self.state != 2:
return
if self.snake.update(self.direction):
self.state = 3
self.snake.eat_apple(self.apple)
self.add_snake_to_grid()
def on_key_press(self, key: int, modifiers: int):
# use keyboard to control directions
if key == arcade.key.UP:
self.direction = UP
elif key == arcade.key.DOWN:
self.direction = DOWN
elif key == arcade.key.LEFT:
self.direction = LEFT
elif key == arcade.key.RIGHT:
self.direction = RIGHT
def main():
start_timer = 0
invincibility_time = 2
view_width = 1000
view_height = 600
# Calculate game view rectangle starting position
start_x = (width - view_width) / 2
start_y = (height - view_height) / 2
spawn_area_scale = (start_x, start_y, view_width, view_height)
# COLOURS
lives_display_col = (0, 0, 0)
score = 0
live_taken = False
# Construct a snake
snake = Snake(1023, 350, 3, 3, 15, (0, 0, 0))
# Apple scale
app_width = 10
app_height = 10
# Randomise apple position
rand_x, rand_y = gen_random_spawn_location(app_width, app_height,
spawn_area_scale)
# Game loop
while run:
curr_time = time.time()
# Draw background, needs to happen every frame
window.fill((255, 255, 255))
spawn_area = pygame.draw.rect(window, (98, 244, 66), spawn_area_scale)
# (Simply Visual) Spawn Area Border
pygame.draw.rect(window, (3, 132, 36), spawn_area_scale, 4)
# Draw apple
apple = pygame.draw.rect(window, (255, 0, 0),
(rand_x, rand_y, app_width, app_height))
# Player controls and other events
get_key_entered(snake)
if snake.lives > 0:
if not live_taken:
snake.draw_snake(window)
snake.update_position()
# If the apple was eaten
if snake.eat(apple):
# Spawn a new apple
rand_x, rand_y = gen_random_spawn_location(
app_width, app_height, spawn_area_scale)
# Update score
score += 5
print("Snake length: ", snake.segments.length)
snake_x = snake.segments.head.rect.x
snake_y = snake.segments.head.rect.y
# The top left and top right corners of the snake head.
# Those exact points create the exact boundary needed and at the same time save computation.
s_tl = (snake_x, snake_y)
s_tr = (snake_x + snake.segment_size, snake_y + snake.segment_size)
not_collide_top_left = not spawn_area.collidepoint(s_tl)
not_collide_top_right = not spawn_area.collidepoint(s_tr)
if not_collide_top_left and not_collide_top_right and not live_taken:
start_timer = curr_time
snake.lives -= 1
live_taken = True
# RESPAWN
temp_lives = snake.lives
del snake
snake = Snake(1023, 350, 3, 3, 15, (0, 0, 0))
snake.lives = temp_lives
# Set all segments in the snake to start at the head position
for counter in range(0, snake.segments.length):
snake.segments.get_at_pos(counter).rect.x = 1023
snake.segments.get_at_pos(counter).rect.y = 350
# Can loose a life again
if round(curr_time - start_timer, 0) == invincibility_time:
live_taken = False
# Strange snake scale behaviour of snake when snake respawn runs here. (To inspect that just in case.)
else: # GAME OVER
# pygame.display.update() # this update causes flicker of the rectangle and text below
pygame.draw.rect(
window, (155, 50, 50),
(start_x - 2, start_y - 2, view_width + 4, view_height + 4))
GUI.display_text(window, "GAME OVER! ", 100, (0, 0, 0), [310, 300])
# GUI
GUI.display_text(window, "Score: " + str(score), 50, (0, 0, 0),
[40, 10])
GUI.display_text(window, "Lives: " + str(snake.lives), 50, (0, 0, 0),
[910, 10])
# Limit frames to 60
clock.tick(60)
# Displays the buffered data
pygame.display.update()
class Game:
def __init__(self,
width,
length,
n_apples,
snake_x0,
snake_y0,
d=direction.right,
render=False):
self.width_ = width
self.length_ = length
self.n_apples_ = n_apples
self.snake_x0_ = snake_x0
self.snake_y0_ = snake_y0
self.snake_ = None
self.direction_ = d
self.score_ = 0
self.render_ = render
self.reset()
if self.render_:
self.render()
def reset(self):
self.world_ = Map(self.width_, self.length_, self.n_apples_,
self.render_)
self.snake_x0_ = 1 + np.random.randint(self.length_ - 2)
self.snake_y0_ = 1 + np.random.randint(self.width_ - 2)
self.direction_ = direction(np.random.randint(4))
self.snake_ = Snake(self.snake_x0_, self.snake_y0_, self.direction_)
self.world_.update(self.snake_)
self.score_ = 0
s = State(self.snake_, self.world_)
s_array = np.concatenate((s.to_array(), [self.snake_.length_],
directionToArray(self.snake_.direction_)))
return s_array
def render(self):
self.world_.render()
def step(self, d):
t = Transition()
t.state_ = State(self.snake_, self.world_)
t.direction_ = d
self.snake_.turn(d)
score_move = self.snake_.move_forward(self.world_)
self.world_.update(self.snake_)
t.next_state_ = State(self.snake_, self.world_)
#t.score_ = self.snake_.length_ - 1
self.reward_ = self.snake_.length_ + score_move - 1
#self.reward_ = score_move
self.score_ = self.score_ + self.reward_
state_array = np.concatenate(
(t.next_state_.to_array(), [self.snake_.length_],
directionToArray(self.snake_.direction_)))
if self.render_:
#print('\n\nnew step')
#print("self.snake_.length_:{}".format(self.snake_.length_))
#print("directionToArray(self.snake_.direction_):{}".format(directionToArray(self.snake_.direction_)))
#t.next_state_.render()
self.render()
return (state_array, self.reward_, not self.snake_.isAlive(),
t.direction_)
def get_direction_input(self):
with Input(keynames='curses') as input_generator:
for e in input_generator:
if e == 'KEY_UP':
return direction.up
elif e == 'KEY_DOWN':
return direction.down
elif e == 'KEY_LEFT':
return direction.left
elif e == 'KEY_RIGHT':
return direction.right
else:
print(e)
class Gameplay:
ended = False
pause = False
gameOver = False
cols = 40
rows = 40
boardSize = 0
gapSize = 0
blockSize = 0
WHITE = [255, 255, 255]
GRAY = [122, 122, 122]
BLACK = [0, 0, 0]
RED = [255, 0, 0]
GREEN = [0, 255, 0]
BLUE = [0, 0, 255]
SNAKE_COLOR = WHITE
HEAD_COLOR = WHITE
BACKGROUND_COLOR = BLACK
FIELD_COLOR = [10, 10, 10]
EDGE_COLOR = WHITE
GRID_COLOR = [40, 40, 40]
FOOD_COLOR = GREEN
TEXT_COLOR = WHITE
startX = 0
startY = 0
score = -1
tick = 0
snake = None
food = None
grid = None
def __init__(self, width, height):
self.boardSize = min(width, height) - 30
self.gapSize = 0
self.blockSize = self.boardSize // self.cols - self.gapSize
self.startX = 1.5 * self.blockSize
self.startY = 1.5 * self.blockSize
self.areWalls = True
self.windowEvent = threading.Event()
self.aiEvent = threading.Event()
self.aiIsOn = False
self.setGame()
def setGame(self):
self.makeGrid()
self.snake = Snake(self.cols // 2, self.rows // 2, self)
self.randomFood()
self.setColors()
self.setPause(False)
self.setGameOver(False)
def endGame(self):
self.ended = True
def setPause(self, state):
self.pause = state
if state:
self.SNAKE_COLOR = self.GRAY
self.HEAD_COLOR = self.GRAY
self.EDGE_COLOR = self.GRAY
else:
self.SNAKE_COLOR = self.WHITE
self.HEAD_COLOR = self.WHITE
self.EDGE_COLOR = self.WHITE
self.setColors()
def getPause(self):
return self.pause
def setGameOver(self, state):
self.gameOver = state
if state:
self.SNAKE_COLOR = self.RED
self.HEAD_COLOR = self.RED
self.EDGE_COLOR = self.RED
else:
self.SNAKE_COLOR = self.WHITE
self.HEAD_COLOR = self.WHITE
self.EDGE_COLOR = self.WHITE
self.setColors()
def getTick(self):
return self.tick
def setTickValue(self, val):
self.tick = val
def makeTick(self):
self.tick -= 1
def isGameOver(self):
return self.gameOver
def hasQuitted(self):
return self.ended
def quit(self):
self.ended = True
def setEvents(self):
self.windowEvent.set()
self.aiEvent.set()
def isAiOn(self):
return self.aiIsOn
def turnOnAi(self):
ai = SnakeAI(self)
self.ai = threading.Thread(target=ai.run)
self.aiIsOn = True
self.ai.start()
def turnOffAi(self):
self.aiIsOn = False
def randomFood(self):
x = random.randint(1, self.cols - 2)
y = random.randint(1, self.rows - 2)
block = self.grid[x][y]
while self.snake.contains(block):
x = random.randint(1, self.cols - 2)
y = random.randint(1, self.rows - 2)
block = self.grid[x][y]
block.setColor(self.FOOD_COLOR)
self.food = block
def makeGrid(self):
newGrid = []
for i in range(self.cols):
newGrid.append([])
for j in range(self.rows):
newGrid[i].append(Block(i, j, self))
self.grid = newGrid
def setColors(self):
for i in range(self.cols):
for j in range(self.rows):
if i == 0 or i == self.cols - 1 or j == 0 or j == self.rows - 1:
if self.areWalls:
color = self.EDGE_COLOR
else:
color = self.FIELD_COLOR
else:
color = self.FIELD_COLOR
self.grid[i][j].setColor(color)
self.snake.setColor()
self.food.setColor(self.FOOD_COLOR)
def onPress(self, event):
key_pressed = pygame.key.get_pressed()
if event.type == pygame.KEYDOWN:
if key_pressed[pygame.K_LEFT] and not self.pause:
self.snake.turnLeft()
elif key_pressed[pygame.K_RIGHT] and not self.pause:
self.snake.turnRight()
if key_pressed[pygame.K_p]:
self.setPause(not self.pause)
elif key_pressed[pygame.K_r]:
self.setGame()
self.setGameOver(False)
elif key_pressed[pygame.K_0]:
if self.aiIsOn:
self.turnOffAi()
else:
self.turnOnAi()
if key_pressed[pygame.K_1]:
self.gapSize = 0
self.blockSize = self.boardSize // self.cols - self.gapSize
elif key_pressed[pygame.K_2]:
self.gapSize = 1
self.blockSize = self.boardSize // self.cols - self.gapSize
elif key_pressed[pygame.K_3]:
self.gapSize = 4
self.blockSize = self.boardSize // self.cols - self.gapSize
if key_pressed[pygame.K_e]:
self.areWalls = not self.areWalls
self.setColors()
def lock(self):
self.gameplayLock.acquire()
def unlock(self):
self.gameplayLock.release()
def play(self):
if not self.pause and not self.gameOver:
self.snake.move()
def draw(self, screen):
if self.score != self.snake.getScore() or self.pause or self.gameOver:
self.drawBackground(screen)
self.drawGrid(screen)
self.food.draw(screen)
self.score = self.snake.getScore()
self.drawInfo(screen)
else:
self.drawGrid(screen)
self.food.draw(screen)
def drawBackground(self, screen):
screen.fill(self.BLACK)
def drawGrid(self, screen):
for i in range(self.cols):
for j in range(self.rows):
x = self.startX + i * (self.blockSize + self.gapSize)
y = self.startY + j * (self.blockSize + self.gapSize)
pygame.draw.rect(screen, self.GRID_COLOR, [
x - self.gapSize, y - self.gapSize, self.blockSize +
2 * self.gapSize, self.blockSize + 2 * self.gapSize
])
self.grid[i][j].draw(screen)
def drawInfo(self, screen):
font1 = pygame.font.SysFont("comicsansms", 42)
font2 = pygame.font.SysFont("comicsansms", 24)
info1 = "SNAKE!"
info2 = "by Piotr Maliszewski"
info3 = "Score: {}".format(self.score)
text1 = font1.render(info1, True, self.TEXT_COLOR)
text2 = font2.render(info2, True, self.TEXT_COLOR)
text3 = font1.render(info3, True, self.TEXT_COLOR)
screen.blit(text1, (self.boardSize + 3 *
(self.blockSize + self.gapSize), self.startY))
screen.blit(text2,
(self.boardSize + 4 * (self.blockSize + self.gapSize),
self.startY + 4 * (self.blockSize + self.gapSize)))
screen.blit(text3,
(self.boardSize + 3 * (self.blockSize + self.gapSize),
self.startY + 6 * (self.blockSize + self.gapSize)))
if self.gameOver:
overText1 = font1.render("Game Over!", True, self.TEXT_COLOR)
overText2 = font1.render("press r to restart", True,
self.TEXT_COLOR)
screen.blit(overText1,
((self.boardSize - overText1.get_width()) // 3,
self.boardSize // 3))
screen.blit(overText2,
((self.boardSize - overText1.get_width()) // 3,
self.boardSize // 3 + 4 *
(self.blockSize + self.gapSize)))
elif self.pause:
pauseText1 = font1.render("Pause", True, self.TEXT_COLOR)
pauseText2 = font1.render("press p to unpause", True,
self.TEXT_COLOR)
screen.blit(pauseText1,
((self.boardSize - pauseText1.get_width()) // 3,
self.boardSize // 3))
screen.blit(pauseText2,
((self.boardSize - pauseText1.get_width()) // 3,
self.boardSize // 3 + 4 *
(self.blockSize + self.gapSize)))
def reset(self):
"""Prepare for next run."""
_Scene.reset(self)
self.snake = Snake()
self.walls = self.make_walls()
self.apple = Apple(self.walls, self.snake)
def update(self):
for event in pygame.event.get(): # Check all event
if event.type == pygame.QUIT: # Click Quit to quit program
pygame.quit() # quit programe
quit()
if event.type == pygame.KEYDOWN: # If pressed keyboard
if event.key == pygame.K_LEFT and not self.snake.get_move_list(
'right'): # Pressed left and not go right
self.snake.set_left() # Go left
elif event.key == pygame.K_RIGHT and not self.snake.get_move_list(
'left'): # Pressed right and not go left
self.snake.set_right() # Go right
elif event.key == pygame.K_UP and not self.snake.get_move_list(
'down'): # Pressed up and not go down
self.snake.set_up() # Go up
elif event.key == pygame.K_DOWN and not self.snake.get_move_list(
'up'): # Pressed down and not go up
self.snake.set_down() # Go down
elif event.key == pygame.K_x: # Press x
self.snake.snake_slide(self.snake.get_move(),
self.apple) # Use slide snake skill
elif event.key == pygame.K_c: # Press c
self.snake.snake_running() # Use running snake skill
x_pos_ls = [
int(self.snake.get_x_pos()[i] / self.tile_mng.get_sizew_tile())
for i in range(self.snake.get_number_body())
] # set x's list
y_pos_ls = [
int(self.snake.get_y_pos()[i] / self.tile_mng.get_sizeh_tile())
for i in range(self.snake.get_number_body())
] # set y's list
x_pos_n = self.client.pos_pattern(
x_pos_ls) # save in string in postion pattern (x, y)
y_pos_n = self.client.pos_pattern(y_pos_ls)
pattern = self.client.set_pattern(self.snake.get_id(), [
self.snake.get_type(), x_pos_n, y_pos_n,
self.snake.get_score(), 0
]) # set pattern of all data
# id,type,xs,ys,score,time
if self.client_state == self.client_state_dict[
'OK']: # Client state is "OK"
self.snake.snake_eat_apple(
self.apple) # Check does snake eat apple ?
self.snake.update() # Update snake
if self.apple.get_eaten(): # Apple is eaten by snake
pattern = "eaten" # pattern is "eaten"
self.apple.set_eaten(False) # Apple is not eaten
self.client.send(pattern) # Send pattern to client
data, addr = self.client.recv() # Receive data from server
if data == None: # Data is none => exit method
return
if data == "notNStart": # data is notNStart => set client state
self.client_state = self.client_state_dict['notNStart']
elif data == "notNExit": # data is notNExit => set client state
self.client_state = self.client_state_dict['notNExit']
else: # otherwise
self.client_state = self.client_state_dict[
'OK'] # Set client state to "OK"
split_list = self.client.split(data) # Split data
for ls in split_list:
self.game_time = int(ls[self.t]) # set time
if ls[self.id] == "*": # See id of apple
self.apple = Apple(int(ls[self.x]), int(ls[self.y]),
self.tile_mng, red, str(ls[self.type]))
elif ls[self.id] != self.snake.get_id() and ls[
self.id] != "*": # See enemy snake's id
self.enemy_dict[ls[self.id]] = Snake(
0, 0, self.tile_mng, blue, ls[self.type], ls[self.id],
0) # Save in dictionary of enemy snake
x_pos = self.client.pos_split(ls[self.x])
y_pos = self.client.pos_split(ls[self.y])
x_list = [
int(x_pos[i] * self.tile_mng.get_sizew_tile())
for i in range(len(x_pos))
]
y_list = [
int(y_pos[i] * self.tile_mng.get_sizeh_tile())
for i in range(len(y_pos))
]
self.enemy_dict[ls[self.id]].set_pos(
x_list, y_list) # Set postion enemy snake
print "total_lines: " + str(nibble.total_lines)
print "center_x: " + str(nibble.center_x)
print "center_y: " + str(nibble.center_y)
print "python's dir: " + os.getcwd()
print "script's dir: " + os.path.dirname(os.path.abspath(__file__))
# Create level
currentLevel = Level(1,nibble.total_columns,nibble.total_lines)
# Draw level
nibble.drawLevel(currentLevel)
nibble.displayMessage("Level" + str(nibble.level) + ", Push Space")
nibble.drawLevel(currentLevel)
# Create a Snake
mySnake = Snake(nibble.center_x,nibble.center_y)
# Show the first Apple
apple = Apple(nibble.total_columns,nibble.total_lines,currentLevel,mySnake)
pygame.draw.rect(nibble.screen, (0, 255, 0), pygame.Rect(apple.getX(), apple.getY(), mySnake.size, mySnake.size),0)
pygame.mixer.init(48000, -16, 1, 1024)
sound_eat = pygame.mixer.Sound(os.path.dirname(os.path.abspath(__file__)) + '/hit.wav')
sound_crash = pygame.mixer.Sound(os.path.dirname(os.path.abspath(__file__)) + '/sounds/crash.ogg')
sound_game_over = pygame.mixer.Sound(os.path.dirname(os.path.abspath(__file__)) + '/sounds/reverse.ogg')
def resetLevel(mySnake):
# Recreate Level 1
global currentLevel
currentLevel = Level(nibble.level,nibble.total_columns,nibble.total_lines)
if leer:
ausschnitt.append(0)
else:
ausschnitt.append(1)
# Schritt 2: in eine Zahl umwandeln
wertigkeit = 1
summe = 0
# for binärziffer in ausschnitt:
for stelle in range(kantenlänge**2):
binärziffer = ausschnitt[stelle]
maskiert = int(maske[stelle])
if maskiert != 0:
if binärziffer == 1:
summe += wertigkeit
wertigkeit = wertigkeit * 2
# 0 1 0 0 1 0 0 0 0 Eingang
# 1 1 1 1 0 1 1 1 1 Maske
# 128 64 32 16 8 4 2 1
return summe
if __name__ == "__main__":
field = Field(10, 20)
snake = Snake(field)
number = situation_number(3, "111 111 111", snake.get_info())
assert number == 16 + 128
number = situation_number(3, "111 101 111", snake.get_info())
class App(object):
def __init__(self):
self._running = False
self._main_clock = pygame.time.Clock()
self._display_surf = None
self.size = self.width, self.height = 640, 480
self._game = Game()
self._snake = Snake()
self._snake.set_position(100, 100)
def on_init(self):
pygame.init()
self._display_surf = pygame.display.set_mode(
self.size,
pygame.HWSURFACE | pygame.DOUBLEBUF)
pygame.display.set_caption('Snake')
self._running = True
def on_event(self, event):
if event.type == pygame.QUIT:
self._running = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
self._snake.set_direction(Snake.SNAKE_DIR_LEFT)
if event.key == pygame.K_RIGHT:
self._snake.set_direction(Snake.SNAKE_DIR_RIGHT)
if event.key == pygame.K_UP:
self._snake.set_direction(Snake.SNAKE_DIR_UP)
if event.key == pygame.K_DOWN:
self._snake.set_direction(Snake.SNAKE_DIR_DOWN)
if event.key == pygame.K_SPACE:
self._snake.set_direction(Snake.SNAKE_DIR_NONE)
def on_cleanup(self):
pygame.quit()
sys.exit()
def on_loop(self):
"""
Calculations and objects update
"""
self._snake.update()
def on_draw(self):
"""
Draw all objects
"""
self._display_surf.fill(Colors['BACKGROUND'])
self._snake.draw(self._display_surf)
def on_execute(self):
self.on_init()
"""
Main loop
"""
while self._running:
for event in pygame.event.get():
self.on_event(event)
self.on_loop()
self.on_draw()
pygame.display.flip()
self._main_clock.tick(60)
self.on_cleanup()
from Snake import Snake
from Population import Population
import time
import os
response = input(
"Please select an option: \n\n1.Play snake game\n2.Let computer learn to play\n0.Exit program\n"
)
while response != "0":
if response == "1":
print("\nGame starting...")
time.sleep(1)
snake = Snake(True, 0)
final_score = snake.new_game()
print("\nYou finished with a score of: " + str(final_score))
elif response == "2":
print("\nYou have chosen to let the computer learn how to play.")
print(
"The computer learns to play by generating random populations of snakes and letting them evolve and reproduce."
)
print(
"In essence, the computer is attempting to mimic how we evolve in nature."
)
print(
"\nNow that you understand how the computer will learn, you need to decide how many generations to simulate."
)
print(
"Each generation consists of 200 snakes. The snakes will move randomly at first but slowly learn to play over time."
)
print(
food_dir = np.array((food_dir[1], -food_dir[0]))
elif head_dir[1] == -1:
food_dir = np.array((-food_dir[1], food_dir[0]))
if food_dir[0] > 0:
return 0
elif food_dir[1] > 0:
return 1
elif food_dir[1] < 0:
return 2
else:
return int(np.random.randint(1, 3, []))
if __name__ == '__main__':
env = Snake(MAP_SIZE[0], MAP_SIZE[1])
player = NaiveDQNPlayer(MAP_SIZE)
for i in range(MAX_EPISODE):
s = env.reset()
step = 0
policy = np.random.rand(1)[0] < EPSILON + i * 0.0005
while not env.game_over:
a = 0
if policy or step > 100:
a = int(player.choose_action(s))
else:
a = naive_action_plan(env.get_snake(), env.food)
s_, r, _, _ = env.step(act_list[a])
player.add_record(s, a, r, s_)
s = s_
if player.step >= player.batch and player.step % 5 == 0:
"""
Author: Christopher Schicho
Project: Snake
Version: 0.0
"""
import sys
import pygame
from Snake import Snake
from Food import Food
from Config import Config as cfg
snake = Snake()
food = Food(snake.snake)
class Game:
def __init__(self):
# start pygame
pygame.init()
self.clock = pygame.time.Clock()
# window
self.window = pygame.display.set_mode((cfg.width, cfg.height))
pygame.display.set_caption("Snake by Christopher Schicho")
# font
self.font = pygame.font.SysFont("comicsansms", 30)
class Game:
def __init__(self, window_width, window_height):
# tiles and pixels
self._nb_tile_x = 60
self._tile_width = floor(window_width / self._nb_tile_x)
self._width_px = self._tile_width * self._nb_tile_x
self._nb_tile_y = floor(window_height / self._tile_width)
self._height_px = self._tile_width * self._nb_tile_y
# elements
# screen
self._screen = pygame.display.set_mode((self._width_px, self._height_px))
self._background = pygame.image.load('../assets/grass.jpg')
self._background = pygame.transform.scale(self._background, (self._width_px, self._height_px))
# objects
self._snake = Snake(self._nb_tile_x, self._nb_tile_y, self._tile_width)
self._apple = Apple(self._nb_tile_x - 1, self._nb_tile_y - 1, self._tile_width)
# other
self._running = True
def play(self):
self.create_new_apple()
while not self.has_lost() and self._running:
self.manage_event()
self.draw_screen()
self._snake.move_head()
if self.is_catching_the_apple():
self.create_new_apple()
self._snake.growth()
else:
self._snake.move_body()
pygame.display.flip()
time.sleep(0.05)
def manage_event(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self._running = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_w or event.key == pygame.K_UP:
self._snake.direction_current = Direction.UP
elif event.key == pygame.K_a or event.key == pygame.K_LEFT:
self._snake.direction_current = Direction.LEFT
elif event.key == pygame.K_s or event.key == pygame.K_DOWN:
self._snake.direction_current = Direction.DOWN
elif event.key == pygame.K_d or event.key == pygame.K_RIGHT:
self._snake.direction_current = Direction.RIGHT
def is_catching_the_apple(self):
return self._apple.x == self._snake.head_x and self._apple.y == self._snake.head_y
def has_lost(self):
return self._snake.has_lost()
def create_new_apple(self):
apple_coord = self._apple.get_coordinate()
while apple_coord in self._snake.body_coordinates or apple_coord == self._snake.get_head_coordinate():
self._apple.set_new_coordinates(self._nb_tile_x - 1, self._nb_tile_y - 1)
apple_coord = self._apple.get_coordinate()
def draw_screen(self):
# background
self._screen.blit(self._background, (0, 0))
# draw apple
self._screen.blit(self._apple.image, self._apple.rect_i)
# draw snake
# head
head_coordinate = self._snake.get_head_coordinate()
rect = pygame.Rect(head_coordinate[0] * self._tile_width, head_coordinate[1] * self._tile_width,
self._tile_width, self._tile_width)
pygame.draw.rect(self._screen, GREEN, rect)
# body
for part in self._snake.body_coordinates:
rect = pygame.Rect(part[0] * self._tile_width, part[1] * self._tile_width, self._tile_width,
self._tile_width)
pygame.draw.rect(self._screen, RED, rect)
class Game: """The game of Snake.""" def __init__(self, height, width, speed, placeObstacles=False): # Integer height of the plane self.height = height # Integer width of the plane self.width = width # Integer delay between frames of the of the game self.speed = speed # Integer score that is the length of the snake self.score = 0 # The snake, starting on the left side of the plane self.snake = Snake(Square(height // 2, width // 2, self.width)) # Boolean indicating whether to place obstacles or not self.placeObstacles = placeObstacles # Set of squares representing obstacles self.obstacles = set() # Square representing the food self.food = None def play(self): """Play the game.""" previousDirection = None listener = KeyListener() # Start the key listener listener.start() # Get the command for clearing the screen (dependent on OS) clearScreen = "cls" if platform.system() == "Windows" else "clear" # Place the first food self.placeFood() # Main game loop while not self.gameOver() and not listener.quit: # Display the game os.system(clearScreen) self.display(listener.paused) # Delay movement for the specified time time.sleep(self.speed) # Update the current direction currentDirection = listener.direction # Snake cannot immediately reverse direction if currentDirection == Direction.opposite(previousDirection): currentDirection = previousDirection # Move the snake if not paused if not listener.paused: self.move(currentDirection) # Store previous direction previousDirection = currentDirection # End the key listener listener.end() # Pause for 1 second time.sleep(1) def move(self, currentDirection): """Move the snake.""" next = self.nextSquare(currentDirection) if next: # Snake gets a food and grows by 1 square if next == self.food: self.snake.grow(next) self.placeFood() if self.placeObstacles: self.placeObstacle() self.score += 1 # Snake moves to next square else: self.snake.advance(next) def display(self, paused): """Display the game. paused -- boolean indicating whether the game is paused """ string = "" pausedString = "| PAUSED |" pausedString = pausedString if len(pausedString) + 2 <= self.width and paused else "" string += "+" + pausedString.center(self.width, "-") + "+\n" for row in reversed(range(self.height)): string += "|" for column in range(self.width): # Print the snake if Square(row, column, self.width) in self.snake: string += "O" # Print an obstacle elif Square(row, column, self.width) in self.obstacles: string += "&" # Print the food elif Square(row, column, self.width) == self.food: string += "+" # Print an empty space else: string += " " string += "|\n" # Display the score in the bottom border scoreString = "| SCORE: " + str(self.score) + " |" scoreString = scoreString if len(scoreString) + 2 <= self.width else "| " + str(self.score) + " |" string += "+" + scoreString.center(self.width, "-") + "+\n" print(string) def gameOver(self): """Return whether the game is over.""" head = self.snake.head() # Snake is out of bounds if head.x < 0 or head.x >= self.height or head.y < 0 or head.y >= self.width: return True # Snake has run into itself elif head in self.snake.snake[:-1]: return True # Snake has run into an obstacle elif head in self.obstacles: return True else: return False def nextSquare(self, currentDirection): """Return the next square based off the snake's direction.""" head = self.snake.head() if currentDirection == Direction.UP: return head.up() elif currentDirection == Direction.LEFT: return head.left() elif currentDirection == Direction.DOWN: return head.down() elif currentDirection == Direction.RIGHT: return head.right() def placeFood(self): """Place the food on a random square on the plane.""" x = random.randint(0, self.height - 1) y = random.randint(0, self.width - 1) food = Square(x, y, self.width) # Make sure not to place the food on the snake or an obstacle while food in self.snake or food in self.obstacles: x = random.randint(0, self.height - 1) y = random.randint(0, self.width - 1) food = Square(x, y, self.width) self.food = food def placeObstacle(self): """Place an obstacle on a random square on the plane.""" x = random.randint(0, self.height - 1) y = random.randint(0, self.width - 1) obstacle = Square(x, y, self.width) # Make sure not to place the obstacle on the snake or food while obstacle in self.snake or obstacle == self.food: x = random.randint(0, self.height - 1) y = random.randint(0, self.width - 1) obstacle = Square(x, y, self.width) self.obstacles.add(obstacle)
episodes_index = 0
moves_since_score = 0
danger_array = [0, 1]
dir_array = [Direction.UP, Direction.RIGHT, Direction.DOWN, Direction.LEFT]
food_dir_array = [-1, 0, 1]
q_model = QModel(generate_all_combinations([danger_array, danger_array, danger_array, dir_array,
food_dir_array, food_dir_array]),
[AIDirectionChoice.LEFT, AIDirectionChoice.FORWARD, AIDirectionChoice.RIGHT])
player_died = False
player_ate = False
previous_dist = -1.0
state = GameState.RUNNING
last_tick = math.floor(time.time() * 1000)
grid = Grid(0, 100, WIDTH, HEIGHT - 100, 15, 15, 0, 5)
snake = Snake(grid.get_size())
food = Food(grid.get_size(), snake)
player_points = 0
player_direction = Direction.RIGHT
print("Grid size: %s" % (grid.get_size(),))
running = True
while running:
time_now = math.floor(time.time() * 1000)
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
player_direction = Direction.LEFT
def game_loop(self):
"""The game loop for 1 player mode"""
snake_length = 6
snake = Snake(snake_length, color=GREEN, game=self)
apple = Apple(APPLE_SIZE, game=self)
def game_reset():
nonlocal snake, apple
snake = Snake(snake_length, color=GREEN, game=self)
apple = Apple(APPLE_SIZE, game=self)
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.game_exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT and snake.direction != 'RIGHT' and not snake.turned:
snake.started = True
snake.turned = True
snake.turn('LEFT')
elif event.key == pygame.K_RIGHT and snake.direction != 'LEFT' and not snake.turned:
snake.started = True
snake.turned = True
snake.turn('RIGHT')
elif event.key == pygame.K_UP and snake.direction != 'DOWN' and not snake.turned:
snake.started = True
snake.turned = True
snake.turn('UP')
elif event.key == pygame.K_DOWN and snake.direction != 'UP' and not snake.turned:
snake.started = True
snake.turned = True
snake.turn('DOWN')
if snake.hit_wall() or snake.hit_tail():
self.show_score(snake, game_reset)
self.display.fill(WHITE)
pygame.draw.rect(self.display, BLACK, [0, self.height, self.width, PANEL_HEIGHT])
self.message("Score: " + str(snake.score), RED, h_align='left', v_align='bottom', off_set_y=20)
apple.draw()
snake.draw()
if snake.started:
snake.go()
snake.turned = False
pygame.display.update()
if snake.eat(apple):
apple = Apple(APPLE_SIZE, game=self)
CLOCK.tick(FPS)
def Show(self):
screen = self.display
field = PlayField()
group = Snake()
group.ConstructSnake()
feed = Food()
block = feed.GetNewBlock(group.sprites())
groupFood = pygame.sprite.Group()
groupFood.add(block)
print(block.rect.center)
UPDATE = pygame.USEREVENT + 1
pygame.time.set_timer(UPDATE,70)
textsurface = Font.MonoSpace(15).render(str(self.highscore),False,Color.Black)
ps4 = PS4Controller()
ps4.init()
print(ps4.joystick_present)
if ps4.joystick_present:
if not ps4.hat_data:
ps4.hat_data = {}
for i in range(ps4.controller.get_numhats()):
ps4.hat_data[i] = (0, 0)
while not self.decision:
self.CheckEvents()
for event in pygame.event.get():
if ps4.joystick_present:
if event.type == pygame.JOYHATMOTION:
ps4.hat_data[event.hat] = event.value
hatValues = ps4.hat_data[0]
if hatValues[0] == -1:
self.key = pygame.K_LEFT
elif hatValues[0] == 1:
self.key = pygame.K_RIGHT
elif hatValues[1] == -1:
self.key = pygame.K_DOWN
elif hatValues[1] == 1:
self.key = pygame.K_UP
if event.type==pygame.KEYDOWN:
self.key = event.key
if event.type==UPDATE:
group.UpdateDirection(self.key)
game_over = not(pygame.sprite.collide_rect(field,group.sprites()[0])) or group.DetectCollisionWithItself()
if game_over:
self.decision = True
self.Quit(False)
else:
screen.fill(Color.White)
screen.blit(textsurface,(620,20))
group.Move()
group.draw(screen)
pygame.display.update()
groupFood.draw(screen)
if pygame.sprite.collide_rect(group.sprites()[0],groupFood.sprites()[0]):
group.EatFood(groupFood.sprites()[0])
block = feed.GetNewBlock(group.sprites())
groupFood.empty()
groupFood.add(block)
self.highscore+=1
textsurface = Font.MonoSpace(15).render(str(self.highscore),False,Color.Black)
body_path = os.path.join(base_path, "body.png")
tail_path = os.path.join(base_path, "tail.png")
apple_path = os.path.join(base_path, "apple.png")
pygame.init()
scene = pygame.display.set_mode(settings)
CLOCK = pygame.time.Clock()
head_img = pygame.image.load(head_path).convert()
body_img = pygame.image.load(body_path).convert()
tail_img = pygame.image.load(tail_path).convert()
apple_img = pygame.image.load(apple_path).convert()
apple = Apple(apple_img)
snake = Snake(head_img, body_img, tail_img)
allSprites = pygame.sprite.Group()
allSprites.add(snake.head)
allSprites.add(apple)
Running = True
score = 0
def process():
global score
global Running
if snake.is_out_of_bounds or snake.is_eating_self:
Running = False
WHITE = (255, 255, 255)
RED = (255, 0, 0)
ORANGE = (255, 165, 0)
YELLOW = (255, 255, 0)
ANOTHER_YELLOW = (230, 230, 5)
GREEN = (0, 255, 0)
LIGHTBLUE = (0, 255, 255)
BLUE = (0, 0, 255)
PURPLE = (128, 0, 128)
UP = 0
DOWN = 1
LEFT = 2
RIGHT = 3
apple = pygame.Rect(randint(3,87)*10, randint(3,47)*10, 10, 10)
new_snake = Snake(head_img, body_img, tail_img)
snake = [new_snake.get_head_rect()]
snakeHead = snake[0]
RAINBOW = [RED, ORANGE, ANOTHER_YELLOW, GREEN, LIGHTBLUE, BLUE, PURPLE]
dir = DOWN
def move_rect():
global dir
cur_y = snakeHead.y
cur_x = snakeHead.x
def __init__(self, screenProps):
self.game = Snake.Snake(screenProps)
self.winningScore = 21
def __init__(self):
'''
Constructor
'''
self.snake = Snake()
def main():
clock = pygame.time.Clock()
window_width = 300
window_height = 300
display_width = 80
display_height = 80
game = True
while game:
score = 60
game_display = Board(window_width, window_height)
snake = Snake(20, 20, 3)
food = Food(10, display_width, display_height, 10, snake)
font = pygame.font.SysFont('Time New Roman, Arial', 20)
text = font.render('Score: %d' % tuple([game_display.game_score]),
False, Board.gold)
x_change = 0
y_change = 0
first_time = True
eat = True
mov = 0
data_sets = np.arange(66)
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
game = False
if event.type == pygame.KEYDOWN:
first_time = False
if event.key == pygame.K_LEFT:
if x_change != 10:
x_change = -10
y_change = 0
mov = 4
elif event.key == pygame.K_RIGHT:
if x_change != -10:
x_change = 10
y_change = 0
mov = 6
elif event.key == pygame.K_UP:
if y_change != 10:
x_change = 0
y_change = -10
mov = 8
elif event.key == pygame.K_DOWN:
if y_change != -10:
x_change = 0
y_change = 10
mov = 2
if not first_time:
data_sets = update_data_set(data_sets, mov, snake, food)
snake.update(score)
if score % 10 == 0 and eat:
snake.append(
SnakeBody(snake[len(snake) - 1].x,
snake[len(snake) - 1].y))
print(len(snake))
eat = False
snake.move_head(x_change, y_change)
if (snake[0].x < food.food_x + 10 and snake[0].x >= food.food_x
and snake[0].y < food.food_y + 10
and snake[0].y >= food.food_y):
score += 10
game_display.game_score += 1
food = Food(10, display_width, display_height, 10, snake)
eat = True
if snake.check_death(display_width, display_height):
print("*****DEAD*****")
restart = game_display.pop_exit_window(data_sets)
if restart == True:
break
game_display.clean()
game_display.borders(display_height, display_width)
pygame.draw.rect(
game_display.GAME_display, Board.red,
(food.food_x, food.food_y, Snake.factor, Snake.factor))
snake.draw(game_display.GAME_display)
game_display.GAME_display.blit(text, (game_display.width - 50, 50))
pygame.display.flip()
time.sleep(0.280)
clock.tick(60)
def makeRectSegment(segment):
return pygame.Rect(
segment.x - segment.size / 2,
segment.y + segment.size / 2,
segment.size,
segment.size)
# game options
width = 600
height = 400
gameDifficulty = 6 # the higher the difficulty, the faster the snake moves
random.seed()
# make snake alive
snakey = Snake(width/2, height/2, 0)
segmentRectQueue = deque()
segSize = snakey.theSnake[0].size
# configure pygame window
pygame.init()
screenSize = width, height
screen = pygame.display.set_mode(screenSize, pygame.DOUBLEBUF)
screen.fill((255, 255, 255))
backgroundBlit = pygame.Surface((segSize, segSize))
backgroundBlit.fill((255, 255, 255))
pygame.display.set_caption('pySnake by bogu')
# make target alive
target = Segment(
from Apple import Apple
from Snake import Snake
pygame.init()
if __name__ == "__main__":
width = 700
height = 600
dsply = pygame.display.set_mode((width, height))
pygame.display.set_caption('Super Snake')
bg = pygame.image.load("Assignment14/assets/img/background.png")
font = pygame.font.Font('Assignment14/assets/font/ALGER.ttf', 32)
clock = pygame.time.Clock()
snake = Snake(dsply)
apple = Apple(dsply)
# Show Score Text
text = font.render('Score: 0', True, (255, 255, 255))
textRect = text.get_rect()
textRect.center = (width // 2, 30)
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit()
if not snake.x_move:
if snake.x < apple.x or snake.x - 1 < apple.x or snake.x - 2 < apple.x or snake.x - 3 < apple.x or snake.x - 4 < apple.x:
snake.direction = 'r'
def divide_snake(self, snake):
new_snake = Snake()
new_snake.initial_parts(initial_length)
self.derived_from(new_snake, snake)
self.add_widget(new_snake)
self.da_snakes.append(new_snake)
# Colors
red = pygame.Color(255, 0, 0) # gameover
green = pygame.Color(0, 255, 0) #snake
black = pygame.Color(0, 0, 0) #score
white = pygame.Color(255, 255, 255) #background
brown = pygame.Color(165, 42, 42) #food
# FPS controller
fpsController = pygame.time.Clock()
#Instantiating players
numberOfPlayers = 2
#TODO:BEAUTIFY
snake1 = Snake(100, 100, 100, 100, 90, 100, 80, 100)
snake2 = Snake(100, 300, 100, 300, 90, 300, 80, 300)
print(snake1.snakeBody)
print(snake2.snakeBody)
snakes = [snake1, snake2]
foodPos = [
random.randrange(1, frameWidth / 10) * 10,
random.randrange(1, frameHeight / 10) * 10
]
foodSpawn = True
# Game over function
def gameOver():
myFont = pygame.font.SysFont('monaco', 72)
def game_loop_2p(self):
"""Game loop for 2 player mode"""
snake_length = 6
snake1 = Snake(snake_length, color=GREEN, game=self, name="Player 1")
snake2 = Snake(snake_length, color=BLUE, game=self, img=SNAKE_HEAD_2, name="Player 2", offset_y=20)
apple = Apple(APPLE_SIZE, game=self)
def game_reset():
nonlocal snake1, snake2, apple
snake1 = Snake(snake_length, color=GREEN, game=self, name="Player 1")
snake2 = Snake(snake_length, color=BLUE, game=self, img=SNAKE_HEAD_2, name="Player 2", offset_y=20)
apple = Apple(APPLE_SIZE, game=self)
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.game_exit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT and snake1.direction != 'RIGHT' and not snake1.turned:
snake1.turn('LEFT')
elif event.key == pygame.K_RIGHT and snake1.direction != 'LEFT' and not snake1.turned:
snake1.turn('RIGHT')
elif event.key == pygame.K_UP and snake1.direction != 'DOWN' and not snake1.turned:
snake1.turn('UP')
elif event.key == pygame.K_DOWN and snake1.direction != 'UP' and not snake1.turned:
snake1.turn('DOWN')
elif event.key == pygame.K_a and snake2.direction != 'RIGHT' and not snake2.turned:
snake2.turn('LEFT')
elif event.key == pygame.K_d and snake2.direction != 'LEFT' and not snake2.turned:
snake2.turn('RIGHT')
elif event.key == pygame.K_w and snake2.direction != 'DOWN' and not snake2.turned:
snake2.turn('UP')
elif event.key == pygame.K_s and snake2.direction != 'UP' and not snake2.turned:
snake2.turn('DOWN')
self.display.fill(WHITE)
pygame.draw.rect(self.display, BLACK, [0, self.height, self.width, PANEL_HEIGHT])
self.message("Score: " + str(snake1.score), GREEN, h_align='left', v_align='bottom', off_set_y=20)
self.message("Score: " + str(snake2.score), BLUE, h_align='right', v_align='bottom', off_set_y=20)
apple.draw()
snake1.draw()
snake2.draw()
snake1.go()
snake2.go()
if snake1.hit_wall() or snake1.hit_tail():
snake1.die = True
if snake2.hit_wall() or snake2.hit_tail():
snake2.die = True
if snake1.die and snake2.die:
self.show_score(snake1, snake2, game_reset)
pygame.display.update()
if snake1.eat(apple) or snake2.eat(apple):
apple = Apple(APPLE_SIZE, game=self)
CLOCK.tick(FPS)
import pygame
from Objects import Apple, Pear, Bomb
from Snake import Snake
pygame.init()
if __name__ == "__main__":
width = 700
height = 600
dsply = pygame.display.set_mode((width, height))
pygame.display.set_caption('Super Snake')
bg = pygame.image.load("Assignment11/assets/img/background.png")
clock = pygame.time.Clock()
snake = Snake(dsply)
apple = Apple(dsply)
pear = Pear(dsply)
bomb = Bomb(dsply)
# Show Score Text
font = pygame.font.Font('Assignment11/assets/font/ALGER.ttf', 32)
text = font.render('Score: 0', True, (255, 255, 255))
textRect = text.get_rect()
textRect.center = (width // 2, 30)
while True:
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_a or event.key == pygame.K_LEFT:
snake.grow_dir = 'l'
from Food import Food
from Score import Score
from Snake import Snake
from turtle import Screen
import time
screen = Screen()
screen.setup(width=600, height=600)
screen.bgcolor("black")
screen.tracer(0)
snake = Snake()
food = Food()
score = Score()
screen.listen()
game_is_on = True
while game_is_on:
screen.update()
time.sleep(0.1)
snake.move()
if snake.segments[0].distance(food) < 15:
food.create_food()
score.increase_score()
snake.increase_length()
head = snake.segments[0]
for segment in snake.segments[1:]:
class Worker():
def __init__(self, name, trainer, model_path, global_episodes,
global_steps):
self.name = "worker_" + str(name)
self.number = name
self.model_path = model_path
self.trainer = trainer
self.global_episodes = global_episodes
self.increment_episodes = self.global_episodes.assign_add(1)
self.global_steps = global_steps
self.increment_steps = self.global_steps.assign_add(1)
self.episode_rewards = []
self.episode_lengths = []
self.episode_mean_values = []
self.summary_writer = tf.summary.FileWriter("train_" +
str(self.number))
# Create the local copy of the network and the tensorflow op to copy global paramters to local network
self.local_AC = AC_Network(self.name, trainer)
self.update_local_ops = update_target_graph('global', self.name)
print('Initializing environment #{}...'.format(self.number))
self.env = Snake(grid_height=GRID_HEIGHT, grid_width=GRID_WIDTH)
def train(self, rollout, sess, gamma, bootstrap_value):
rollout = np.array(rollout)
obs_grid = rollout[:, 0]
actions = rollout[:, 1]
rewards = rollout[:, 2]
next_obs_grid = rollout[:, 3]
values = rollout[:, 4]
# Here we take the rewards and values from the rollout, and use them to calculate the advantage and discounted returns
# The advantage function uses generalized advantage estimation from [2]
self.rewards_plus = np.asarray(rewards.tolist() + [bootstrap_value])
discounted_rewards = discount(self.rewards_plus, gamma)[:-1]
self.value_plus = np.asarray(values.tolist() + [bootstrap_value])
advantages = rewards + gamma * self.value_plus[
1:] - self.value_plus[:-1]
advantages = discount(advantages, gamma)
# Update the global network using gradients from loss
# Generate network statistics to periodically save
feed_dict = {
self.local_AC.target_v:
discounted_rewards,
self.local_AC.inputs:
np.stack(obs_grid).reshape(-1, GRID_HEIGHT, GRID_WIDTH, 3),
self.local_AC.actions:
actions,
self.local_AC.advantages:
advantages
}
v_l, p_l, e_l, g_n, v_n, _ = sess.run([
self.local_AC.value_loss, self.local_AC.policy_loss,
self.local_AC.entropy, self.local_AC.grad_norms,
self.local_AC.var_norms, self.local_AC.apply_grads
],
feed_dict=feed_dict)
return v_l / len(rollout), p_l / len(rollout), e_l / len(
rollout), g_n, v_n
def work(self, max_episode_length, gamma, sess, coord, saver):
episode_count = sess.run(self.global_episodes)
total_steps = 0
print("Starting worker " + str(self.number))
with sess.as_default(), sess.graph.as_default():
while not coord.should_stop():
# Download copy of parameters from global network
sess.run(self.update_local_ops)
episode_buffer = []
episode_values = []
episode_frames = []
episode_reward = 0
episode_step_count = 0
episode_end = False
# Start new episode
obs = self.env.reset()
episode_frames.append(obs)
feature_stack = np.array([
np.zeros_like(self.env.grid),
np.zeros_like(self.env.grid),
np.zeros_like(self.env.grid)
])
reward, features, episode_end = process_observation(obs)
feature_stack = np.concatenate((feature_stack[1:], [features]))
s_features = np.expand_dims(np.stack(feature_stack, axis=2),
axis=0)
while not episode_end:
# Take an action using distributions from policy networks' outputs
action_dist, v = sess.run(
[self.local_AC.policy_actions, self.local_AC.value],
feed_dict={self.local_AC.inputs: s_features})
# Apply filter to remove unavailable actions and then renormalize
for action_id, action_prob in enumerate(action_dist[0]):
if action_id not in obs.available_actions:
action_dist[0][action_id] = 0
if np.sum(action_dist[0]) != 1:
current_sum = np.sum(action_dist[0])
action_dist[0] /= current_sum
action = sample_dist(action_dist, self.global_steps)
obs = self.env.step(action)
r, features, episode_end = process_observation(obs)
feature_stack = np.concatenate(
(feature_stack[1:], [features]))
s1_features = np.expand_dims(np.stack(feature_stack,
axis=2),
axis=0)
if not episode_end:
episode_frames.append(obs)
else:
s1_features = s_features
# Append latest state to buffer
episode_buffer.append([
s_features, action, r, s1_features, episode_end, v[0,
0]
])
episode_values.append(v[0, 0])
episode_reward += r
s_features = s1_features
sess.run(self.increment_steps)
total_steps += 1
episode_step_count += 1
# If the episode hasn't ended, but the experience buffer is full, then we make an update step using that experience rollout
if len(
episode_buffer
) == 30 and not episode_end and episode_step_count != max_episode_length - 1:
# Since we don't know what the true final return is, we "bootstrap" from our current value estimation
v1 = sess.run(
self.local_AC.value,
feed_dict={self.local_AC.inputs: s_features})[0, 0]
v_l, p_l, e_l, g_n, v_n = self.train(
episode_buffer, sess, gamma, v1)
episode_buffer = []
sess.run(self.update_local_ops)
if episode_end:
break
self.episode_rewards.append(episode_reward)
self.episode_lengths.append(episode_step_count)
self.episode_mean_values.append(np.mean(episode_values))
episode_count += 1
global _max_score, _running_avg_score, _episodes, _steps
if _max_score < episode_reward:
_max_score = episode_reward
_running_avg_score = (2.0 / 101) * (
episode_reward - _running_avg_score) + _running_avg_score
_episodes[self.number] = episode_count
_steps[self.number] = total_steps
if episode_count % 1 == 0:
print("{} Step #{} Episode #{} Reward: {}".format(
self.name, total_steps, episode_count, episode_reward))
print(
"Total Steps: {}\tTotal Episodes: {}\tMax Score: {}\tAvg Score: {}"
.format(sess.run(self.global_steps),
sess.run(self.global_episodes), _max_score,
_running_avg_score))
# Update the network using the episode buffer at the end of the episode
if len(episode_buffer) != 0:
v_l, p_l, e_l, g_n, v_n = self.train(
episode_buffer, sess, gamma, 0.0)
if episode_count % 5 == 0 and episode_count != 0:
if episode_count % 10 == 0 and self.name == 'worker_0':
saver.save(
sess, self.model_path + '/model-' +
str(episode_count) + '.cptk')
print("Saved Model")
mean_reward = np.mean(self.episode_rewards[-5:])
mean_length = np.mean(self.episode_lengths[-5:])
mean_value = np.mean(self.episode_mean_values[-5:])
summary = tf.Summary()
summary.value.add(tag='Perf/Reward',
simple_value=float(mean_reward))
summary.value.add(tag='Perf/Length',
simple_value=float(mean_length))
summary.value.add(tag='Perf/Value',
simple_value=float(mean_value))
summary.value.add(tag='Losses/Value Loss',
simple_value=float(v_l))
summary.value.add(tag='Losses/Policy Loss',
simple_value=float(p_l))
summary.value.add(tag='Losses/Entropy',
simple_value=float(e_l))
summary.value.add(tag='Losses/Grad Norm',
simple_value=float(g_n))
summary.value.add(tag='Losses/Var Norm',
simple_value=float(v_n))
self.summary_writer.add_summary(summary, episode_count)
self.summary_writer.flush()
if self.name == 'worker_0':
sess.run(self.increment_episodes)
from turtle import Screen
from Snake import Snake
from Food import Food
from scoreboard import ScoreBoard
import time
screen = Screen()
screen.setup(width=600, height=600)
screen.bgcolor("black")
screen.title("Snake O Mania")
screen.tracer(0)
snake = Snake()
food = Food()
scoreboard = ScoreBoard()
screen.listen()
screen.onkey(snake.up, "Up")
screen.onkey(snake.down, "Down")
screen.onkey(snake.left, "Left")
screen.onkey(snake.right, "Right")
is_game_on = True
while is_game_on:
screen.update()
time.sleep(.1)
snake.move()
# detecting the collision with food
if snake.head.distance(food) < 15:
food.refresh()
from kilo import led
from GamePadEmu import GamePadEmu
from Snake import Snake
if __name__ == "__main__":
import time
with GamePadEmu() as pad:
anim = Snake(led, pad)
try:
anim.run(fps=30)
except KeyboardInterrupt:
led.all_off()
led.update()
time.sleep(1)
