def AddData():
EntData = DataEntry.get()
if EntData == "snake":
DataEntry.delete(0, END)
snake.snake(Graph)
return 0
elif EntData.lower() == "chuck norris":
EntData = "42"
DataArr = EntData.split(',')
for x in range(0, len(DataArr)):
DataArr[x] = float(DataArr[x])
List = ListChooseVar.get()
if List == "L1":
for Data in DataArr:
L1.append(Data)
listOne.insert(END, Data)
listOne.see(END)
summRecalc("L1")
if GraphDrawn[2] == "L1":
GraphDrawn[1].reDraw(L1)
elif GraphDrawn[2] == "BOTH":
GraphDrawn[1].reDraw(L1, L2)
else:
for Data in DataArr:
L2.append(Data)
listTwo.insert(END, Data)
listTwo.see(END)
summRecalc("L2")
if GraphDrawn[2] == "L2":
GraphDrawn[1].reDraw(L2)
elif GraphDrawn[2] == "BOTH":
GraphDrawn[1].reDraw(L1, L2)
DataEntry.delete(0, END)
def test_sort_generation(): test_gen = [] for i in range(10): test_gen.append(snake.snake()) test_gen[-1].fitness = np.random.randint(0, 10) test_gen = ga.sort_generation(test_gen) assert all(test_gen[i].fitness >= test_gen[i+1].fitness for i in range(len(test_gen)-1))
def generateSnakes(self, newGen=[]):
if self.gen == 1:
return [
snake(None, randomColor(), self.randomDirection())
for i in range(self.genSize)
]
else:
if self.gen > 100:
for snek in newGen:
snek.sinceFoodCap = 2500
return newGen
def main():
h, w = terminal_size()
h *= 2 # Using gImage Glyphs
background = gImage(w, h, background=0b000)
for y in range(h):
for x in [0, w-1]:
background.paint_pixel(y, x, 0b101)
for x in range(w):
for y in [0, h-1]:
background.paint_pixel(y, x, 0b101)
gim = gImage(0, 0).pasteImage(0, 0, Image.open(HERE / "mario.bmp"))
gim.paint(h-gim.height-1, 1)
#gImage(0, 0).pasteImage(0, 0, Image.open(HERE / "lars.bmp")).paint(2, 2)
gImage(0, 0).pasteImage(0, 0, Image.open(HERE / "penrose.bmp")).paint(2, 2)
#input("")
from snake import snake
snake()
def doTest(test, expected):
print("Starting test case %s" % str(test.__name__))
snake_under_test = snake.snake(False)
start_time = time.time()
try:
result = test(snake_under_test)
except:
result = sys.exc_info()[1]
if not result in expected:
print("TEST FAIL!: expected '%s' Got: '%s'" % (expected, result))
else:
print("TEST PASS! Elapsed time: %f milliseconds" % ((time.time() - start_time) * 1000))
def add_snake(self, ext_snake=None):
if ext_snake == None:
self.snake = snake.snake()
else:
if not isinstance(ext_snake, snake.snake):
raise TypeError("Expected a snake, received a " +
type(ext_snake).__name__)
self.snake = ext_snake
# initialize position
self.snake.position = np.random.randint(0, self.size, 2)
self.snake.occupied.insert(0, self.snake.position.copy())
def test_create_generation(fixture_neural_network): test_gen = [] for i in range(10): test_gen.append(snake.snake((fixture_neural_network))) test_gen[-1].fitness = np.random.randint(0, 10) new_gen = ga.create_generation(test_gen) for sn in new_gen: assert isinstance(sn, snake.snake) assert len(test_gen) == len(new_gen) assert sn.neural_network.shape == fixture_neural_network.shape
def breed(self, a, b):
babyColor = (((a.col[0] + b.col[0]) / 2) +
random(-1 * self.mutationDelta, self.mutationDelta),
((a.col[1] + b.col[1]) / 2) +
random(-1 * self.mutationDelta, self.mutationDelta),
((a.col[2] + b.col[2]) / 2) +
random(-1 * self.mutationDelta, self.mutationDelta))
babyNN = a.nn.createCopy()
babyNN.weights_i = self.breedWeights(a.nn.weights_i, b.nn.weights_i)
babyNN.weights_h = self.breedWeights(a.nn.weights_h, b.nn.weights_h)
babyNN.bias_i = self.breedWeights(a.nn.bias_i, b.nn.bias_i)
babyNN.bias_h = self.breedWeights(a.nn.bias_h, b.nn.bias_h)
return snake(babyNN, babyColor, self.randomDirection())
def addSnake():
global snakeCount, newMemberName, newMemberSnakes
print("Add a snake to " + newMemberName + "'s list")
snakeName = raw_input("Snake name: ")
snakeType = raw_input("Snake type: ")
if snakeType == "Mamba":
print("WARNING: The snake is very toxic!")
if snakeType == "Anaconda":
print("INFO: The snake is protected and cannot be added!")
return
snakeCount = snakeCount + 1
theSnake = snake(snakeCount, snakeName, snakeType)
newMemberSnakes.append(theSnake)
def supervised_superfun(X1, y, epochs, n, N = 50):
X = np.zeros((len(X1), X1[0].shape[0], X1[0].shape[1], 3))
X[X1 == 1, 0] = 1
X[X1 == 2, 1] = 1
X[X1 == -1, 2] = 1
size = np.shape(X[0])
optimizer = keras.optimizers.Adam(lr=1e-2)
#create model
model = Sequential()
#add model layers
model.add(Conv2D(64, kernel_size = (3, 3), activation = 'relu', input_shape = size))
model.add(Flatten())
model.add(Dense(4, activation = 'softmax'))
model.compile(optimizer = optimizer, loss = 'categorical_crossentropy', metrics = ['accuracy'])
model.fit(X, y, validation_data = (X, y), epochs = epochs, shuffle= True, verbose = 0)
predicts = model.predict(X)
print('Accuracy: ', np.mean((np.argmax(predicts, axis = 1) == np.argmax(y, axis = 1))))
game_score = []
game_score = np.zeros(N)
for i in range(N):
game_go_on = 1
game = snake(n, n)
X1 = game.board_call()
board = board_3D(X1)
counter = 0
score = 0
while game_go_on == 1:
counter += 1
pred = model.predict(board)[0]
direction = np.argmax(pred)
game_go_on = game.move(direction)
X1 = game.board_call()
board = board_3D(X1)
if game.score > score:
score = game.score
counter = 0
if counter > n*n:
print('Tolerance limit, run: ', i)
break
game_score[i] = game.score
print(game_score)
def evaluate(chromosome, arch=[], N=20, display=False, sleep=None, avg=10):
network = Network(chromosome, relu, arch)
def get_move(position, N):
rays = snake.wall_ray(position, N) + snake.snake_ray(
position, N) + snake.apple_ray(position, N)
probs = network.forward(rays)
# print(probs)
# return probs.index(max(probs))
return np.random.choice(
[i for i, x in enumerate(probs) if x == max(probs)])
score = 0
for i in range(avg):
score += snake.snake(N, get_move, -100, display, sleep=sleep)
return score / avg
def generate_children(parents, no_of_children):
all_children = []
l = len(parents)
for count in range(no_of_children):
parent1 = random.choice(parents)
parent2 = random.choice(parents)
child = snake.snake(width, height, brainLayer, block_length)
for i in range(len(parent1.Brain.weights)):
for j in range(parent1.Brain.weights[i].shape[0]):
for k in range(parent1.Brain.weights[i].shape[1]):
child.Brain.weights[i][j, k] = random.choice(
[parent1.Brain.weights[i][j, k], parent2.Brain.weights[i][j, k]])
for j in range(parent1.Brain.bases[i].shape[1]):
child.Brain.bases[i][0, j] = random.choice(
[parent1.Brain.bases[i][0, j], parent2.Brain.bases[i][0, j]])
all_children.append(child)
return all_children
def build_network_1DNN(self):
"""
Building the CNN
"""
self.CNN = False
optimizer = keras.optimizers.Adam(lr=self.lr) #lr = 1e-3 works good
#Define size
game = snake(self.n, self.n)
size = np.shape(np.ravel(game.board_call()))
self.model = Sequential()
self.model.add(Dense(1024, activation='relu'))
#self.model.add(Dense(16, activation = 'relu'))
self.model.add(Dense(4, activation='linear'))
self.model.compile(optimizer=optimizer,
loss='mse',
metrics=['accuracy'])
def main(argv):
global width, rows, s, snack, scores
width = 500
scores = []
rows = 20
win = pygame.display.set_mode((width, width))
s = snake((255, 0, 0), (10, 10))
snack = cube(randomSnack(rows, s), color=(0, 255, 0))
flag = True
redrawWindow(win)
clock = pygame.time.Clock()
count = 0
while flag and count < 50:
pygame.time.delay(10)
clock.tick(10)
s.move_with_mode(argv[0], snack)
if s.body[0].pos == snack.pos:
s.add_cube()
snack = cube(randomSnack(rows, s), color=(0, 255, 0))
# Lose from collision with wall
if ((s.body[0].pos[0] == -1) or (s.body[0].pos[0] == rows)
or (s.body[0].pos[1] == -1) or (s.body[0].pos[1] == rows)):
game_over(s, argv)
count = count + 1
# Lose by collision with body
for x in range(len(s.body)):
if s.body[x].pos in list(map(lambda z: z.pos, s.body[x + 1:])):
game_over(s, argv)
count = count + 1
break
redrawWindow(win)
# Save Score results to an outfile
with open(
argv[0] + datetime.datetime.today().strftime('%d-%m-%Y') + '.txt',
'w') as f:
for listitem in scores:
f.write('%s\n' % listitem)
def main():
# command line argument parser
ap = argparse.ArgumentParser()
ap.add_argument('-o', '--output', required=True, help='relative path to save the snakes')
args = vars(ap.parse_args())
snakes = [snake.snake(width, height, brainLayer, block_length) for _ in range(population_size)]
arena = Arena(width, height, block_length)
top_snakes = []
for i in range(no_of_generations):
print('generation : ', i+1, ',', end='\n')
run(snakes, arena)
# sorting the population wrt length of snake and steps taken
snakes.sort(key=lambda x: (len(x.list), -x.steps_taken), reverse=True)
print_top_5(snakes[0:5])
# generalising the whole population
print('saving the snake')
top_snakes.append(snakes[0])
# saving top snakes list as pickle
save_top_snakes(top_snakes, args['output'])
snakes = create_new_population(snakes)
def __init__(self, width, height, framerate):
self.WIDTH = width
self.HEIGHT = height
self.FRAMERATE = framerate
self.root = tk.Tk()
self.CANVAS = tk.Canvas(self.root,
width=self.WIDTH,
height=self.HEIGHT)
self.CANVAS.pack()
self.CANVAS.bind_all('<Left>', self.left_key)
self.CANVAS.bind_all('<Right>', self.right_key)
self.CANVAS.bind_all('<Up>', self.up_key)
self.CANVAS.bind_all('<Down>', self.down_key)
self.pixel_size = 5
self.snake = snake.snake(self.CANVAS, self.WIDTH, self.HEIGHT,
self.pixel_size)
self.snake.place_snake()
self.food_postition = None
self.testing = None
self.place_food()
def test(model):
game_test = snake.snake()
end = False
move = 0
while not end:
current_food = game_test.food_location
state, _ = get_state(game_test.location_history,
game_test.food_location)
prediction = model.predict(state)[0]
action = np.argmax(prediction)
result = game_test.play(action)
print(f' {int(prediction[0]*1000)}')
print(f'{int(prediction[1]*1000)} {move} {int(prediction[3]*1000)}')
print(f' {int(prediction[2]*1000)}')
game_test.print_board()
if current_food != game_test.food_location:
move = 0
else:
move += 1
if result == 'invalid' or move > 50:
end = True
def sanke_grows(self):
position = []
last_snake_position = self.snake_list[-1].getPosition()
last_sanke_dir = self.snake_list[-1].getDirection()
last_snake_pos = [last_snake_position[0],last_snake_position[1]]
#新建一段蛇
if last_sanke_dir == 'up':
position = [last_snake_pos[0],last_snake_pos[1]+self.cube_size]
if last_sanke_dir == 'down':
position = [last_snake_pos[0],last_snake_pos[1]-self.cube_size]
if last_sanke_dir == 'left':
position = [last_snake_pos[0]+self.cube_size,last_snake_pos[1]]
if last_sanke_dir == 'right':
position = [last_snake_pos[0]-self.cube_size,last_snake_pos[1]]
#给新的蛇加上turn属性
newSnake = Snk.snake(self.screen, [self.snake_list[-1].getColor()[0]-self.n,self.snake_list[-1].getColor()[1]-self.n,self.snake_list[-1].getColor()[2]-self.n], position, last_sanke_dir,self.cube_size)
if self.snake_list[-1].getTurns() != []:
for turn in self.snake_list[-1].getTurns():
newSnake.setTurns(turn)
# print(self.snake_list[-1].getTurns())
self.snake_list.append(newSnake)
def __initGame(self):
#initialize game variables (used for looping)
self._apples = []
self._applesToSpawn = self.maxApples
#set-up screen
self.__resetScreen(self._screen)
self._screen.register_shape("apple.gif")
#register keystrokes
self._player = snake()
self._screen.onkey(self.__queueUp, "Up")
self._screen.onkey(self.__queueDown, "Down")
self._screen.onkey(self.__queueLeft, "Left")
self._screen.onkey(self.__queueRight, "Right")
#generate apples and score tracking
self.__generateApples()
self._totalScore = score()
#begin game
self.__gameloop()
def loadProfile(self):
if not os.path.exists('SnakeTamer/' + self.userID + '.snaketamer'):
if not os.path.exists('SnakeTamer'):
os.mkdir("SnakeTamer")
# if there was no profile found create one
self.saveProfile(1)
else:
f = open("SnakeTamer/" + self.userID + ".snaketamer", "r")
if f.mode == 'r':
content = json.loads(f.read())
self.last_action = content["last_action"]
for sn in content["snakes"]:
self.snakes.append(
snake(str(sn["name"]), int(sn["level"]),
int(sn["health"]), int(sn["hunger"]),
int(sn["happiness"]), int(sn["last_eaten"]),
int(sn["last_levelUp"])))
else:
print("Profil konnte nicht geladen werden.")
return
def get_event(location_history, food_location):
possible_actions = 4
events = []
state, _ = get_state(location_history, food_location)
game_e = snake.snake()
for action in range(possible_actions):
game_e.location_history = location_history[:]
game_e.food_location = food_location
game_e.snake_length = max(len(location_history), 3)
result = game_e.play(action)
reward = get_reward(result)
if reward == -1:
done = True
events.append([None, action, reward, None, done])
else:
next_state, _ = get_state(game_e.location_history,
game_e.food_location)
done = False
events.append([None, action, reward, next_state[:], done])
events[0][0] = state
return events
def __init__(self, frametime, playmode):
#how long each frame is
self.SPEED = frametime
#game mode 1=human 2=ai
self.mode = playmode
self.s = snake.snake()
self.root = Tk()
self.rootFrame = Frame(self.root, width=500, height=50, bg="white")
self.rootFrame.pack()
self.score = StringVar()
self.score.set("Score: " +
str(self.s.get_score_alive() + self.s.get_score_eat()))
self.scoreLabel = Label(self.rootFrame, textvariable=self.score).pack()
self.canvas = Canvas(self.root, width=500, height=500, bg="gray")
self.canvas.pack()
self.root.bind('a', self.left)
self.root.bind('d', self.right)
self.root.bind('<Left>', self.left)
self.root.bind('<Right>', self.right)
self.canvas.bind('<Configure>', self.create_grid)
restore_bullet = 0
# OTHER LOCAL GAME VARIABLES
isdead = 'Alive'
gravity_counter = 0
# COUNT
global_stuff.COUNT = 0
global_stuff.REMAINING_NO = global_stuff.MAXIMUM_NO
down_move = -1
last_left_shift_count = 0
# SNEK CHECK
if(global_stuff.snek == 1):
(hx, hy) = h.get_coord()
h = snake(hx, hy)
# GAME LOOP
while(1):
# INCREASE THE COUNT AND DECREASE THE REMAINING NO
global_stuff.COUNT += 1
global_stuff.REMAINING_NO -= 1
last_left_shift_count += 1
# DISPLAY THE BOARD, HERO, BULLETS AND ENEMY(if applicable)
term.next_play()
board.print(h, e)
h.print_direct()
if(global_stuff.enemy_come == 1):
e.print_direct()
e.follow(h) # make the enemy follow our hero
screen = pg.display.set_mode(((WIDTH+2)*snk.BLOCK_SIZE,(HEIGHT+2)*snk.BLOCK_SIZE))
pg.display.set_caption("snake")
font = pg.font.SysFont(pg.font.get_default_font(),40)
gameovertext = font.render("GAME OVER",1,WHITE)
starttext = font.render("PRESS ANY KEY TO START",1,WHITE)
screen.fill(BLACK)
def play_music(name, delay):
while pg.mixer.music.get_busy():
pg.event.poll()
clock.tick(10)
try:
thread.start_new_thread( play_music, ("Thread-1", 2, ) )
except:
print "Error: unable to start thread"
# we need a snake and something to eat
snake = snk.snake(screen,WIDTH/2,HEIGHT/2) #coordinates where the first snake starts
snake2 = snk.snake(screen, WIDTH/2+5, HEIGHT/2, GOLD, YELLOW) #coordinates where the second snake starts
food = fd.food(screen,1,HEIGHT+1,1,WIDTH+1)
# food should not appear where the snake is
while food.getPos() in snake.getPosList():
food.__init__(screen,1,HEIGHT+1,1,WIDTH+1)
# only queue quit and and keydown events
# pg.event.set_allowed([pg.QUIT,pg.KEYDOWN])
pg.event.set_blocked([pg.MOUSEMOTION,pg.MOUSEBUTTONUP,pg.MOUSEBUTTONDOWN])
# will increase game speed every 10 times we eat
eaten = 0
from tkinter import *
from tkinter import messagebox
from snake import snake
# tkinter window
root = Tk()
# snake grid variables
board_size = 400
cell_size = board_size/10
isRunning = False
# changes how much faster snake moves as it gets larger
snake_speed_multiplier = 100
s = snake()
# save the starting length of the snake for later
start_len = s.snake_len
board = Canvas(root, height=board_size + 2, width=board_size + 3)
board.pack()
def draw_snake():
for row in range(len(s.grid)):
for col in range(len(s.grid[row])):
# http://www.science.smith.edu/dftwiki/index.php/File:TkInterColorCharts.png
if s.grid[row][col] < 0: # apple
color = 'red'
elif s.grid[row][col] > 0: # snake
#check if tile is the head of the snake
if (row,col) == tuple(s.snake_pos):
color = 'green4'
else:
import pygame
from snake import snake
from snack import snack
import time
import random
import variables
# <--- pygame init settings --->
pygame.init()
display = pygame.display.set_mode(
(variables.screenWidth, variables.screenHeight))
pygame.display.set_caption('Snake')
snakeMgr = snake()
snackMgr = snack()
font = pygame.font.SysFont("monospace", 20)
resetMsg = font.render("Game over - press R to reset", 1, variables.text_color)
# <------>
# <--- Create snake and snack --->
snakeMgr.new_part(
variables.size *
random.randint(2, variables.screenWidth / variables.size - 2),
variables.size *
random.randint(2, variables.screenHeight / variables.size - 2))
snackMgr.new_snack(snakeMgr.body)
# <------>
# <--- Game loop, will execute until player quits the game with ESC key --->
while not snakeMgr.player_exit:
for event in pygame.event.get():
snakeMgr.steering(event, snackMgr)
def __init__(self): self.player = snake(screen_width/2, screen_height/2) self.apples = [] for i in range(number_of_apples): self.apples.append(apple())
import snake as sn
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
# Box parameters:
rows = 10
cols = 10
start_position = (0, 0)
plot_positions, num_of_moves, num_of_steps = sn.snake(rows,
cols,
position=start_position)
print("\nNumber of moves: ", num_of_moves)
print("Number of steps: ", num_of_steps)
with plt.style.context('ggplot'):
fig, ax = plt.subplots()
ax.yaxis.set_major_locator(plt.NullLocator())
ax.xaxis.set_major_formatter(plt.NullFormatter())
ax.set(xlim=(-1, rows + 1), ylim=(-1, cols + 1))
line, = ax.plot([], [], color='red', linewidth=6)
# ======== Animation ===================================
def line_coordinates(coordinates=()):
# changes plot positions into line coordinates
def snake_game():
xpos = random.randrange(10, WIN_WIDTH - WIDTH, WIDTH)
ypos = random.randrange(10, WIN_HEIGHT - HEIGHT, HEIGHT)
xvel = 0
yvel = 0
sn = snake(xpos, ypos)
food = placeFood()
temp = deepcopy(sn)
# print(id(sn.body[0].xpos))
# print(id(temp.body[0].xpos))
game_over = False
run = True
while run:
dt = clock.tick(FPS) / 1000
temp = deepcopy(sn)
win.fill((0, 0, 0))
for i in range(len(sn.body)):
print(
str(i) + " \t X: " + str(sn.body[i].xpos) + " \t\t Y: " +
str(sn.body[i].ypos) + " \t TEMP: X: " +
str(temp.body[i].xpos) + " \t\t Y: " + str(temp.body[i].ypos))
for event in pg.event.get():
if event.type == pg.QUIT:
pg.quit()
sys.exit()
if event.type == pg.KEYDOWN:
if event.key == pg.K_ESCAPE:
run = False
main()
keys = getKeys()
##------------------------For TESTING--------------------##
##
if keys[pg.K_LSHIFT]:
sn.addBody(sn.body[0].xpos + WIDTH, sn.body[0].ypos)
if keys[pg.K_TAB]:
# auch der Head wird deleted ^^
sn.deleteBody()
##--------------------------------------------------------##
if keys[pg.K_UP] and yvel == 0:
yvel = -HEIGHT
xvel = 0
if keys[pg.K_DOWN] and yvel == 0:
yvel = HEIGHT
xvel = 0
if keys[pg.K_LEFT] and xvel == 0:
xvel = -WIDTH
yvel = 0
if keys[pg.K_RIGHT] and xvel == 0:
xvel = WIDTH
yvel = 0
# check if snake run into itself
for i in range(len(sn.body) - 1):
if sn.body[0].xpos == sn.body[
i + 1].xpos and sn.body[0].ypos == sn.body[i + 1].ypos:
game_over = True
# check if snake run into the border
if sn.body[0].xpos < 0 or sn.body[0].xpos > (
WIN_WIDTH - WIDTH
) or sn.body[0].ypos < 0 or sn.body[0].ypos > (WIN_HEIGHT - HEIGHT):
game_over = True
if game_over:
print("GAME OVER!")
xpos = 50
ypos = 50
xvel = 0
yvel = HEIGHT
food = placeFood()
print(food.xpos, food.ypos)
for i in range(len(sn.body) - 1):
sn.deleteBody()
sn = snake(xpos, ypos)
game_over = False
death_screen()
#run = False
# exit()
else:
if sn.body[0].xpos == food.xpos and sn.body[0].ypos == food.ypos:
food = placeFood()
sn.addBody(sn.body[0].xpos + WIDTH, sn.body[0].ypos)
if xvel != 0:
xpos += xvel
if yvel != 0:
ypos += yvel
sn.body[0].xpos = xpos
sn.body[0].ypos = ypos
for i in range(len(sn.body) - 1):
sn.body[i + 1].xpos = temp.body[i].xpos
sn.body[i + 1].ypos = temp.body[i].ypos
for i in range(len(sn.body)):
pg.draw.rect(win, (255, 255, 255),
(sn.body[i].xpos + 1, sn.body[i].ypos + 1, WIDTH - 2,
HEIGHT - 2))
# damit der head eine andere Farbe hat
# if(i == 0):
# pg.draw.rect(win, (0, 0, 255),
# (sn.body[i].xpos, sn.body[i].ypos, WIDTH, HEIGHT))
# else:
# pg.draw.rect(win, (255, 255, 255),
# (sn.body[i].xpos, sn.body[i].ypos, WIDTH, HEIGHT))
# Draw Food
pg.draw.rect(win, (255, 0, 0), (food.xpos, food.ypos, WIDTH, HEIGHT))
draw_text("SCORE: " + str(len(sn.body)), font, (255, 255, 255), win,
20, 20)
pg.display.update()
pg.quit()
def __init__(self):
self.num_gen = 1
self.previous_generation = []
self.current_generation = []
for _ in range(settings.num_snakes_gen):
self.current_generation.append(s.snake())
import random
from snake import snake
from food import food
import pygame
import pygame.freetype
pygame.init()
myfont = pygame.freetype.SysFont("Arial", 20)
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("Snake")
snake = snake(screen)
food = food(screen)
food.spawn()
RUNNING = True
clock = pygame.time.Clock()
while RUNNING:
clock.tick(15)
screen.fill((255, 150, 255))
TEXT = "Score: " + str(snake.snake_length)
text_surface, rect = myfont.render(TEXT, (255, 255, 255))
screen.blit(text_surface, (10, 10))
for event in pygame.event.get():
pg.init()
pg.mixer.init()
eatsound = pg.mixer.Sound("snakeeat.wav")
crashsound = pg.mixer.Sound("snakecrash.wav")
clock = pg.time.Clock()
screen = pg.display.set_mode(
((WIDTH + 2) * snk.BLOCK_SIZE, (HEIGHT + 2) * snk.BLOCK_SIZE))
pg.display.set_caption("Snake")
font = pg.font.SysFont(pg.font.get_default_font(), 40)
gameovertext = font.render("GAME OVER", 1, WHITE)
starttext = font.render("PRESS ANY KEY TO START", 1, WHITE)
screen.fill(BLACK)
snake = snk.snake(screen, WIDTH // 2, HEIGHT // 2)
food = fd.food(screen, 1, HEIGHT + 1, 1, WIDTH + 1)
while food.getPos() in snake.getPosList():
food, __init__(screen, 1, WIDTH + 1, 1, HEIGHT + 1)
pg.event.set_blocked([pg.MOUSEMOTION, pg.MOUSEBUTTONUP, pg.MOUSEBUTTONDOWN])
eaten = 0
drawWalls(screen)
screen.blit(starttext,
((WIDTH - 10) * snk.BLOCK_SIZE / 2, HEIGHT * snk.BLOCK_SIZE / 2))
pg.display.flip()
waiting = True
while waiting:
display.refresh()
font.letter_S(25, 10, 0)
font.letter_N(20, 10, 0)
font.letter_A(15, 10, 0)
font.letter_K(10, 10, 0)
font.letter_E(5, 10, 0)
display.refresh()
game_loop = True
while game_loop:
pg.init()
clock = pg.time.Clock()
# we need a snake and something to eat
snake = snk.snake(WIDTH/2,HEIGHT/2) #coordinates where the first snake starts
snake2 = snk.snake(WIDTH/2+5, HEIGHT/2+5) #coordinates where the second snake starts
food = fd.food(0,1,HEIGHT+1,1,WIDTH+1)
# food should not appear where the snake is
while food.getPos() in snake.getPosList():
food.__init__(0,1,HEIGHT+1,1,WIDTH+1)
# will increase game speed every 10 times we eat
eaten = 0
def listenController2(name, delay):
global CONTROLLER2
dev = os.open("../../../dev/rfcomm1", os.O_RDONLY)
while True:
def startGame(multiPlayerMode=False):
global highScore
print("STARTING GAME in " + ("Multiplayer" if multiPlayerMode else "Singleplayer") + " Mode")
pg.init()
screen = pg.display.set_mode(((WIDTH+2)*blockUnit,(HEIGHT+2)*blockUnit))
pg.display.set_caption("FLPoly Snake")
font = pg.font.SysFont(pg.font.get_default_font(), 40)
scoreFont = pg.font.SysFont(pg.font.get_default_font(), 25)
starttext = font.render("PRESS ANY KEY TO START",1,black)
screen.fill(white)
snake = snk.snake(screen,WIDTH/4,HEIGHT/4)
object = obj.object(screen,1,HEIGHT+1,1,WIDTH+1)
snakeB = None
objectB = None
if multiPlayerMode:
snakeB = snk2.snake(screen,WIDTH/2,HEIGHT/2)
objectB = obj2.objectB(screen,1,HEIGHT+1,1,WIDTH+1)
#let's start
clock = pg.time.Clock()
boundBox(screen)
screen.blit(starttext,((WIDTH-10)*blockUnit/2,HEIGHT*blockUnit/2))
pg.display.flip()
waiting = True
while waiting:
event = pg.event.wait()
if event.type == pg.KEYDOWN:
waiting = False
while object.getPos() in snake.getPosList():
object.__init__(screen,1,HEIGHT+1,1,WIDTH+1)
if multiPlayerMode:
while objectB.getPos() in snakeB.getPosList():
objectB.__init__(screen,1,HEIGHT+1,1,WIDTH+1)
running = True
while running:
# Check if a snake has collided with a wall or is out of bounds
if not onScreen(snake) or snake.chrashed() or (multiPlayerMode and (not onScreen(snakeB) or snakeB.chrashed())):
running = False
pg.quit()
print("GAME OVER!")
purpleSnakeScore = snake.length - 10
if multiPlayerMode:
orangeSnakeScore = snakeB.length - 10
if purpleSnakeScore > orangeSnakeScore:
print("Purple Snake Wins! Score: " + str(purpleSnakeScore))
if purpleSnakeScore > highScore:
highScore = purpleSnakeScore
print("NEW HIGH SCORE: " + str(highScore))
elif orangeSnakeScore > purpleSnakeScore:
print("Orange Snake Wins! Score: " + str(orangeSnakeScore))
if orangeSnakeScore > highScore:
highScore = orangeSnakeScore
print("NEW HIGH SCORE: " + str(highScore))
else:
print("Draw!")
# It doesn't really matter which score we use here since they're the same
if orangeSnakeScore > highScore:
highScore = orangeSnakeScore
print("NEW HIGH SCORE: " + str(highScore))
else:
if purpleSnakeScore > highScore:
highScore = purpleSnakeScore
print("NEW HIGH SCORE: " + str(highScore))
else:
print("Last Game's Score: " + str(purpleSnakeScore))
print("High Score: " + str(highScore))
openMainMenu()
else:
screen.fill(black)
boundBox(screen)
# Draw Scores
snakeScore = scoreFont.render("PURPLE SCORE: " + str(snake.length - 10), 1, white)
screen.blit(snakeScore, (blockUnit, 2))
if multiPlayerMode:
orangeScoreText = "ORANGE SCORE: " + str(snakeB.length - 10)
snakeBScore = scoreFont.render(orangeScoreText, 1, white)
screen.blit(snakeBScore, ((WIDTH + 1)*blockUnit - scoreFont.size(orangeScoreText)[0], 2))
# Draw Snakes and Food
snake.draw()
object.draw()
if multiPlayerMode:
snakeB.draw()
objectB.draw()
pg.display.flip()
# Check if snakes are eating food
if object.getPos() == snake.getHeadPos():
snake.grow()
# food should not appear where the snake is
object.__init__(screen, 1, HEIGHT + 1, 1, WIDTH + 1)
while object.getPos() in snake.getPosList():
object.__init__(screen, 1, HEIGHT + 1, 1, WIDTH + 1)
snake.incLength()
# increase game speed
# if eaten % SPEED_INC == 0:
# SPEED += SPEED_TICK
if multiPlayerMode:
if objectB.getPos() == snakeB.getHeadPos():
snakeB.grow()
# food should not appear where the snake is
objectB.__init__(screen, 1, HEIGHT + 1, 1, WIDTH + 1)
while objectB.getPos() in snakeB.getPosList():
objectB.__init__(screen, 1, HEIGHT + 1, 1, WIDTH + 1)
snakeB.incLength()
# increase game speed
#if eaten % SPEED_INC == 0:
# SPEED += SPEED_TICK
#game speed control
clock.tick(SPEED)
# get the next event on queue
event = pg.event.poll()
if event.type == pg.QUIT:
running = False
pg.quit()
sys.exit()
elif event.type == pg.KEYDOWN:
actmotdir = snake.getMotionDir()
if event.key == pg.K_ESCAPE:
running = False
pg.quit()
sys.exit()
elif event.key == pg.K_UP and actmotdir != snk.DOWN:
snake.setMotionDir(snk.UP)
elif event.key == pg.K_DOWN and actmotdir != snk.UP:
snake.setMotionDir(snk.DOWN)
elif event.key == pg.K_RIGHT and actmotdir != snk.LEFT:
snake.setMotionDir(snk.RIGHT)
elif event.key == pg.K_LEFT and actmotdir != snk.RIGHT:
snake.setMotionDir(snk.LEFT)
if multiPlayerMode:
actmotdir2 = snakeB.getMotionDir()
if event.key == pg.K_w and actmotdir2 != snk2.DOWN:
snakeB.setMotionDir(snk2.UP)
elif event.key == pg.K_s and actmotdir2 != snk2.UP:
snakeB.setMotionDir(snk2.DOWN)
elif event.key == pg.K_d and actmotdir2 != snk2.LEFT:
snakeB.setMotionDir(snk2.RIGHT)
elif event.key == pg.K_a and actmotdir2 != snk2.RIGHT:
snakeB.setMotionDir(snk2.LEFT)
# remove the snake and make movement
snake.remove()
snake.move()
if multiPlayerMode:
snakeB.remove()
snakeB.move()
pg.init()
# initializing mixer, sounds, clock and screen
pg.mixer.init()
eatsound = pg.mixer.Sound("snakeeat.wav")
crashsound = pg.mixer.Sound("snakecrash.wav")
clock = pg.time.Clock()
screen = pg.display.set_mode(((WIDTH+2)*snk.BLOCK_SIZE,(HEIGHT+2)*snk.BLOCK_SIZE))
pg.display.set_caption("snake")
font = pg.font.SysFont(pg.font.get_default_font(),40)
gameovertext = font.render("GAME OVER",1,WHITE)
starttext = font.render("PRESS ANY KEY TO START",1,WHITE)
screen.fill(BLACK)
# we need a snake and something to eat
snake = snk.snake(screen,WIDTH/2,HEIGHT/2)
food = fd.food(screen,1,HEIGHT+1,1,WIDTH+1)
# food should not appear where the snake is
while food.getPos() in snake.getPosList():
food.__init__(screen,1,HEIGHT+1,1,WIDTH+1)
# only queue quit and and keydown events
# pg.event.set_allowed([pg.QUIT,pg.KEYDOWN])
pg.event.set_blocked([pg.MOUSEMOTION,pg.MOUSEBUTTONUP,pg.MOUSEBUTTONDOWN])
# will increase game speed every 10 times we eat
eaten = 0
# press any key to start!!!
drawWalls(screen)
