def __init__(self, data):
self._turn = data['turn']
self._width = data['board']['width']
self._height = data['board']['height']
self._nodes = dict()
self._food_list = []
self._enemy_list = []
self._our_snake = None
our_id = data['you']['id']
# Process Snakes
for snake in data['board']['snakes']:
snake_info = SnakeInfo(snake, self, our_id)
if snake_info.is_enemy():
self._enemy_list.append(snake_info)
else:
self._our_snake = snake_info
for point in snake['body']:
new_snake = SnakeNode(point, snake_info)
self._nodes[new_snake.get_point()] = new_snake
snake_head = self._our_snake.get_head()
# Process Food
for raw_data in data['board']['food']:
new_food = Food(raw_data, snake_head)
self._food_list.append(new_food)
self._nodes[new_food.get_point()] = new_food
self._food_list = sorted(self._food_list,
key=operator.attrgetter('_start_distance'))
def main():
'''
s = Stack()
arr = [11, 22, 33, 44, 55, 66]
array_to_stack(s, arr)
for v in s:
print(v)
stack_to_array(s,arr)
print(arr)
'''
'''
arr2 = [1,2,3,4]
s2 = Stack()
for a in arr2:
s2.push(a)
stack_test(s2)
for v in s2:
print(v)
'''
#testing the stack
arr2 = [1, 2, 3, 4]
stack_test(arr2)
f = Food("bread", 10, True, 55)
g = Food("grape", 6, False, 9)
foods = [f, g]
stack_test(foods)
'''
def main():
food = Food("grape", 3, True, 2)
food1 = Food("chicken", 2, False, 1)
food2 = Food("sushi", 3, True, 12)
foods = [food, food1, food2]
avg = average_calories(foods)
print(avg)
def routineTo(sf, cf):
gen = Genetic(sf, cf)
fen = fenetre()
food = Food(fen)
#newFen = newFenTop()
#texts = addScoreOnTopWindows(newFen, int(Params.p['sizePop']))
pop = Population(fen, food)
pop.setInitialPositions()
for i in range(int(Params.p['nbEvol'])):
popName = "pop_" + str(i)
if i > 0:
gen.createNewPopulation(pop)
food = Food(fen)
pop.setFood(food)
pop.setInitialPositions()
#newFen[1].itemconfig(newFen[2], text=popName)
t = time.time()
#while time.time() - t < Params.p['lifeTime']:
j = 0
while j < Params.p['lifeTime']:
#refreshScores(newFen, texts, pop)
pop.routineForPopulation()
fen.refreshScreen()
j += 1
timeGen = time.time() - t
print("Execution time: ", timeGen)
savePop(pop, popName = popName)
fen.fen.destroy()
def __init__(self):
self.player = Player(self.screen ,self.x,self.y)
self.collider=Collider(self.screen,self.player.arrows,self.badguys,self.player,self.foods)
self.food = Food(self.screen,self.food_x, self.food_y)
self.wl=WL(self.screen,self.exitcode)
self.timer=Timer(self.screen,self.count)
self.screen2=Screen2(self.screen,self.width,self.height)
def get_food():
"""
-------------------------------------------------------
Creates a food object by requesting data from a user.
Use: f = get_food()
-------------------------------------------------------
Returns:
food - a completed food object (Food).
-------------------------------------------------------
"""
n = input("Enter Name:")
print("Origin")
# Create food object to use the origins function
p = Food("Butter Chicken", 2 , True, 120)
print(p.origins())
o = int(input(":"))
v = input("Vegetarian (Y/N):")
if v == "Y":
v = True
if v == "N":
v = False
c = int(input("Calories:"))
food = Food(n, o, v == True, c)
return food
def instruction(self):
self.elements = []
self.text_menu = arcade.draw_text("Instruction",
self.center,
self.high,
arcade.color.WHITE,
30,
align="center",
anchor_x="center")
icon_food = Food(0, self.center - 180, self.high - 50)
icon_speed = Food(1, self.center - 180, self.high - 80)
icon_slow = Food(2, self.center - 180, self.high - 110)
icon_ghost_walk = Food(3, self.center - 180, self.high - 140)
icon_color = Food(4, self.center - 180, self.high - 170)
back_button = MenuButton("Close", self.center, self.high - 325, 15,
self.setup)
self.icons.append(icon_food)
self.icons.append(icon_speed)
self.icons.append(icon_slow)
self.icons.append(icon_ghost_walk)
self.icons.append(icon_color)
self.elements.append(back_button)
self.is_instruction = True
def main():
f1 = Food("not spring rolls", 1, False, 66)
f2 = Food("spring rolls wrong", 2, True, 653)
f3 = Food("good spring rolls", 1, True, 7)
source = [f1, f2, f3]
source2 = [6, 8, 2]
list_test(source)
def main():
try:
pygame.init()
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption('Змейка')
running = True
board = Board(20, 15, 40)
snake = Snake(board)
# snake.set_self_onboard()
food = Food(board)
# food.set_self_onboard()
board.add_food(food)
board.add_snake(snake)
fps = 6
clock = pygame.time.Clock()
if board.start_screen(screen, clock):
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE: # пауза
print('main.py:"SPACE"')
board.pause_play()
elif event.scancode == pygame.KSCAN_R: # перезапуск
food.restart()
snake.restart()
board.pause_play()
elif board.playing:
# управление стрелками
if event.key == pygame.K_UP:
snake.UP()
break
elif event.key == pygame.K_RIGHT:
snake.RIGHT()
break
elif event.key == pygame.K_DOWN:
snake.DOWN()
break
elif event.key == pygame.K_LEFT:
snake.LEFT()
break
screen.fill((0, 0, 0))
# food.set_self_onboard()
if board.playing:
snake.next_frame(screen)
board.render(screen)
pygame.display.flip()
clock.tick(fps)
except Exception as e:
print(e)
pygame.quit()
def __init__(self):
self.window = pygame.display.set_mode((500, 500))
pygame.display.set_caption("Hacktoberfest Snake Game")
self.fps = pygame.time.Clock()
self.score = 0
self.snake = Snake()
self.food = Food()
def __init__(self, x, y):
self.x = x
self.y = y
self.base_object = {}
self.food_on_map = Food()
self.material_on_map = Material()
self.symbol = "X"
def main():
food = Food("grape", 3, True, 5)
food1 = Food("chicken", 2, False, 67)
food2 = Food("sushi", 3, True, 12)
food3 = Food("water", 3, True, 0)
foods = [food, food1, food2, food3]
a = calories_by_origin(foods, 3)
print(a)
def __init__(self):
pygame.init()
self.setting = Setting()
self.screen = pygame.display.set_mode(
(self.setting.WIDTH, self.setting.HIGH), 0, 32)
self.food = Food(self)
self.snake = Snake(self)
self.message = Message(self)
self.map = Map(self)
def f_menu():
print("---------------------- Food Menu ----------------------")
print(" Name" + " " * 20 + "Price")
index = 0
for meal in food_list:
item = Food(meal[0], meal[1], meal[2])
item.food_menu(index)
index += 1
print("--------------------------------------------------------")
def place_food(self):
x = randint(0, self.height - 1)
y = randint(0, self.width - 1)
food = Food(x, y)
while food.position in self.snake.snakeBody:
x = randint(0, self.height - 1)
y = randint(0, self.width - 1)
food = Food(x, y)
return food
def main():
food = Food("grape", 3, True, 67)
food1 = Food("chicken", 2, False, 67)
food2 = Food("sushi", 3, True, 67)
foods = [food, food1, food2]
v = by_origin(foods, 3)
for s in v:
print(s)
def __init__(self):
self.player = Player([400, 400])
self.windowHeight = 768
self.windowWidth = 1366
self.screen = 0
self.running = True
self.nn = NeuralNetwork()
self.food = Food([200, 200])
self.countGeneration = 0
self.score = 0
def __init__(self):
pygame.init()
self.status = 1
self.screen = pygame.display
self.surface = self.screen.set_mode((800, 600))
self.snake = [Snake(200, 200, 'r')]
self.fps = 100
self.dir_change_location = {}
self.food = Food()
self.food.generate_food()
def main():
food = Food("grape", 3, True, 5)
food1 = Food("chicken", 2, False, 67)
food2 = Food("sushi", 3, True, 10)
food3 = Food("water", 3, True, 0)
foods = [food, food1, food2, food3]
result = food_search(foods, -1, 0, True)
for f in result:
print(f)
def launch(self):
self.snake=Snake()
self.food=Food()
pygame.init()
screen_size=(self.W,self.H)
screen=pygame.display.set_mode(screen_size)
pygame.display.set_caption("Snake")
clock=pygame.time.Clock()
scores=0
isdead=False
while True:
for event in pygame.event.get():
if event.type==pygame.QUIT:
sys.exit()
if event.type==pygame.KEYDOWN:
self.snake.change_direction(event.key)
if event.key==pygame.K_SPACE and isdead:
return self.launch()
screen.fill((155,255,255))
if not isdead:
scores+=1
self.snake.move()
for rect in self.snake.body:
pygame.draw.rect(screen,(20,220,39),rect,0)
isdead=self.snake.isdead(self.W,self.H)
if isdead:
self.show_context(screen,(100,200),"YOU DEAD")
if self.food.rect==self.snake.body[0]:
scores+=50
self.food.remove()
self.snake.addnode()
while True:
self.food.set(self.W)
if self.food.rect not in self.snake.body:
break
pygame.draw.rect(screen,(136,0,21),self.food.rect,0)
self.show_context(screen,(50,500),"SCORES:"+str(scores))
pygame.display.update()
clock.tick(5)
def __init__(self):
# overhaul size of the screen by 16x16 pixels as 1 unit
self.size = {'columns': 45, 'rows': 30}
# time in ticks between each snake move
self.snakepace = 6
# snake state, alive = True, dead = False
self.snakeState = True
# game score
self.score = 0
# internal cool down to limit player movement
self.cd = [9, 9, False]
# screen size in pixels
self.psize = {'width': 720, 'height': 480}
# fps control
self.clock = pygame.time.Clock()
# time in ticks for internal control
self.pace = 0
# spawning snake and assigning to a variable
self.snake = Snake(352, 240)
# spawning food and assigning to a variable
self.food = Food(
randint(1, self.size['columns'] - 1) * 16,
randint(1, self.size['rows'] - 1) * 16)
# board
self.rows = []
self.screen = pygame.display.set_mode(
(self.psize['width'], self.psize['height']))
# rows
for i in range(0, self.size['rows']):
self.row = []
# columns
for j in range(0, self.size['columns']):
if i == 0:
if j == 0:
self.row.append(LTCell(j * 16, i * 16))
elif j == self.size['columns'] - 1:
self.row.append(TRCell(j * 16, i * 16))
else:
self.row.append(TCell(j * 16, i * 16))
elif i == self.size['rows'] - 1:
if j == 0:
self.row.append(BLCell(j * 16, i * 16))
elif j == self.size['columns'] - 1:
self.row.append(RBCell(j * 16, i * 16))
else:
self.row.append(BCell(j * 16, i * 16))
elif i > 0 and j == 0:
self.row.append(LCell(j * 16, i * 16))
elif i > 0 and j == self.size['columns'] - 1:
self.row.append(RCell(j * 16, i * 16))
else:
self.row.append(Cell(j * 16, i * 16))
self.rows.append(self.row)
def reset(self):
self.move = Move()
time.sleep(self.secs)
self.buildGrid()
self.move = Move()
self.snake = Snake(self.width, self.height, self.border)
self.food = Food(self.width, self.height, self.snake)
self.score = 0
self.reseting = True
def __init__(self,
numOfSnakes=Constants.numberOfSnakes,
gridSize=Constants.gridSize,
maxEpisodeLength=Constants.globalEpisodeLength):
self.snakes = []
for idx in range(numOfSnakes):
self.snakes.append(Snake(idx))
self.food = Food(Snake.snakeList)
self.gameLength = maxEpisodeLength
self.time_step = 0
return
def game_loop() -> None:
game_over = False
game_close = False
while not game_close:
while game_over and not game_close:
surface.fill(BLACK)
show_you_lost_screen()
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.QUIT:
game_over = True
game_close = True
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_q:
game_close = True
game_over = True
if event.key == pygame.K_c:
game_over = False
snake = Snake(WIDTH, HEIGHT, snake_size)
food = Food(WIDTH, HEIGHT, snake_size)
score = 0
while not game_over:
for event in pygame.event.get():
if event.type == pygame.QUIT:
game_over = True
game_close = True
if event.type == pygame.KEYDOWN:
snake.head_direction = event.key
if snake.eat(food):
food.generate(WIDTH, HEIGHT, snake_size)
score += 1
snake.move()
if snake.died(WIDTH, HEIGHT):
game_over = True
surface.fill(BLACK)
draw_snake(snake)
draw_food(food)
show_score(score)
pygame.display.update()
clock.tick(snake_speed)
class Ground():
def __init__(self, x, y):
self.x = x
self.y = y
self.base_object = {}
self.food_on_map = Food()
self.material_on_map = Material()
self.symbol = "X"
def build_construction(self, building_class, fraction): #budowanie
"""Buduje budynek, dodaje jego symbol i wartość do słownika i zwraca ten słownik."""
self.building = building_class
self.building.build(fraction) #zbudowanie budynku
self.building_dict = {}
self.building = self.building.add_building(
fraction) #dodanie do słownika danych budynku
return self.building
def update_object_new(
self): #zaktualizowanie słownika na obszarze przy rysowaniu mapy
"""Metoda aktualizująca słownik pola o losowe wartości jedzenia i materiałów."""
self.base_object.update(self.food_on_map.generate())
self.base_object.update(self.material_on_map.generate())
def update_object(
self, obj): #aktualizowanie oobszaru na mapie np. przy budowaniu
"""Metoda aktualizująca słownik o zadaną wartość."""
self.base_object.update(obj)
def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
print("answer_price_food")
food = str(tracker.get_slot('food'))
if food is None:
dispatcher.utter_message("Nhà hàng mình không có món kia bạn ạ")
Max = SequenceMatcher(a=food, b="Lẩu dầu cay không vụn").ratio()
for item in Menu():
temp = SequenceMatcher(a=food, b=item.name).ratio()
if temp >= Max:
Max = temp
max_food = Food(item.name, item.price, item.type, 0)
if max_food.type == "beef":
dispatcher.utter_message("Món " + max_food.name +
" bên em đang bán có giá " +
str(max_food.price) + "k/100g ạ")
elif max_food.type == "special":
dispatcher.utter_message(
"Tiết mục " + max_food.name + " bên em đang bán có giá " +
str(max_food.price) +
"k bao gồm cả phần mì và nhân viên ra múa mì luôn ạ")
elif max_food.type == "drink":
dispatcher.utter_message("Dạ " + max_food.name +
" bên em đang bán có giá " +
str(max_food.price) + "k/chai ạ")
else:
dispatcher.utter_message("Món " + max_food.name +
" bên em đang bán có giá " +
str(max_food.price) + "k/suất ạ")
return [SlotSet("food", None)]
def buildLargeMenu(numItems, maxValue, maxCost):
items = []
for i in range(numItems):
items.append(
Food('num-' + str(i), random.randint(1, maxValue),
random.randint(1, maxCost)))
return items
def loadWorld(self, worldFile):
self.reset()
self.main_gui.button_go["text"] = "Go =>"
if self.charged > 0 and self.main_gui.is_modifying.get() == True:
self.main_gui.on_modif_state_change()
self.charged += 1
with open(f"worlds/{worldFile}") as file:
data = file.read()
world_data = json.loads(data)
try:
for food in world_data['food']:
self.add_food(
Food(self.canvas, food['x'], food['y'], food['size']))
for nest in world_data['nests']:
self.add_nest(
Nest(self, len(self.nests), nest['x'], nest['y'],
nest['species'], nest['size']))
if (world_data["wall"]):
for wall in world_data["wall"]:
self.add_wall(wall[0], wall[1])
for i, species in enumerate(world_data["species"]):
for trait, value in species.items():
self.species[i].update_trait(trait, value)
self.main_gui.update_species_entry(trait, value)
except BaseException:
pass
def read_food(line):
"""
-------------------------------------------------------
Creates and returns a food object from a line of string data.
Use: f = read_food(line)
-------------------------------------------------------
Parameters:
line - a vertical bar-delimited line of food data in the format
name|origin|is_vegetarian|calories (str)
Returns:
food - contains the data from line (Food)
-------------------------------------------------------
"""
line.strip()
x = line.split("|")
if x[2] == "True":
x[2] = True
if x[2] == "False":
x[2] = False
origin = int(x[1])
food = Food(x[0], origin, x[2] , int(x[3]))
return food
def read_food(line):
"""
-------------------------------------------------------
Creates and returns a food object from a line of string data.
Use: f = read_food(line)
-------------------------------------------------------
Parameters:
line - a vertical bar-delimited line of food data in the format
name|origin|is_vegetarian|calories (str)
Returns:
food - contains the data from line (Food)
-------------------------------------------------------
"""
l = line.split("|")
name = l[0]
ori = int(l[1])
vegTemp = l[2]
if vegTemp == "True":
veg = True
else:
veg = False
cal = int(l[3])
food = Food(name, ori, veg, cal)
return food
def __init__(self): # pygame initialization self.screen = pygame.display.set_mode((SCREEN_SIZE, SCREEN_SIZE)) pygame.mouse.set_visible(0) self.background = pygame.Surface(self.screen.get_size()) self.background = self.background.convert() self.background.fill((255, 255, 255)) self.food = Food() self.food_sprite = pygame.sprite.RenderPlain(self.food) # create sprite group for the food self.seeker = Seeker() self.seeker_sprite = pygame.sprite.RenderPlain(self.seeker) # create sprite group for the seeker self._draw() # pybrain initialization self.action = [0.0, 0.0] self.reset()
class ChemotaxisEnv(Environment): """ Experiment adapted from "Evolving Dynamical Neural Networks for Adaptive Behavior" (Beer & Gallagher, 1992) An seeker is enclosed in a square box with a food item inside. This food item emits a chemical signal whose intensity falls off as the inverse square of the distance from the food. The intensity of the chemical signal within the environment varies five orders of magnitude from the item to the far corners of the box, i.e. at a distance of root(2). We wish the seeker to find and remain in the vicinity of the food item, starting from arbitrary locations and orientations within the environment. To accomplish this task, the seeker is endowed with a circular body with a diameter of .01. The seeker possesses chemical sensors that can directly sense the intensity of the chemical signal at their location. These sensors are symmetrically placed about the center line of the body. In addition, the seeker has two effectors located on opposite sides of its body. These effectors can apply forces that move the body forward and rotate it. In the simplified physics of this environment, the velocity of movement is proportional to the force applied. State space (continuous): food location of food item as a coordinate pair from (0,0) to (100,100) seeker.loc location of the center of the seeker seeker.dir angle of the seeker in radians from the positive x-axis, i.e. east=0 Action space (continuous): l output signal of the left effector neuron r output signal of the right effector neuron """ def __init__(self): # pygame initialization self.screen = pygame.display.set_mode((SCREEN_SIZE, SCREEN_SIZE)) pygame.mouse.set_visible(0) self.background = pygame.Surface(self.screen.get_size()) self.background = self.background.convert() self.background.fill((255, 255, 255)) self.food = Food() self.food_sprite = pygame.sprite.RenderPlain(self.food) # create sprite group for the food self.seeker = Seeker() self.seeker_sprite = pygame.sprite.RenderPlain(self.seeker) # create sprite group for the seeker self._draw() # pybrain initialization self.action = [0.0, 0.0] self.reset() def _draw(self): #self.seeker_sprite.update(self.background) self.screen.blit(self.background, (0, 0)) self.food.update() self.food_sprite.draw(self.screen) self.seeker.update(self.screen) # we don't need to draw this here because we draw it with pymunk pygame.display.flip() def _calcDistance(self, loc1, loc2): """ Calculates the Euclidean distance between two coordinate pairs. """ from math import sqrt return sqrt((loc2[0] - loc1[0]) ** 2 + (loc2[1] - loc1[1]) ** 2) def calcSignal(self, loc): """ Calculates the chemical signal at a specific location, which is the inverse square of the distance between the given location and the food. """ dist = self._calcDistance(self.food.loc, loc) if dist == 0: return 1 else: return 1/dist # why does changing the reward magnitude change the sensor-delta magnitude? def getSensors(self): """ the currently visible state of the world (the observation may be stochastic - repeated calls returning different values) :rtype: by default, this is assumed to be a numpy array of doubles """ # get sensor locations lx, ly, rx, ry = self.seeker.calcAbsoluteSensorPositions() # return the strength of the chemical signals at the seeker's left and right sensors return [ self.calcSignal(toPygame((lx, ly))), self.calcSignal(toPygame((rx, ry))) ] def performAction(self, action): """ perform an action on the world that changes its internal state (maybe stochastically). :key action: an action that should be executed in the Environment. :type action: by default, this is assumed to be a numpy array of doubles action[0] is the left motor/effector neuron output, action[1] is the right """ self.seeker.move_body(action[0], action[1]) self.movement_tracker.append(toPygame(self.seeker.body.position)) # redraw self._draw() def reset(self): """ Reinitializes the environment with the food in a random location and the seeker with a random direction in a random location. """ from random import random self.movement_tracker = [] self.food.setLocation((random()*SCREEN_SIZE, random()*SCREEN_SIZE)) self.seeker.reset()
def main():
#create display
screen = pygame.display.set_mode((690, 601))
screen.fill([156, 203, 250])
clock = pygame.time.Clock()
font = pygame.font.Font(None, 25)
frameCount = 0
frameRate = 10
startTime = 90
#tile map through which players will navigate
fridgeMap = SpriteTileMap("maze.txt", "sprites.txt")
#fPlayer navigates through the maze
#sPlayer kills the mold, defends fPlayer
fPlayer = Food()
sPlayer = SprayBottle()
#mold objects try to attack the food player
mold1 = Mold('blue')
mold2 = Mold('green')
mold3 = Mold('blue')
mold4 = Mold('green')
mold5 = Mold('blue')
mold6 = Mold('green')
mold7 = Mold('blue')
mold8 = Mold('green')
done = False
#game loop
while not done:
mouseX, mouseY = pygame.mouse.get_pos()
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
#arrow keys are assigned to the navigation movements
#of fPlayer
key = pygame.key.get_pressed()
if key[pygame.K_RIGHT]:
fPlayer.move("RIGHT", fridgeMap)
elif key[pygame.K_LEFT]:
fPlayer.move("LEFT", fridgeMap)
elif key[pygame.K_UP]:
fPlayer.move("UP", fridgeMap)
elif key[pygame.K_DOWN]:
fPlayer.move("DOWN", fridgeMap)
#sPlayer moves with the mouse
if event.type == pygame.MOUSEMOTION:
sPlayer.move(mouseX, mouseY)
if event.type == pygame.MOUSEBUTTONDOWN:
mold1.decideNextState(sPlayer)
mold2.decideNextState(sPlayer)
mold3.decideNextState(sPlayer)
mold4.decideNextState(sPlayer)
mold5.decideNextState(sPlayer)
mold6.decideNextState(sPlayer)
print (isCollide(sPlayer,mold1))
totalSeconds = startTime - (frameCount // frameRate)
if totalSeconds < 0:
totalSeconds = 0
minutes = totalSeconds // 60
seconds = totalSeconds % 60
outputString = "Time left: {0:02}:{1:02}".format(minutes,seconds)
text = font.render(outputString, True, (255,255,255))
mold1.move()
#mold2.move()
#mold3.move()
#mold4.move()
#mold5.move()
#mold6.move()
frameCount += 1
clock.tick(frameRate)
pygame.display.flip()
fridgeMap.drawMap(screen)
screen.blit(fPlayer.getImage(), (fPlayer.getX(), fPlayer.getY()))
screen.blit(mold1.getImage(), (mold1.getX(), mold1.getY()))
screen.blit(mold2.getImage(), (mold2.getX(), mold2.getY()))
screen.blit(mold3.getImage(), (mold3.getX(), mold3.getY()))
screen.blit(mold4.getImage(), (mold4.getX(), mold4.getY()))
screen.blit(mold5.getImage(), (mold5.getX(), mold5.getY()))
screen.blit(mold6.getImage(), (mold6.getX(), mold6.getY()))
screen.blit(sPlayer.getImage(), (sPlayer.getX(), sPlayer.getY()))
pygame.draw.rect(screen, [250, 74, 47], [510, 10, 160, 40])
screen.blit(text, [520, 23])
def game(levels):
global level
level = levels
global foodlet
global wormlet
foodlet = Food()
prt1=Loc(250,250)
wormlet = Worm([prt1])
game = True
while game == True:
last = copy.deepcopy(wormlet.get(wormlet.length()-1))
events = pygame.event.get()
for event in events:
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
wormlet.setdir('left')
elif event.key == pygame.K_RIGHT:
wormlet.setdir('right')
elif event.key == pygame.K_UP:
wormlet.setdir('up')
elif event.key == pygame.K_DOWN:
wormlet.setdir('down')
elif event.key == pygame.K_q:
game = False
elif event.key == pygame.K_p:
a = pause()
if a == 'menu':
game = False
wormlet.update() #advances worm in its direction
first=wormlet.get(0)
if foodlet.getlocation() == wormlet.getlocation():
wormlet.add(last)
foodlet.reset()
while (level.checkloc(foodlet.getlocation()) == True or wormlet.checkloc(foodlet.getlocation()) == True):
foodlet.reset()
display()
if (level.checkloc(first) == True):
game = False
for x in range (1, wormlet.length()):
if first == wormlet.get(x):
game = False
window.blit(pygame.transform.smoothscale(screen,(ssize)),(0,0))
pygame.display.flip()
pygame.display.update()
if level.num == 2:
pygame.time.wait(45)
elif level.num == 1:
pygame.time.wait(65)
else:
pygame.time.wait(80)
from Food import Food
from Worm import Worm
w = 500
h = 500
screen = pygame.display.set_mode((w, h))
clock = pygame.time.Clock()
pygame.mixer.init()
chomp = pygame.mixer.Sound("chomp.wav")
score = 0
worm = Worm(screen)
food = Food(screen)
running = True
while running:
screen.fill((0, 0, 0))
worm.move()
worm.draw()
food.draw()
if worm.crashed:
running = False
elif worm.x <= 0 or worm.x >= w - 1:
running = False
elif worm.y <= 0 or worm.y >= h - 1:
running = False
elif food.check(worm.x, worm.y):
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()