def test_is_dead(self):
my_snake = Snake(20, 60)
self.assertEquals(my_snake.is_dead(), False)
center = [ceil(my_snake.height / 2), ceil(my_snake.width / 2)]
my_snake.cells.append([center[0], center[1]])
self.assertEquals(my_snake.is_dead(), True)
def test_tick(self):
my_snake = Snake(20, 60)
center = [ceil(my_snake.height / 2), ceil(my_snake.width / 2)]
food1 = [center[0], center[1] + 3]
food2 = [center[0], center[1] + 5]
self.assertEquals(my_snake.tick(food1), True)
self.assertEquals(my_snake.tick(food2), False)
def __init__(self):
pygame.init()
pygame.mouse.set_visible(False)
self.main_clock = pygame.time.Clock()
window.set_caption('snake game')
self.surface = window.set_mode(surface_size)
self.snake = Snake(self.surface)
self.food = Food(self.surface, self.snake.head)
self.monster = Monster(self.surface, self.snake.head)
self.food.on_collide_event = self.snake.grow_up
self.eventHandler = EventHandler(pygame.KEYDOWN)
self.add_events()
def test_teleport_wall(self):
my_snake = Snake(20, 60)
my_snake.cells = [[0, 30]]
self.assertEquals(my_snake.teleport_wall(), 0)
my_snake.cells = [[10, 0]]
self.assertEquals(my_snake.teleport_wall(), 0)
my_snake.cells = [[my_snake.height - 1, 0]]
self.assertEquals(my_snake.teleport_wall(), 0)
my_snake.cells = [[0, my_snake.width - 1]]
self.assertEquals(my_snake.teleport_wall(), 0)
self.assertEquals(True, True)
class SnakeGame:
def __init__(self):
pygame.init()
pygame.mouse.set_visible(False)
self.main_clock = pygame.time.Clock()
window.set_caption('snake game')
self.surface = window.set_mode(surface_size)
self.snake = Snake(self.surface)
self.food = Food(self.surface, self.snake.head)
self.monster = Monster(self.surface, self.snake.head)
self.food.on_collide_event = self.snake.grow_up
self.eventHandler = EventHandler(pygame.KEYDOWN)
self.add_events()
def add_events(self):
# exit.
self.eventHandler.add_event(QUIT, lambda event: exit(0))
self.eventHandler.add_subevent(KEYDOWN, K_q, exit)
# movement.
self.eventHandler.add_subevent(KEYDOWN, K_UP, self.snake.go_up)
self.eventHandler.add_subevent(KEYDOWN, K_RIGHT, self.snake.go_right)
self.eventHandler.add_subevent(KEYDOWN, K_DOWN, self.snake.go_down)
self.eventHandler.add_subevent(KEYDOWN, K_LEFT, self.snake.go_left)
self.eventHandler.add_subevent(KEYDOWN, K_LSHIFT, self.snake.speed_up)
self.eventHandler.add_subevent(KEYDOWN, K_SPACE, self.snake.shrink)
# self.eventHandler.add_subevent(KEYDOWN, pygame.K_a, self.snake.grow_down_head)
def update_screen(self):
self.surface.fill(white)
pygame.draw.rect(self.surface, black,
(0, 0, surface_size[0], surface_size[1]),
stroke_width)
# draw borders.
self.food.draw()
self.snake.play()
self.monster.play()
self.food.check_collision()
for i in range(self.food.fixed_counter):
pygame.draw.rect(self.surface, cp[i % 4], borders_position[i],
stroke_width)
pygame.display.flip()
def start(self):
while True:
self.eventHandler.check_events()
self.update_screen()
self.main_clock.tick(50)
def main():
noOfSnakes = int(input())
snakes = []
for i in range(noOfSnakes):
snakes.append(Snake(int(input()), int(input())))
noOfLadders = int(input())
ladders = []
for i in range(noOfLadders):
ladders.append(Ladder(int(input()), int(input())))
noOfPlayers = int(input())
players = []
for i in range(noOfPlayers):
players.append(Player(str(input())))
size = int(input())
snakeAndLadder1 = SnakeAndLadderService(size)
snakeAndLadder1.setPlayers(players)
snakeAndLadder1.setSnakes(snakes)
snakeAndLadder1.setLadders(ladders)
snakeAndLadder1.startGame()
def __init__(self):
self.snake = Snake(self.len, self.len)
self.board = Board(self.len, self.len)
from model.snake import Snake
from view.term_draw import draw_chr
# UP = (0, -1)
# DOWN = (0, 1)
# LEFT = (-1, 0)
# RIGHT = (1, 0)
LEFT = [0, -1]
RIGHT = [0, 1]
UP = [-1, 0]
DOWN = [1, 0]
curses.initscr()
my_board = Board(20, 60)
my_snake = Snake(20, 60)
win = curses.newwin(my_board.height,my_board.width, 0, 0)
win.keypad(1)
curses.noecho()
curses.curs_set(0)
win.border(0)
win.nodelay(1)
key = KEY_RIGHT
score = 0
win.addch(my_board.food[0], my_board.food[1], '*')
while key != 27: # press Space to exit
win.border(0)
win.addstr(0, 2, 'Score : ' + str(score) + ' ') # Printing 'Score' and
win.addstr(0, 14, 'Welcome to SNAKE world') # 'SNAKE' strings
def play_game(genomes, config):
global screen
global best_fitness
global pop
dx = 1
dy = 0
best_foods = 0
generation_number = 0
best_instance = None
genome_number = 0
# Create the field, the snake and a bit of food
theField = Field(screen, gu.field_width, gu.field_height, gu.blockSize,
gu.field_color)
# Outer loop is for all the genomes
for genome_id, genome in genomes:
net = neat.nn.FeedForwardNetwork.create(genome, config)
dx = 1
dy = 0
score = 0.0
calories = 100
# create food at random position
theFood = Food(theField)
# Snake starts from a fixed location
theSnake = Snake(theField,
gu.snake_color,
5,
x=int(gu.field_width / 2),
y=int(gu.field_height / 2))
# initialize an empty set for loop detection
loopPoints = set()
food_count = 0 # keep counting of food
while True:
event = pygame.event.wait()
# Window is going to be closed
if event.type == pygame.QUIT:
print("Quitting the game now ...")
## save the population
gu.save_object(pop, gu.pop_data_file)
pygame.quit()
sys.exit()
# Every TIME_DURATION there will be a SNAKE_EVENT to move the snake
if event.type == SNAKE_EVENT:
# initially dx = 1 and dy = 0 i.e. moving to the right on X axis
# current distance from the food
hx, hy = theSnake.position()
fx, fy = theFood.position()
dist_before_move = math.sqrt((hx - fx)**2 + (hy - fy)**2)
# find out current input points (total 9 for now)
inputs = gu.get_inputs(theSnake.body[0], theFood.position(),
(gu.field_width, gu.field_height),
(dx, dy))
# it will generate 3 outputs (continue straight, left or right)
outputs = net.activate(inputs)
# find index of maximum value and determine the direction (0 - straight, 1 - left or 2 - right)
direction = outputs.index(max(outputs))
# decide the movement direction based on the outcome
if direction == 1: # turn left
(dx, dy) = gu.left((dx, dy))
elif direction == 2: # turn right
(dx, dy) = gu.right((dx, dy))
else: # keep going straight (direction = 0)
# dx and dy values will remain same
pass
# because of movement calories will burn
calories -= 1
# move the snake now, also check if move is invalid or calories are exausted
# if not theSnake.move(dx, dy) or calories <= 0:
if (theSnake.move(dx, dy) == False) or (theSnake.body[0]
in loopPoints):
# too bad snake died
# genome.fitness = 0
loopPoints = set()
break
# Reward the snake for being alive
score += gu.ALIVE_SCORE
# punish for the loop
# if theSnake.body[0] in loopPoints:
# score -= gu.LOOP_SCORE
# keep tracking head positon till next food grab
loopPoints.add(theSnake.body[0])
# distance from the food after the move
hx, hy = theSnake.position()
dist_after_move = math.sqrt((hx - fx)**2 + (hy - fy)**2)
# adjust the score
if (hx, hy) == (fx, fy):
# if snake grabs the food
food_count += 1
score += gu.FOOD_SCORE
calories += gu.FOOD_CALORIES # found food, got calories
theSnake.grow() # grow by one length
# Make new food now
theFood = Food(theField)
# Also reset loopPoints
loopPoints = set()
elif dist_after_move > dist_before_move:
score -= gu.FAR_SCORE
elif dist_after_move < dist_before_move:
score += gu.NEAR_SCORE
else:
# place holder for something else
score += 0
# end of SNAKE_EVENT
# Render snake and food
theField.draw()
theFood.draw()
theSnake.draw()
pygame.display.update()
pygame.time.wait(gu.renderdelay)
# end of while loop
# while loop is done for the current genome
for i in range(0, 2):
theField.draw()
theFood.draw()
theSnake.draw(damage=(i % 2 == 0))
pygame.display.update()
# Tell about the fitness
genome.fitness = score / 100
# Keep saving best instance
if not best_instance or genome.fitness > best_fitness:
best_instance = {
'num_generation': generation_number,
'fitness': genome.fitness,
'score': score,
'genome': genome,
'net': net,
}
best_foods = max(best_foods, food_count)
best_fitness = max(best_fitness, genome.fitness)
# if gu.debug_on:
roudn_places = 5
print(f"Generation {generation_number} \t" + \
f"Genome {genome_number} \t" + \
f"Foods {food_count} \t" + \
f"BF {best_foods} \t" + \
f"Fitness {round(genome.fitness, roudn_places)} \t" + \
f"Best fitness {round(best_fitness, roudn_places)} \t" + \
f"Score {round(score, roudn_places)}")
genome_number += 1
# end of for loop, all genomes are done
# Save end results
gu.save_best_generation_instance(best_instance)
generation_number += 1
if generation_number % 20 == 0:
gu.save_object(pop, gu.pop_data_file)
print("Exporting population")
# export population
# gu.save_object(pop,gu.pop_data_file)
# export population
global list_best_fitness
global fig
list_best_fitness.append(best_fitness)
line_best_fitness.set_ydata(np.array(list_best_fitness))
line_best_fitness.set_xdata(list(range(len(list_best_fitness))))
plt.xlim(0, len(list_best_fitness) - 1)
plt.ylim(0, max(list_best_fitness) + 0.5)
fig.canvas.draw()
fig.canvas.flush_events()
def single_ai_mode():
# set up local player data
addPlayerData(player_name)
screen_size = [700, 700]
pygame.init()
fpsClock = pygame.time.Clock()
# create pyGame screen
playSurface = pygame.display.set_mode((screen_size[0], screen_size[1]))
my_board = Board(50, 50)
my_snake = Snake(50, 50)
# set up food and snake
food_loc = [my_board.food]
draw_surface(playSurface, redColour, [my_board.food], 10,
100) # draw first food
pygame.display.set_caption('Food Snake')
total_score = 0
score = 0
isEnd = False
while True:
# give AI input, and let AI control snake
dir = AI1(my_board, my_snake)
my_snake.turn(dir)
for event in pygame.event.get():
if event.type == pygame.QUIT:
quitHelper()
elif event.type == pygame.KEYDOWN:
if event.key == ord('q'):
isEnd = True
if event.key == pygame.K_ESCAPE:
pygame.event.post(pygame.event.Event(pygame.QUIT))
# increase along the moving direction
draw_surface(playSurface, blackColour, my_snake.get_cells(), 10, 100)
status = my_snake.tick(my_board.food, [])
my_snake.teleport_wall()
my_new_cells = my_snake.get_cells()
if my_snake.is_dead([]) or isEnd:
break
# When snake eats the food
if status == 1:
score += my_board.foodWeight
total_score += 1
my_board.new_food(my_new_cells, my_snake.obstacles, [])
food_loc = [my_board.food]
playSurface.fill(blackColour)
pygame.draw.polygon(playSurface, greenColour,
[[99, 99], [99, 601], [601, 601], [601, 99]], 1)
show_message(playSurface, 'Score: ' + str(total_score), whiteColour,
40, 10, 10)
screen.blit(avatar_image, (20, 615))
show_message(playSurface, player_name, whiteColour, 40, 100, 630)
draw_surface(playSurface, redColour, food_loc, 10, 100)
draw_surface(playSurface, greenColour, my_snake.obstacles, 10, 100)
draw_surface(playSurface, whiteColour, my_new_cells, 10, 100)
pygame.display.flip()
# speed is changeable
fpsClock.tick(my_snake.speed)
game_end(total_score)
def test_turn(self):
my_snake = Snake(20, 60)
self.assertEquals(my_snake.turn([-1, 0]), True)
self.assertEquals(my_snake.turn([0, -1]), False)
def duo_ai_mode(two_AI):
global player1_name, player2_name, avatar1_image, avatar2_image
init_name()
final_score1 = 0
player1_name = player_name
avatar1_image = avatar_image
addPlayerData(player_name)
# init_name()
final_score2 = 0
player2_name = player_name
avatar2_image = avatar_image
addPlayerData(player2_name)
screen_size = [700, 700]
pygame.init()
fpsClock = pygame.time.Clock()
# create pyGame screen
level = 1
playSurface = pygame.display.set_mode((screen_size[0], screen_size[1]))
my_board = Board(50, 50)
my_snake = Snake(50, 50)
op_snake = Snake(50, 50)
op_snake.obstacles = my_snake.obstacles
# set up food and snake
food_loc = [my_board.food]
draw_surface(playSurface, redColour, [my_board.food], 10,
100) # draw first food
pygame.display.set_caption('Food Snake')
total_score = 0
score = 0
isEnd = False
# check input and go as the direction
while True:
# give AI input, and let AI control snake
# o.w human VS AI
if two_AI:
dir = AI1(my_board, my_snake)
my_snake.turn(dir)
# op is pure AI
dir = AI12(my_board, op_snake)
op_snake.turn(dir)
# catch event and control snake
eventHelper(my_snake, True)
# increase along the moving direction
draw_surface(playSurface, blackColour, my_snake.get_cells(), 10, 100)
status1 = my_snake.tick(my_board.food, [])
my_snake.teleport_wall()
# increase along the moving direction
draw_surface(playSurface, blackColour, op_snake.get_cells(), 10, 100)
status2 = op_snake.tick(my_board.food, [])
op_snake.teleport_wall()
my_new_cells = my_snake.get_cells()
op_new_cells = op_snake.get_cells()
# two player mode
if my_snake.is_dead(op_new_cells) or op_snake.is_dead(
my_new_cells) or isEnd:
break
# if AI is dead
# if op_snake.is_dead(my_new_cells):
# score += 10
# op_snake = Snake(50, 50)
# op_snake.obstacles = my_snake.obstacles
# When my snake eats the food
if status1 == 1 or status2 == 1:
score += my_board.foodWeight
if status1 == 1:
final_score1 += 1
else:
final_score2 += 1
my_board.new_food(my_new_cells, my_snake.obstacles, op_new_cells)
food_loc = [my_board.food]
if score - level > level / 2:
level += 1
if level % 2 == 0:
my_snake.add_obstcles(level)
if level % 3 == 0:
my_snake.speed += 1
# update display
displayHelper(playSurface, fpsClock, level, food_loc, my_snake,
total_score, player1_name, 601, op_new_cells)
game_end(final_score1)
def single_ai_mode():
# set up local player data
addPlayerData(player_name)
screen_size = [700, 700]
pygame.init()
fpsClock = pygame.time.Clock()
# create pyGame screen
playSurface = pygame.display.set_mode((screen_size[0], screen_size[1]))
my_board = Board(50, 50)
my_snake = Snake(50, 50)
# set up food and snake
food_loc = [my_board.food]
draw_surface(playSurface, redColour, [my_board.food], 10,
100) # draw first food
pygame.display.set_caption('Food Snake')
total_score = 0
score = 0
level = 1
isEnd = False
while True:
# give AI input, and let AI control snake
dir = AI1(my_board, my_snake)
my_snake.turn(dir)
# catch event and control snake
eventHelper(my_snake, False)
# increase along the moving direction
draw_surface(playSurface, blackColour, my_snake.get_cells(), 10, 100)
status = my_snake.tick(my_board.food, [])
my_snake.teleport_wall()
my_new_cells = my_snake.get_cells()
if my_snake.is_dead([]) or isEnd:
break
# When snake eats the food
if status == 1:
score += my_board.foodWeight
total_score += 1
my_board.new_food(my_new_cells, my_snake.obstacles, [])
food_loc = [my_board.food]
if score - level > level / 2:
level += 1
if level % 2 == 0:
my_snake.add_obstcles(level)
if level % 3 == 0:
my_snake.speed += 1
displayHelper(playSurface, fpsClock, level, food_loc, my_snake,
total_score, player_name)
game_end(total_score)
def standard_mode():
# set up local player data
addPlayerData(player_name)
screen_size = [700, 700]
pygame.init()
fpsClock = pygame.time.Clock()
playSurface = pygame.display.set_mode((screen_size[0], screen_size[1]))
my_board = Board(50, 50)
my_snake = Snake(50, 50)
# set up food and snake
food_loc = [my_board.food]
worm_loc = []
draw_surface(playSurface, redColour, [my_board.food], 10,
100) # draw first food
pygame.display.set_caption('Food Snake')
total_score = 0
level = 1
score = 0
isEnd = False
while True:
# catch event and control snake
eventHelper(my_snake, True)
# increase along the moving direction
draw_surface(playSurface, blackColour, my_snake.get_cells(), 10, 100)
status = my_snake.tick(my_board.food, my_board.wormhole)
#if all snake body disappeared, go to next level!
if my_snake.get_cells() == []:
my_snake.cells = [[1, 1], [1, 2],
[1, 3]] # reassign snake's position!
level += 1
score = 0
if level == 2:
for i in range(20, 30, 1):
my_snake.obstacles.append([i, 25])
elif level == 3:
for i in range(20, 30, 1):
my_snake.obstacles.append([i, 15])
my_snake.obstacles.append([i, 35])
worm_loc = []
my_board.new_food(my_new_cells, my_snake.obstacles, [])
food_loc = [my_board.food]
my_snake.teleport_wall()
my_new_cells = my_snake.get_cells()
# ending condition
if my_snake.is_dead([]) or isEnd:
break
if status == 1:
score += my_board.foodWeight
total_score += 1
if score > 1:
my_board.new_wormhole(my_new_cells, my_snake.obstacles, [])
worm_loc = [my_board.wormhole]
food_loc = []
else:
my_board.new_food(my_new_cells, my_snake.obstacles, [])
food_loc = [my_board.food]
# update display each round
displayHelper(playSurface, fpsClock, level, food_loc, my_snake)
game_end(total_score)
def run_game():
"""
主程序负责执行游戏
"""
pygame.init()
# 实例化设置类
gm_setting = Settings()
# 初始化屏幕
screen = pygame.display.set_mode(
(gm_setting.screen_width, gm_setting.screen_height))
pygame.display.set_caption("Maze")
# 获取迷宫数组
maze = CreateMaze()
# 生成迷宫
maze.prim()
# 生成迷宫的答案
ans = PassageWay(gm_setting, maze.m)
ans.get_path()
ans.get_level()
# print("ans.level", ans.level)
# 实例化砖块,创建基本迷宫编组
bricks = Group()
gf.create_maze_group(screen, gm_setting, maze, bricks)
# 创建四个方向键
dir_button = DirectionButton(screen, gm_setting)
# 实例化一条蛇
snake = Snake(gm_setting)
# 实例化果实障碍
fruits = Fruits(maze, ans.path)
# print(fruits.pos)
# 设置响应长按键的时间间隔
pygame.key.set_repeat(100, 100)
# 实例化游戏状态
state = Gamestate(gm_setting)
# 实例化分数
score = ScoreBored(screen, gm_setting, state)
# 实例化等级面板
level = LevelBored(screen, gm_setting, ans.level)
# 实例化长度面板
lenBoard = LenBored(screen, gm_setting, len(snake.coordinate))
# 实例化排行榜
ranklist = RankList(screen, gm_setting)
# 实例化各种道具
ans_prop = AnsProp(screen, gm_setting, state)
# 实例化开始界面
start_page = StartActivity(screen, gm_setting)
# 实例化结束页面
end_page = EndActivity(screen, gm_setting)
# 实例化说明界面
description_page = DescriptionActivity(screen, gm_setting)
# 读取存档
gf.init(ranklist)
while True:
# 主循环
if state.gm_state == gm_setting.gm_welcome:
# 实例化欢迎界面并显示欢迎界面1秒
welcome_page = WelcomeActivity(screen, gm_setting)
welcome_page.show_page()
for event in pygame.event.get():
if event.type in [pygame.KEYDOWN, pygame.MOUSEBUTTONDOWN]:
state.gm_state = gm_setting.gm_wait
if event.type == pygame.QUIT:
sys.exit()
elif state.gm_state == gm_setting.gm_run:
# 进入游戏获取当前时间
state.gm_end_time = datetime.datetime.now()
ans.level = 0
ans.get_level()
level.update_level(ans.level)
# 更新分数
score.update_score(state)
# 更新长度
lenBoard.update_len(len(snake.coordinate))
# 响应事件
gf.check_events(screen, gm_setting, snake, maze, state, start_page,
end_page, ranklist, fruits, dir_button, ans_prop)
# 使蛇的尾部每隔10秒就自增一格
snake.tail_update(score.score, maze.m)
# 用操作后位置变换的蛇、通路、障碍果实来更新迷宫矩阵
gf.update_maze(gm_setting, maze, snake, bricks, state, fruits,
ans.path)
# 检查蛇头是否已经成功逃出迷宫,若成功逃脱则更新排行榜
gf.check_snake_out(screen, gm_setting, maze, snake, state,
ranklist, score)
# 更新屏幕
gf.update_screen(screen, gm_setting, bricks, dir_button, score,
ans_prop, level, lenBoard)
elif state.gm_state == gm_setting.gm_wait:
# 生成迷宫
maze.prim()
# 生成迷宫的答案
ans = PassageWay(gm_setting, maze.m)
ans.get_path()
ans.get_level()
fruits = Fruits(maze, ans.path)
snake.Flag_Score = []
# 响应事件
gf.check_events(screen, gm_setting, snake, maze, state, start_page,
end_page, ranklist, fruits)
start_page.show_page()
elif state.gm_state == gm_setting.gm_end:
snake.Flag_Score = []
# 响应事件
gf.check_events(screen, gm_setting, snake, maze, state, start_page,
end_page, ranklist, fruits)
end_page.show_page()
elif state.gm_state == gm_setting.gm_rank:
# 响应事件
gf.check_events(screen, gm_setting, snake, maze, state, start_page,
end_page, ranklist)
ranklist.show_page()
elif state.gm_state == gm_setting.gm_descr:
# 响应事件
gf.check_events(screen, gm_setting, snake, maze, state, start_page,
end_page, ranklist, fruits)
description_page.show_page()
class State:
LEFT = [-1, 0]
RIGHT = [1, 0]
UP = [0, -1]
DOWN = [0, 1]
# clock-wise
DIRS = [UP, RIGHT, DOWN, LEFT]
len = 20
scale = 4
scale_num = int(len / scale) #5
tile_n = scale_num * scale_num
# snake head * tail * food * direction
# 25*25*16*4+1
total_state_num = 9 * 9 * 9 * 9 * 4 + 1
# 3 actions keep, turn right, turn left
turn = 0
def __init__(self):
self.snake = Snake(self.len, self.len)
self.board = Board(self.len, self.len)
def get_index(self):
tile_n = self.tile_n
scale_num = self.scale_num
scale = self.scale
# 0 - 19
# 0,1,2,3,4
self.head_x = self.snake.cells[-1][0] // 4
self.head_y = self.snake.cells[-1][1] // 4
self.tail_x = self.snake.cells[0][0] // 4
self.tail_y = self.snake.cells[0][1] // 4
self.food_x = self.board.food[0] // 4
self.food_y = self.board.food[1] // 4
# -4321, 0 , 1234
self.diff_x = int(self.head_x - self.food_x + 4)
self.diff_y = int(self.head_y - self.food_y + 4)
self.ht_x = int(self.head_x - self.tail_x + 4)
self.ht_y = int(self.head_y - self.tail_y + 4)
size = scale_num * 2
self.dir = self.snake.direction
if self.snake.is_dead():
index = self.total_state_num - 1
else:
index = int( self.diff_x + 9*self.diff_y +\
self.ht_x*9*9+ self.ht_y*9*9*9 +\
#self.head_x + size*self.head_y + \
#tile_n*self.food_x + tile_n*size*self.food_y + \
#tile_n*tile_n*self.tail_x + tile_n*tile_n*size*self.tail_y +\
self.DIRS.index(self.dir)*9*9*9*9 )
return index
def turn_right(self):
index = self.DIRS.index(self.dir)
self.dir = self.DIRS[(index + 1) % 4]
self.snake.turn(self.dir)
def turn_left(self):
index = self.DIRS.index(self.dir)
self.dir = self.DIRS[(index - 1) % 4]
self.snake.turn(self.dir)
def move_get_rewards(self):
# return 0 if nothing happen
# return 1 if got food
self.turn += 1
self.snake.teleport_wall()
reward = self.snake.tick(self.board.food, None)
if reward == 0:
reward = -1 / (self.len * 2) # negative if in loop
elif reward == 1:
self.board.new_food(self.snake.obstacles, [])
if self.snake.is_dead():
reward = -1
return reward
def standard_mode():
# set up local player data
addPlayerData(player_name)
screen_size = [700, 700]
pygame.init()
fpsClock = pygame.time.Clock()
playSurface = pygame.display.set_mode((screen_size[0], screen_size[1]))
my_board = Board(50, 50)
my_snake = Snake(50, 50)
# set up food and snake
food_loc = [my_board.food]
worm_loc = []
draw_surface(playSurface, redColour, [my_board.food], 10,
100) # draw first food
pygame.display.set_caption('Food Snake')
total_score = 0
level = 1
score = 0
isEnd = False
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
quitHelper()
elif event.type == pygame.KEYDOWN:
# determine the event of keyBoard
if event.key == pygame.K_RIGHT or event.key == ord('d'):
my_snake.turn(RIGHT)
if event.key == pygame.K_LEFT or event.key == ord('a'):
my_snake.turn(LEFT)
if event.key == pygame.K_UP or event.key == ord('w'):
my_snake.turn(UP)
if event.key == pygame.K_DOWN or event.key == ord('s'):
my_snake.turn(DOWN)
if event.key == ord('q'):
isEnd = True
if event.key == pygame.K_ESCAPE:
pygame.event.post(pygame.event.Event(pygame.QUIT))
# increase along the moving direction
draw_surface(playSurface, blackColour, my_snake.get_cells(), 10, 100)
status = my_snake.tick(my_board.food, my_board.wormhole)
#if all snake body disappeared, go to next level!
if my_snake.get_cells() == []:
my_snake.cells = [[1, 1], [1, 2],
[1, 3]] # reassign snake's position!
level += 1
score = 0
if level == 2:
for i in range(20, 30, 1):
my_snake.obstacles.append([i, 25])
elif level == 3:
for i in range(20, 30, 1):
my_snake.obstacles.append([i, 15])
my_snake.obstacles.append([i, 35])
worm_loc = []
my_board.new_food(my_new_cells, my_snake.obstacles, [])
food_loc = [my_board.food]
my_snake.teleport_wall()
my_new_cells = my_snake.get_cells()
if my_snake.is_dead([]) or isEnd:
break
if status == 1:
score += my_board.foodWeight
total_score += 1
if score > 1:
my_board.new_wormhole(my_new_cells, my_snake.obstacles, [])
worm_loc = [my_board.wormhole]
food_loc = []
else:
my_board.new_food(my_new_cells, my_snake.obstacles, [])
food_loc = [my_board.food]
playSurface.fill(blackColour)
pygame.draw.polygon(playSurface, greenColour,
[[99, 99], [99, 601], [601, 601], [601, 99]], 1)
show_message(playSurface, 'Score: ' + str(total_score), whiteColour,
40, 10, 10)
show_message(playSurface, 'Level: ' + str(level), whiteColour, 40, 10,
50)
screen.blit(avatar_image, (20, 615))
show_message(playSurface, player_name, whiteColour, 40, 100, 630)
draw_surface(playSurface, redColour, food_loc, 10, 100)
draw_surface(playSurface, yellowColour, worm_loc, 10, 100)
draw_surface(playSurface, greenColour, my_snake.obstacles, 10, 100)
draw_surface(playSurface, whiteColour, my_new_cells, 10, 100)
pygame.display.flip()
# speed is changeable
fpsClock.tick(my_snake.speed)
game_end(total_score)
def test_get_cells(self):
my_snake = Snake(20, 60)
self.assertEquals(my_snake.cells, my_snake.get_cells())
def duo_ai_mode():
global player1_name, player2_name, avatar1_image, avatar2_image
init_name()
final_score1 = 0
player1_name = player_name
avatar1_image = avatar_image
addPlayerData(player_name)
init_name()
final_score2 = 0
player2_name = player_name
avatar2_image = avatar_image
addPlayerData(player2_name)
screen_size = [700, 700]
pygame.init()
fpsClock = pygame.time.Clock()
# create pyGame screen
level = 1
playSurface = pygame.display.set_mode((screen_size[0], screen_size[1]))
my_board = Board(50, 50)
my_snake = Snake(50, 50)
op_snake = Snake(50, 50)
op_snake.obstacles = my_snake.obstacles
# set up food and snake
food_loc = [my_board.food]
draw_surface(playSurface, redColour, [my_board.food], 10,
100) # draw first food
pygame.display.set_caption('Food Snake')
total_score = 0
score = 0
isEnd = False
# check input and go as the direction
while True:
# give AI input, and let AI control snake
dir = AI1(my_board, my_snake)
my_snake.turn(dir)
# op is pure AI
dir = AI12(my_board, op_snake)
op_snake.turn(dir)
for event in pygame.event.get():
if event.type == pygame.QUIT:
quitHelper()
elif event.type == pygame.KEYDOWN:
# determine the event of keyBoard
if event.key == pygame.K_RIGHT or event.key == ord('d'):
my_snake.turn(RIGHT)
if event.key == pygame.K_LEFT or event.key == ord('a'):
my_snake.turn(LEFT)
if event.key == pygame.K_UP or event.key == ord('w'):
my_snake.turn(UP)
if event.key == pygame.K_DOWN or event.key == ord('s'):
my_snake.turn(DOWN)
if event.key == ord('q'):
isEnd = True
if event.key == pygame.K_ESCAPE:
pygame.event.post(pygame.event.Event(pygame.QUIT))
# increase along the moving direction
draw_surface(playSurface, blackColour, my_snake.get_cells(), 10, 100)
status1 = my_snake.tick(my_board.food, [])
my_snake.teleport_wall()
# increase along the moving direction
draw_surface(playSurface, blackColour, op_snake.get_cells(), 10, 100)
status2 = op_snake.tick(my_board.food, [])
op_snake.teleport_wall()
my_new_cells = my_snake.get_cells()
op_new_cells = op_snake.get_cells()
if my_snake.is_dead(op_new_cells) or op_snake.is_dead(
my_new_cells) or isEnd:
break
# When my snake eats the food
if status1 == 1 or status2 == 1:
score += my_board.foodWeight
if status1 == 1:
final_score1 += 1
else:
final_score2 += 1
my_board.new_food(my_new_cells, my_snake.obstacles, op_new_cells)
food_loc = [my_board.food]
if score - level > level / 2:
level += 1
if level % 2 == 0:
my_snake.add_obstcles(level)
if level % 3 == 0:
my_snake.speed += 1
playSurface.fill(blackColour)
pygame.draw.polygon(playSurface, greenColour,
[[99, 99], [99, 601], [601, 601], [601, 99]], 1)
show_message(playSurface, 'Score: ' + str(total_score), whiteColour,
40, 10, 10)
show_message(playSurface, 'Level: ' + str(level), whiteColour, 40, 10,
50)
screen.blit(avatar1_image, (20, 615))
show_message(playSurface, player1_name, whiteColour, 40, 100, 630)
screen.blit(avatar2_image, (20, 650))
show_message(playSurface, player2_name, whiteColour, 40, 100, 665)
draw_surface(playSurface, redColour, food_loc, 10, 100)
draw_surface(playSurface, greenColour, my_snake.obstacles, 10, 100)
draw_surface(playSurface, whiteColour, my_new_cells, 10, 100)
draw_surface(playSurface, greyColour, op_new_cells, 10, 100)
pygame.display.flip()
# speed is changeable
fpsClock.tick(my_snake.speed)
game_end(final_score1, final_score2)
class State:
turn = 0
LEFT = [-1, 0]
RIGHT = [1, 0]
UP = [0, -1]
DOWN = [0, 1]
# clock-wise
DIRS = [UP,RIGHT,DOWN,LEFT]
len = 20
tile_n = 400
# snake head * tail * food * direction
# 400*4*4+1
total_state_num = tile_n*4 * 4 + 1
# 3 actions keep, turn right, turn left
def __init__(self):
self.snake = Snake(self.len, self.len)
self.board = Board(self.len, self.len)
def get_index(self):
size = self.len
tile_n = self.tile_n
self.head_x = self.snake.cells[-1][0]
self.head_y = self.snake.cells[-1][1]
self.tail_x = self.snake.cells[0][0]
self.tail_y = self.snake.cells[0][1]
self.food_x = self.board.food[0]
self.food_y = self.board.food[1]
self.diff_x = self.head_x-self.food_x+size
self.diff_y = self.head_y-self.food_y+size
self.ht_x = self.head_x-self.tail_x
self.ht_y = self.head_y-self.tail_y
self.dir = self.snake.direction
if self.snake.is_dead():
index = self.total_state_num - 1
else:
index = int( self.diff_x + size*2*self.diff_y +\
#self.head_x + size*self.head_y + \
#tile_n*self.food_x + tile_n*size*self.food_y + \
#tile_n*tile_n*self.tail_x + tile_n*tile_n*size*self.tail_y +\
# self.ht_x*tile_n*4*4 + tile_n*4*4*size * 2 * self.ht_y
self.DIRS.index(self.dir)*tile_n*4 )
return index
def turn_right(self):
index = self.DIRS.index(self.dir)
self.dir = self.DIRS[(index+1)%4]
self.snake.turn(self.dir)
def turn_left(self):
index = self.DIRS.index(self.dir)
self.dir = self.DIRS[(index - 1) % 4]
self.snake.turn(self.dir)
def move_get_rewards(self):
# return 0 if nothing happen
# return 1 if got food
self.snake.teleport_wall()
reward = self.snake.tick(self.board.food,None)
if reward == 0:
reward = - 1 / self.len*2 # negative if in loop
elif reward == 1:
self.board.new_food(self.snake.obstacles,[])
if self.snake.is_dead():
reward = -1
return reward
