def update(self):
self.handle_keys()
self.trail_sprite_group.empty()
#Collision
for player in self.players:
player.update()
for i in player.trail:
self.trail_sprite_group.add(i)
for player in self.players:
#Border Collision
if player.rect.x < 0 or player.rect.x > (RESOLUTION[0] - CHUNK_SIZE):
change_state()
if player.rect.y < 0 or player.rect.y > (RESOLUTION[1] - CHUNK_SIZE):
change_state()
#Food Collision
for hit in pygame.sprite.spritecollide(player, self.food_sprite_group, True):
player.score += 1
self.food_sprite = Food.Food(self.resolution, self.chunk_size, self.food)
for sprite in self.trail_sprite_group.sprites():
if sprite.rect.x == self.food_sprite.rect.x and sprite.rect.y == self.food_sprite.rect.y:
self.food_sprite = Food.Food(self.resolution, self.chunk_size, self.food)
self.food_sprite_group.add(self.food_sprite)
for hit in pygame.sprite.spritecollide(player, self.trail_sprite_group, False):
change_state()
def eat(self):
"""
Spustí sa po zjedení potravy
"""
self.food = Food.food(self.width, self.height) # Nová potrava
# Nechceme, aby sa potrava objavila na hadovi
dummy = True
while dummy:
a = 0
# Kolízia s telom
for pos in self.body:
if np.array_equal(pos, self.food.pos):
self.food = Food.food(self.width, self.height)
break
a += 1
# Kolízia s hlavou
if np.array_equal(self.head, self.food.pos):
self.food = Food.food(self.width, self.height)
else:
a += 1
if a == len(self.body) + 1: # Potrava neleží na hadovi
dummy = False
self.deathtime += self.foodboost # Had sa najedol, žije dlhšie
# O koľko narastie, pri dlhšom hadovi bude odmena za jedlo väčšia
if self.length >= 10:
self.growcount += 3
else:
self.growcount += 1
def ihopethisshitwrosk():
Food.query(fat,rat)
title = "ur here"
mymap = pygmaps.maps(fat,rat,20)
mymap.addpoint(fat, rat,"Sr")
for k,v in Food.query(fat,rat).items():
mymap.addpoint(k,v,"#0000FF")
mymap.draw("./mymap.html")
def __init__(self):
pygame.init()
self.S = Snake()
self.F = Food()
# self.M = Menu()
self.CLOCK = pygame.time.Clock()
self.reset()
def set_food(self, food):
if food == 1:
self.food_type = food
self.food = Food.Food(self.rect.x, self.rect.y, self.game, self)
elif food == 0:
self.food_type = food
self.food = None
elif food == 2:
self.food_type = food
self.food = Food.Energiser(self.rect.x, self.rect.y, self.game,
self)
def main():
with open("foods.json") as jj:
ingredients = json.load(jj)
with open("recipes.json") as jj:
recipes = json.load(jj)
chef = Food(ingredients, recipes, level=60)
print(f'Max depth: {len(chef.allIngredients())}')
print(chef.allIngredients())
exclude = ['raw tuna', 'raw trout', 'raw shark']
deepsearch(chef, exclude=exclude)
def __init__(self, Grid):
self.grid = Grid
self.body = [(10, 6), (10, 7), (10, 8)]
self.direction = "Up"
self.status = ['run', 'stop']
self.speed = 300
self.color = "#FFC64B"
self.food = Food(self.grid)
self.display_food()
self.gameover = False
self.score = 0
def __init__(self):
pygame.init()
self.width = 500
self.height = 500
self.clock = pygame.time.Clock()
pygame.display.set_caption("Snake")
pygame.display.set_icon(pygame.image.load('images\icon.png'))
self.font = pygame.font.SysFont('Comic Sans MS', 20)
self.screen = pygame.display.set_mode([self.width, self.height])
self.snake = Snake(self.width, self.height)
self.food = Food(self.width, self.height)
self.fail_sounds = self.GetOggFiles("sounds\\fail")
class Snake(object):
def __init__(self, Grid):
self.grid = Grid
self.body = [(10, 6), (10, 7), (10, 8)]
self.direction = "Up"
self.status = ['run', 'stop']
self.speed = 300
self.color = "#FFC64B"
self.food = Food(self.grid)
self.display_food()
self.gameover = False
self.score = 0
def available_grid(self):
return [i for i in self.grid.grid_list if i not in self.body[2:]]
def change_direction(self, direction):
self.direction = direction
def display(self):
for (x, y) in self.body:
self.grid.draw((x, y), self.color)
def display_food(self):
while (self.food.pos in self.body):
self.food.set_pos()
self.food.display()
def move(self):
head = self.body[0]
if self.direction == 'Up':
new = (head[0], head[1] - 1)
elif self.direction == 'Down':
new = (head[0], head[1] + 1)
elif self.direction == 'Left':
new = (head[0] - 1, head[1])
else:
new = (head[0] + 1, head[1])
if not self.food.pos == head:
pop = self.body.pop()
self.grid.draw(pop, self.grid.bg)
else:
self.display_food()
self.score += 1
self.body.insert(0, new)
if not new in self.available_grid():
self.status.reverse()
self.gameover = True
else:
self.grid.draw(new, color=self.color)
def decode(self, encoded):
self.board = Board(src=encoded["board"])
self.id_snakes = {
sid: Snake(src=s)
for sid, s in encoded["snakes"].items()
}
self.foods = {fcell: Food(fcell) for fcell in encoded["foods"]}
def __init__(self):
super(PlayState, self).__init__()
# PLAYER, BOARD, FOOD
self.player = Player((NUM_ROWS // 2, NUM_COLS // 2), 'START', BLUE, 2)
self.board = Board()
self.food = Food()
self.initialized = True # flag used for initial board generation
# FITNESS FUNCTION KILL SWITCH
self.moves_since_food = 0
# PLAYER NAMES & SCORES
self.font = pygame.font.SysFont(FONT, 24)
self.player_text = self.font.render(
"Player 1: {0:>4d}".format(self.player.score), True,
WHITE) # TODO make color generic for choice
self.player_text_pos = self.player_text.get_rect()
self.player_text_pos.x = self.player_text_pos.y = CELL_SIDE
# LOGO
self.logo_text = pygame.font.SysFont(FONT, 48).render(
"SNAKE", True, (0, 255, 0))
self.logo_text_pos = self.logo_text.get_rect()
self.logo_text_pos.x = SCREEN_WIDTH // 2
self.logo_text_pos.y = CELL_SIDE
def __init__(self):
try:
address = sys.argv[1]
port = int(sys.argv[2])
self.event = KEY_RIGHT
self.dir = "right"
self.totalSnakes = int(sys.argv[3])
self.connections = []
self.addresses = []
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.bind((address, port))
self.sock.listen(1)
self.snakes = []
self.data = {
"win": 0,
"dead": [],
"snakes": [],
"food": [],
"scores": [],
}
for i in range(0, self.totalSnakes):
self.snakes.append(Snake.Snake(i + i))
self.data["scores"].append(0)
self.data["dead"].append(False)
self.data["snakes"].append(self.snakes[i].getBody())
self.food = Food.Food()
self.data["food"] = self.food.getCor()
except Exception as e:
print(e)
self.sock.close()
exit()
def __init__(self):
super().__init__()
self.name = "GameState"
#Textures
self.snake = pygame.transform.scale(pygame.image.load('Snake.png').convert(), (CHUNK_SIZE, CHUNK_SIZE))
self.trail = pygame.transform.scale(pygame.image.load('Trail.png').convert(), (CHUNK_SIZE, CHUNK_SIZE))
self.food = pygame.transform.scale(pygame.image.load('Food.png').convert(), (CHUNK_SIZE, CHUNK_SIZE))
self.highscore = int(open('Score.dat', 'r').readline())
#Colors
self.background = (51, 51, 51)
self.white = (255, 255, 255)
#Sprites
self.player_sprite = Player.Player(RESOLUTION, CHUNK_SIZE, 2, 0, SNAKE, TRAIL)
self.player_sprite_group = pygame.sprite.Group()
self.food_sprite = Food.Food(RESOLUTION, CHUNK_SIZE, FOOD)
self.food_sprite_group = pygame.sprite.Group()
self.food_sprite_group.add(self.food_sprite)
self.trail_sprite = Trail.Trail(RESOLUTION, CHUNK_SIZE, 2, 2, FOOD)
self.trail_sprite_group = pygame.sprite.Group()
self.trail_sprite_group.add(self.trail_sprite)
#Other
self.chunk_size = 16
self.chunk_amount = 32
self.resolution = (self.chunk_size * self.chunk_amount, self.chunk_size * self.chunk_amount)
def __init__(self):
# try:
address = sys.argv[1]
port = int(sys.argv[2])
self.event = KEY_RIGHT
self.dir = "right"
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.connect((address, port))
self.rdata = json.loads(str(self.sock.recv(2048)))
self.id = self.rdata["id"]
self.data = self.rdata["data"]
self.totalSnakes = len(self.data["snakes"])
curses.initscr()
self.score = 0
self.window = curses.newwin(HEIGHT, WIDTH, 0, 0)
self.window.timeout(TIMEOUT)
self.window.keypad(1)
curses.noecho()
curses.curs_set(0)
self.window.border(0)
self.snakes = []
for i in range(0, self.totalSnakes):
self.snakes.append(Snake.Snake(self.window,
self.data["snakes"][i]))
self.food = Food.Food(self.window, self.data["food"][0],
self.data["food"][1])
def feed(self,food_stor):
self.current_image = random.choice(self.images)
if (self.y_mouse > 90 and self.y_mouse < 590 and
self.x_mouse > 15 and self.x_mouse < 765) and (self.max_food < 8) and self.bank_value > 4: #mouse is in the tank and bank has money
food_stor.add(Food(self.current_image,self.x_mouse,self.y_mouse))
self.max_food += 1
self.bank_value -= 5
return True
def generate_food(self):
for i in range(amount_food):
food = Food.Food(self.screen, self.sim_data['design'])
self.food_list.append(food)
x = 20 + round(random.random() * width)
y = 20 + round(random.random() * height)
self.food_coords.append((x, y))
food.draw(x, y)
def __init__(self, type, index, left, top, game, food_type=0):
#1 - food, 2 - energiser
self.game = game
self.type = type
self.image = pygame.image.load("res\\" + type + ".gif")
self.rect = self.image.get_rect(topleft=(left, top))
self.is_wall = not (type == "empty")
self.index = index
self.food_type = food_type
if self.food_type == 0:
self.food = None
if food_type == 1:
self.food = Food.Food(left, top, game, self)
if food_type == 2:
self.food = Food.Energiser(left, top, game, self)
print(self.food.rect.width)
def spawn_food(self):
x = int(random.random() * Const.GRID_NR_W) * Const.BODY_SIZE + Const.BODY_SIZE / 2
y = int(random.random() * Const.GRID_NR_H) * Const.BODY_SIZE + Const.BODY_SIZE / 2
type = int(random.random() * 5)
# thank to this if normal apple (type 0) should appear 50% of the time
if type != 0:
type = int(random.random() * 5)
self.food = Food.Food(type, x, y)
def update(self, world, events):
if self.fx:
if self.reverse:
self.fx -= 1
if not self.fx:
self.reverse = False
else:
self.fx += 1
if self.fx == 64:
if self.order in world.orders:
world.remove_order(self.order)
self.contents = None
if self.order.double:
self.combo.contents = None
plate = Food.Plate()
plate.dirty = world.washing
world.returned.append([plate, 360])
world.del_updates(self)
money.play()
self.locked = False
plate = Food.Plate()
plate.dirty = world.washing
world.returned.append([plate, 360])
else:
self.reverse = True
self.order = None
elif self.contents:
for o in world.orders:
if o.double:
if self.combo and self.contents == o.os[
0].plate and self.combo.contents and self.combo.contents == o.os[
1].plate:
self.fx = 1
self.locked = True
self.order = o
elif o.plate == self.contents:
self.fx = 1
self.locked = True
self.order = o
else:
self.locked = False
else:
self.locked = False
world.del_updates(self)
def update(self):
self.recalculate_vectors()
self.kdtree = KDTree(self.vectors)
neighbor_distances, neighbor_indexes = self.kdtree.query(self.vectors,
k=6)
neighbor_indexes = neighbor_indexes[:, 1:]
num_cells = len(self.cells)
# self.food_spawn_rate = math.ceil(len(self.cells) / 30)
for i, cell in enumerate(self.cells):
input_list = [
cell.position.x, cell.position.y, cell.velocity.x,
cell.velocity.y, cell.health
]
for index in neighbor_indexes[i]:
if index > num_cells - 1:
input_list.append(1.0)
input_list.append(self.food[index - num_cells].position.x)
input_list.append(self.food[index - num_cells].position.y)
else:
input_list.append(0.0)
input_list.append(self.cells[index].position.x)
input_list.append(self.cells[index].position.y)
cell.update(input_list)
nearest_index = neighbor_indexes[i][1]
if nearest_index < len(self.cells):
nearest = self.cells[nearest_index]
else:
nearest = self.food[nearest_index - num_cells]
collide = cell.collision(nearest)
if collide:
if isinstance(nearest, Food.Food):
cell.health += 0.1
cell.score += 1
self.eaten_food.append(
[nearest, nearest_index - num_cells])
elif cell.breed_cooldown < 0 and nearest.breed_cooldown < 0:
self.breed_cells(cell, nearest)
cell.score += 2
nearest.score += 2
if cell.health < 0:
self.dead_cells.append([cell, i])
for i in range(self.food_spawn_rate):
food = Food.Food(np.random.random() * self.width,
np.random.random() * self.height)
self.new_food.append(food)
self.remove_dead_objects()
self.add_new_objects()
self.counter += 1
def setup(self):
self.scoreText=self.font_big.render("SCORE : 0",True,pygame.Color(0,255,0))
self.snake_head=Snake.Snake(150,150)
self.snake_head.image.fill(pygame.Color(0,0,255))
self.spritesList.add(self.snake_head)
for i in range(1,3):
segment=Snake.Snake(150,150+i*10)
self.snake_segs.append(segment)
self.spritesList.add(segment)
self.food=Food.Food()
self.score=0
def eat(self, food: Food) -> None:
"""
After eating a piece of food, updating the coordinates of the snake
:param food: an instance of Food
:return: None
"""
food_pos = food.get_position() # get the food position
self.snake.insert(
0, [food_pos[0], food_pos[1]]) # add food into the snake
self.head_x, self.head_y = food_pos[0], food_pos[
1] # update the head of the snale
def collision_detection(self, item_list, item_value, required_mass, camera):
""" (list),(int),(int),(object) ---> (None)
This function identifies collisions between a variety of different objects and the player, and is maniputable in order to set
indentifiers that allow the player object to comprehend what it is collidiing with and how to react
"""
for item in item_list:
if distance(self.x,self.y,item.x,item.y) <= self.mass/3 and self.mass > required_mass:
item_list.remove(item)
if self.mass <=800:
self.mass += item_value
pygame.mixer.Sound("Eat.wav").play()
self.cameraValue += 10*float(item_value)/self.mass
elif self.mass > 800 and self.mass <= 1200:
self.mass += item_value
pygame.mixer.Sound("Eat.wav").play()
self.cameraValue += 30*float(item_value)/self.mass
elif self.mass > 1150 and self.mass <= 1300:
self.mass += item_value
pygame.mixer.Sound("Eat.wav").play()
self.cameraValue += 55*float(item_value)/self.mass
elif self.mass > 1300 and self.mass <= 1450:
self.mass += item_value
pygame.mixer.Sound("Eat.wav").play()
self.cameraValue += 65*float(item_value)/self.mass
elif self.mass > 1450 and self.mass <= 1600:
self.mass += item_value
pygame.mixer.Sound("Eat.wav").play()
self.cameraValue += 85*float(item_value)/self.mass
elif self.mass > 1600 and self.mass < 2000:
self.mass += item_value
pygame.mixer.Sound("Eat.wav").play()
self.cameraValue += 120*float(item_value)/self.mass
elif self.mass >= 2000:
self.mass += item_value
pygame.mixer.Sound("Eat.wav").play()
self.cameraValue = self.cameraValue
if item_value == 1:
Food.spawn_food(item_list,1,self.surface,self.playfieldWidth,self.playfieldHeight)
elif item_value == 100.111:
self.explode(camera,item_list)
pygame.mixer.explode_sound.play()
def spawnOneFood(self, origin=(0, 0), random=False):
if random:
x, y = self.getSpawnLocationDistribution(origin)
else:
x, y = origin
self.pos_food[(x, y)] = Food(
x, y,
Globals.glwidget.createImage(
Globals.datadir + 'images/food/food.png', 2, [32, 32, 32, 32],
[x * 32, y * 32, 32, 32]))
self.occupiedTiles[(x, y)] = True
def move():
game_on = True
turtle.color('red')
style = ('Courier', 10, 'italic')
turtle.penup()
turtle.goto(150, 280)
score = Score.SCORE
higscore=Score.highscore
food=Food.random_food()
while game_on:
turtle.write(f'SCORE İS : {score} HİGHSCORE İS : {higscore} ', font=style, align='center')
turtle.hideturtle()
food_x = food.xcor()
food_y = food.ycor()
screen.update()
time.sleep(0.1)
if snake_parts[0].xcor()>280 or snake_parts[0].xcor()<-280 or snake_parts[0].ycor()>280 or snake_parts[0].ycor()<-280:
return False
for num in range(len(snake_parts)-1,0,-1):
new_x = snake_parts[num-1].xcor()
new_y = snake_parts[num - 1].ycor()
snake_parts[num].goto(new_x,new_y)
if (snake_parts[0].xcor()>food_x-20 and snake_parts[0].xcor()<food_x+20) and (snake_parts[0].ycor()>food_y-20 and snake_parts[0].ycor()<food_y+20):
food.hideturtle()
turtle.clear()
score+=1
if score>=int(higscore):
higscore=score
with open("highscore",mode="w") as file:
file.write(f"{score}")
file.close()
food=Food.random_food()
CreateSnake.eat()
snake_parts[0].forward(20)
x = CreateSnake.eat_self_control()
if x == False:
print("HIT THE TAİL GG")
return False
def __init__(self):
try:
curses.initscr()
self.score = 0
self.window = curses.newwin(HEIGHT, WIDTH, 0, 0)
self.window.timeout(TIMEOUT)
self.window.keypad(1)
curses.noecho()
curses.curs_set(0)
self.window.border(0)
self.snake = Snake.Snake(self.window)
self.food = Food.Food(self.window)
except:
curses.endwin()
def __init__(self, components, double=False):
self.c = []
for c in components:
if c.contents:
self.c.extend(c.contents)
else:
self.c.append(c)
try:
baseimg = orderframes[len(self.c) - 1]
except IndexError:
while len(orderframes) < len(self.c):
img = orderframes[-1]
w = img.get_width()
toblit = img.subsurface(pygame.Rect(w - 36, 0, 36, 106))
new_img = pygame.Surface((w + 34, 106))
new_img.blit(img, (0, 0))
new_img.blit(toblit, (w - 2, 0))
orderframes.append(new_img)
baseimg = orderframes[len(self.c) - 1]
self.img = pygame.Surface((baseimg.get_width(), 138), pygame.SRCALPHA,
32).convert_alpha()
self.img.blit(baseimg, (0, 0))
if len(self.c) == 1:
self.img.blit(self.c[0].raw_img, (19, 74))
if self.c[0].state != "normal":
self.img.blit(states[self.c[0].state], (17, 104))
else:
for n, c in enumerate(self.c):
self.img.blit(c.raw_img, (2 + n * 34, 74))
if c.state != "normal":
self.img.blit(states[c.state], (n * 34, 104))
self.plate = Food.Plate()
for c in components:
assert self.plate.combine(c), "INVALID RECIPE: " + str(
components) + " OFFENDING INGREDIENT: " + str(c)
if len(self.c) < 3:
subsurf = self.img.subsurface(pygame.Rect(3, 8, 64, 64))
else:
subsurf = self.img.subsurface(
pygame.Rect(3 + 17 * len(self.c) - 34, 8, 64, 64))
subsurf.blit(self.plate.get_img(), (0, -self.plate.o3d * 4))
self.time = int(
(900 + len(self.c) * 900) * self.plate.contents.ordermultiplier)
if double:
self.time *= 1.5
self.time = int(self.time)
self.stime = self.time
self.img = Img.xn(self.img, 2)
self.width = self.img.get_width()
def check_eat(snake, food):
"""
Checks if snake ate the food. Calls generation of new position if food is eaten.
Args:
snake (obj): Object of class Snake
food (obj): Object of class Food
"""
if snake.get_head_position() == food.position:
snake.length += 1
snake.points += Variables.score_multi
Variables.is_eaten = True
Food.Food().generate_food_pos()
def __init__(self, screen_width, screen_height, speed, difficulty):
pygame.init()
self.game_over = False
self.screen_width = screen_width
self.screen_height = screen_height
self.block_size = 20
# set default font
self.game_font_mini = pygame.font.SysFont("comicsansms", 20)
self.game_font_s = pygame.font.SysFont("comicsansms", 30)
self.game_font_m = pygame.font.SysFont("inkfree", 50)
self.game_font_l = pygame.font.SysFont("comicsansms", 100)
self.running = True
# create display
self.game_display = pygame.display.set_mode(
(self.screen_width, self.screen_height))
# set clock for fps control
self.clock = pygame.time.Clock()
# instantiate snake
self.snake = sn.Snake(self.game_display, self.block_size, 640, 360)
# instantiate fruit
self.fruit = fd.Fruit(self.screen_width, self.screen_height,
self.block_size)
self.head = pygame.image.load('../graphics/head.png')
self.part = pygame.image.load('../graphics/part.png')
self.apple = pygame.image.load('../graphics/apple.png')
# set window name
pygame.display.set_caption("Snake")
# method for input general messages
self.choice = 0
self.difficulty = difficulty
self.speed = speed
self.run = 1
self.intro = False
self.paused = False
self.gcont = False
self.descrpt = False
self.while_scores = False
def enter(self, chunk_size, chunk_amount):
self.player_sprite = Player.Player(self.resolution, self.chunk_size, 2, 2, self.snake, self.trail)
self.player_sprite_group = pygame.sprite.Group()
self.player_sprite_group.add(self.player_sprite)
self.players = [self.player_sprite]
#Setup for food
self.food_sprite = Food.Food(self.resolution, self.chunk_size, self.food)
self.food_sprite_group = pygame.sprite.Group()
self.food_sprite_group.add(self.food_sprite)
#Setup for trails
self.trail_sprite = Trail.Trail(self.resolution, self.chunk_size, 2, 2, self.food)
self.trail_sprite_group = pygame.sprite.Group()
self.trail_sprite_group.add(self.trail_sprite)
def __init__(self):
self.window = pygame.display.set_mode(size)
pygame.display.set_caption('Snake')
self.window.fill(black)
self.fps_increment=80
self.FPS=STARTING_FPS
self.playerInput = PlayerInput()
self.board=Board()
self.head=Segment((world_size/2, world_size/2))
self.snake=Snake(self.head)
self.food=Food()
def eat_food(self, dish):
closest_food = Food((1000000, 1000000), dish)
go = False
for food in dish.food:
if food.distance(self.position) < closest_food.distance(
self.position):
closest_food = food
go = True
if go:
if closest_food.distance(self.position) <= self.radius:
self.hunger = 0
dish.food.remove(closest_food)
closest_food.eat()
self.move_towards(closest_food.position,
closest_food.distance(self.position))
def testFood():
try:
import Food
except:
print "Error: No file named Food.py found in current directory."
return
try:
for a in range(4):
for b in range(4):
for c in range(4):
for d in range(4):
assertEquals(constants.LEFT, Food.getMove(a, b, c, d))
except CritterTestError:
failed.append("Food")
return
except:
failed.append("Food")
raise
passed.append("Food")
def GameLoop(screen,fpsSet):
## returns score
## screen size
score = 0
# sets Snake and food size in constructor to be able to change it in Settings
running = True # game running flag
size = Settings.surfaceSize
screen = pygame.display.set_mode(size,pygame.RESIZABLE| pygame.HWSURFACE|pygame.DOUBLEBUF)
Settings.obsList += generateObstacles(Settings.numberObs, screen) ## Settings class keeps obstacle number
Settings.obsDraw(screen)
pygame.display.update()
foodRadius = Settings.getFoodRadius()
SnakeSize = Settings.getSnakeSize()
food = Food(screen,foodRadius)
snake = Snake(screen,SnakeSize)
# sets Snake starting velocity
event,Str = block() # blocks before game starts
if Str == "quit":
exit()
elif Str == "mouse":
return 0 ## score
elif Str == "keydown":
snake.event(event,True)
while (snake.getVelocity() == (0,0)):
event,Str = block()
snake.event(event,True)
elif Str == "resize":
size = event.dict['size']
Settings.surfaceSize = size
screen = pygame.display.set_mode(size,pygame.RESIZABLE| pygame.HWSURFACE|pygame.DOUBLEBUF)
snake.set_surface(screen)
food.set_surface(screen)
food.redraw()
snake.redraw()
Settings.obsDraw(screen)
while running:
snake.move()
snake.draw()
# while loop allows for food to always be drawn in a single loop
while True:
coords = food.foodCoords()
if not(coords in snake.getBody()):
if checkObstacle(coords, Settings.obsList):
food.draw()
break;
## use screen.get_width and .get_height methods in case you need to resize
running = checkObstacle(snake.getPos(),Settings.obsList) ## check if Snake hit any obstacle
if snake.checkInvalidMove():
running = False
snake.set_surface(screen)
if Settings.getCollision(): #returns True if snake is set to collide with walls
snake.checkBoundaries()
if snake.getCrashState():
running = False
else:
x,y = snake.checkBoundaries()
if snake.getCrashState():
snakeX,snakeY = snake.getPos()
if snakeX > snake.surface.get_width():
snake.x = 0
elif snakeX < 0:
snake.x = snake.surface.get_width()
elif snakeY < 0:
snake.y = snake.surface.get_height()
elif snakeY > snake.surface.get_height():
snake.y = 0
if food.check(snake.x, snake.y):
score += 1
snake.eat()
food.erase()
event, Str = nonBlock()
if Str == "quit":
exit()
if Str == "none":
a = None
elif Str == "keydown":
snake.event(event,True)
elif Str == "mouse":
snake.event(event,False)
elif Str == "resize":
size = event.dict['size']
Settings.surfaceSize = size
screen = pygame.display.set_mode(size,screen.get_flags())
Settings.setSurface(screen)
snake.set_surface(screen)
food.set_surface(screen)
food.redraw()
snake.redraw()
Settings.obsDraw(screen)
pygame.display.update()
clock.tick(fpsSet) ## fps set -> must be set in every loop of the game loop
return score
class SnakeGame:
def __init__(self):
self.window = pygame.display.set_mode(size)
pygame.display.set_caption('Snake')
self.window.fill(black)
self.fps_increment=80
self.FPS=STARTING_FPS
self.playerInput = PlayerInput()
self.board=Board()
self.head=Segment((world_size/2, world_size/2))
self.snake=Snake(self.head)
self.food=Food()
def game(self):
pygame.init()
running=True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running=False
self.playerInput.takeInput(event)
if self.food.foodExists==False:
self.food.spawnFood(self.board.grid)
if self.snake.foundFood(self.food.foodGridPosition)==True:
self.food.clearFood(self.board.grid)
self.board.updateNodes(self.snake)
self.drawBoard()
self.food.foodExists=False
self.snake.grow()
self.snake.setDirection(self.playerInput.direction)
self.playerInput.finaliseDirection()
#self.board.resetNode(self.snake.getHead().getLastNode().getPosition()) This code doesn't work. For some reason, when food it picked up, this no longer calls the method.
self.snake.moveSnake()
if self.snake.checkCollision()==True:
break
self.board.updateNodes(self.snake)
self.drawBoard()
clock.tick(self.FPS)
pygame.display.update()
self.increaseFPS()
pygame.quit()
def drawBoard(self):
for List in self.board.grid:
for node in List:
if node.getContainsFood()==True:
pygame.draw.rect(self.window, red, (node.getPosition()[0], node.getPosition()[1], rectangle_width, rectangle_height),0)
elif node.getContainsSnake()==True:
pygame.draw.rect(self.window, white, (node.getPosition()[0], node.getPosition()[1], rectangle_width, rectangle_height),0)
elif node.getContainsSnake()==False:
pygame.draw.rect(self.window, black, (node.getPosition()[0], node.getPosition()[1], rectangle_width, rectangle_height),0)
def increaseFPS(self):
self.fps_increment-=1
if self.fps_increment<=0:
if self.FPS<=fps_cap:
self.FPS+=1
self.fps_increment=80
def main(self):
self.game()
