def __init__(self, width=640, height=480):
self.width = width
self.height = height
self.victory = False
self.running = False
self.exiting = False
self.player_num = 1
self.current_piece = pygame.sprite.GroupSingle()
self.clock = pygame.time.Clock()
self.read_spim()
self.read_spim()
self.read_spim()
self.read_spim()
self.read_spim()
while not self.exiting:
self.screen = MenuScreen(width, height)
logging.root.info("State: Menu")
self.menu()
self.screen = GameScreen(width, height)
logging.root.info("State: Game")
self.run()
def build(self):
Builder.load_file('./screen.kv')
Builder.load_file('./board.kv')
Builder.load_file('./block.kv')
self.set_screen_size()
return GameScreen()
def __init__(self):
pygame.init()
#screen = pygame.display.set_mode(size)
self.clock = pygame.time.Clock()
pygame.mouse.set_visible(1)
self.gameLogic = GameLogic(self.load(mapOfWorld))
self.screenLogic = GameScreen(self.gameLogic)
def __init__(self):
pygame.mixer.pre_init(44100,-16,2,2048)
pygame.init()
self.sounds=Sounds()
self.input_handler = InputHandler()
self.game_screen = GameScreen(self.TITLE,self.WIDTH,self.HEIGHT)
self.miner=Miner(8,0)
self.explosion=Explosion(-1,-1)
self.game_screen.add_sprite(self.miner)
self.game_screen.add_sprite(self.explosion)
self.health = 100
self.clock=pygame.time.Clock()
self.state=self.WAITING
self.game_screen.display_opening()
class Game(object):
def __init__(self, width=640, height=480):
self.width = width
self.height = height
self.victory = False
self.running = False
self.exiting = False
self.player_num = 1
self.current_piece = pygame.sprite.GroupSingle()
self.clock = pygame.time.Clock()
self.read_spim()
self.read_spim()
self.read_spim()
self.read_spim()
self.read_spim()
while not self.exiting:
self.screen = MenuScreen(width, height)
logging.root.info("State: Menu")
self.menu()
self.screen = GameScreen(width, height)
logging.root.info("State: Game")
self.run()
def read_spim(self):
data = None
try:
rdata, __, __ = select.select([spim.stdout.fileno()], [], [], 0.001)
except select.error as err:
logging.root.error("Error: %s" % err.args[0])
raise
if rdata:
data = spim.stdout.readline()
spim.stdout.flush()
data = data[:-1] # remove newline
logging.root.debug("Found Data: %s" % data)
return data
def write_spim(self, data):
dbg_data = data.replace("\n", "\\n")
logging.root.debug("WRITE SPIM: %s" % dbg_data)
spim.stdin.write(data)
def parse_data(self, data):
header = data[0:3]
logging.root.debug("Header = %s" % header)
if header == "111":
board_state = []
state = []
column = 0
even = True
for datum in data[3:]:
if column % 4 == 0:
state.reverse()
board_state = state + board_state
even = not even
state = []
if not even:
state.insert(0, 0)
datum = int(datum)
if datum < 4:
state.insert(0, 0)
elif datum == 4:
state.insert(0, 1)
elif datum == 5:
state.insert(0, 3)
elif datum == 6:
state.insert(0, 2)
elif datum == 7:
state.insert(0, 4)
if even:
state.insert(0, 0)
column = column + 1
state.reverse()
board_state = state + board_state
self.screen.state = board_state
return self.screen.state
elif header == "110":
return self.screen.state
def menu(self):
while not self.running:
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_UP:
logging.root.debug("Choosing One Player")
self.player_num = 1
elif event.key == pygame.K_DOWN:
logging.root.debug("Choosing Two Player")
self.player_num = 0
elif event.key == pygame.K_RETURN:
logging.root.debug("Chosing Return Value: %d" % self.player_num)
self.write_spim(str(self.player_num) + "\n") #Determines AI/P2
self.running = True
elif event.key == pygame.K_ESCAPE:
self.exiting = True
return
elif event.type == pygame.QUIT:
self.exiting = True
return
p1 = "One Player"
p2 = "Two Player"
if self.player_num == 1:
p1 = "[ " + p1 + " ]"
elif self.player_num == 0:
p2 = "[ " + p2 + " ]"
self.screen.draw_choices(p1, p2)
pygame.display.flip()
self.clock.tick(FPS)
def run(self):
state = P1_MOVE
state_changed = True
data = self.read_spim()
if data:
self.parse_data(data)
logging.root.info("State: P1_MOVE")
while self.running:
for event in pygame.event.get([pygame.QUIT, pygame.KEYDOWN]):
if event.type == pygame.QUIT:
self.exiting = True
return
quit_game()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
self.exiting = True
return
quit_game()
if state_changed:
self.screen.draw_board()
self.screen.draw_pieces(self.screen.state)
pygame.display.flip()
state_changed = False
if state == P1_MOVE:
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONUP:
pos = pygame.mouse.get_pos()
for sprite in self.screen.button_group:
if sprite.rect.collidepoint(pos):
if sprite.btype == END_OF_TURN:
self.write_spim(str(END_OF_TURN) + "\n")
if self.player_num == 0:
state = P2_MOVE
self.screen.draw_window(turn="Blacks Turn")
pygame.display.flip()
logging.root.info("State: P2_MOVE")
else:
state = P2_AI
elif sprite.btype == RESTART:
self.write_spim(str(RESTART) + "\n")
Game()
self.exiting = True
return
for sprite in self.screen.p1_group:
if sprite.rect.collidepoint(pos):
self.current_piece = sprite
state = P1_MOVE_CLICKED
logging.root.info("State: P1_MOVE_CLICKED")
elif state == P1_MOVE_CLICKED:
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONUP:
self.current_piece.update(pygame.mouse.get_pos())
state = P1_VALIDATE
pos = (self.current_piece.old_xpos, self.current_piece.old_ypos)
self.write_spim(self.current_piece.print_boardpos(pos) + "\n")
pos = (self.current_piece.xpos, self.current_piece.ypos)
self.write_spim(self.current_piece.print_boardpos(pos) + "\n")
logging.root.info("State: P1_VALIDATE")
self.screen.p1_group.clear(self.screen.screen, self.screen.bg)
self.screen.p1_group.draw(self.screen.screen)
self.screen.p2_group.draw(self.screen.screen)
pygame.display.flip()
elif state == P1_VALIDATE:
data = self.read_spim()
if data:
state = P1_MOVE
state_changed = True
self.parse_data(data)
logging.root.info("State: P1_MOVE")
elif state == P2_AI:
self.screen.draw_window(turn="Waiting for AI...")
pygame.display.flip()
data = None
while data is None:
data = self.read_spim()
self.screen.state = self.parse_data(data)
state = P1_MOVE
state_changed = True
self.screen.draw_window(turn="Reds Turn")
pygame.display.flip()
elif state == P2_MOVE:
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONUP:
pos = pygame.mouse.get_pos()
for sprite in self.screen.button_group:
if sprite.rect.collidepoint(pos):
if sprite.btype == END_OF_TURN:
self.write_spim(str(END_OF_TURN) + "\n")
self.screen.draw_window(turn="Reds Turn")
pygame.display.flip()
state = P1_MOVE
logging.root.info("State: P1_MOVE")
elif sprite.btype == RESTART:
self.write_spim(str(RESTART) + "\n")
Game()
self.exiting = True
return
for sprite in self.screen.p2_group:
if sprite.rect.collidepoint(pos):
self.current_piece = sprite
state = P2_MOVE_CLICKED
logging.root.info("State: P2_MOVE_CLICKED")
elif state == P2_MOVE_CLICKED:
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONUP:
self.current_piece.update(pygame.mouse.get_pos())
pos = (self.current_piece.old_xpos, self.current_piece.old_ypos)
self.write_spim(self.current_piece.print_boardpos(pos) + "\n")
pos = (self.current_piece.xpos, self.current_piece.ypos)
self.write_spim(self.current_piece.print_boardpos(pos) + "\n")
state = P2_VALIDATE
logging.root.info("State: P2_VALIDATE")
self.screen.p2_group.clear(self.screen.screen, self.screen.bg)
self.screen.p2_group.draw(self.screen.screen)
self.screen.p1_group.draw(self.screen.screen)
pygame.display.flip()
elif state == P2_VALIDATE:
data = self.read_spim()
if data:
state = P2_MOVE
state_changed = True
self.parse_data(data)
logging.root.info("State: P2_MOVE")
self.clock.tick(FPS)
class Game(object):
TITLE = "Gold Rush!"
WIDTH=680
HEIGHT=600
WAITING = 1
PLAYING = 2
FRAMES_PER_SECOND = 30
board=[]
def __init__(self):
pygame.mixer.pre_init(44100,-16,2,2048)
pygame.init()
self.sounds=Sounds()
self.input_handler = InputHandler()
self.game_screen = GameScreen(self.TITLE,self.WIDTH,self.HEIGHT)
self.miner=Miner(8,0)
self.explosion=Explosion(-1,-1)
self.game_screen.add_sprite(self.miner)
self.game_screen.add_sprite(self.explosion)
self.health = 100
self.clock=pygame.time.Clock()
self.state=self.WAITING
self.game_screen.display_opening()
def setup(self):
self.gold=0
self.charges=10
self.cash=0
self.health=100
self.board=[]
# top row of empty spaces
self.board.append([' ']*20)
self.board.append(['*']*20)
for y in range(2,14):
row=[]
for x in range(20):
c='*'
if y>1 and random()<0.4:
c=' '
if random()<0.5:
c='0'
else:
c='1'
row.append(c)
self.board.append(row)
self.miner.set_location(8,0)
self.game_screen.setup()
self.game_screen.set_board(self.board)
self.game_screen.draw_board()
def mainloop(self):
deltat=self.clock.tick(self.FRAMES_PER_SECOND)
running=True
while running:
self.input_handler.check()
if self.input_handler.exit_action:
running=False
elif self.state == self.WAITING:
if self.input_handler.key_press:
self.setup()
self.state=self.PLAYING
else:
self.game_screen.clear_sprites()
if self.miner.can_move():
kpress=self.input_handler.arrow_press
if kpress:
dx=0
dy=0
if kpress == K_RIGHT:
dx=1
elif kpress == K_LEFT:
dx=-1
elif kpress == K_UP:
dy=-1
elif kpress == K_DOWN:
dy=1
if self.input_handler.space_press and (dx!=0 or dy!=0):
self.do_explosion(dx,dy)
tx=self.miner.x + dx
ty=self.miner.y + dy
if (dx!=0 or dy!=0) and (tx>=0 and tx<=19 and ty>=0 and ty<=13):
o=self.board[ty][tx]
if o in ' 01':
self.miner.set_location(tx,ty)
if o in '01':
self.take_nugget(tx,ty)
elif (dy==-1 and tx==17 and ty==-1 and self.gold!=0):
self.cash_out()
if self.charges==0:
self.state=self.WAITING
self.input_handler.reset()
self.game_screen.display_gameover()
if self.miner.y>0:
self.health-=1
if self.health<0:
self.health=0
self.game_screen.display_health(self.health)
else:
self.health+=1
if self.health>100:
self.health=100
self.game_screen.display_health(self.health)
self.game_screen.draw(deltat)
pygame.quit()
def do_explosion(self,dx,dy):
bx=self.miner.x + dx
by=self.miner.y + dy
if bx>=0 and bx<20 and (by>0 or (by==0 and dy==1)) and by<14 and self.charges>0:
self.explosion.explode(bx,by)
self.charges-=1
self.board[by][bx]=' '
self.miner.add_delay(20)
self.game_screen.clear_square(bx,by)
self.game_screen.display_charges()
self.sounds.play_boom()
self.game_screen.display_charges(self.charges)
for j in range(20):
x=randint(0,19)
y=randint(2,11)
o=self.board[y][x]
a=self.board[y-1][x]
if o==' ' and a=='*':
self.board[y][x]='*'
self.game_screen.reset_square(x,y)
def cash_out(self):
self.cash+=self.gold*self.charges
self.gold=0
self.sounds.play_kaching()
self.game_screen.display_gold(self.gold)
self.game_screen.display_cash(self.cash)
self.sounds.play_yeehaw()
def take_nugget(self,tx,ty):
self.board[ty][tx]=' '
self.gold += 1
self.sounds.play_bell()
self.game_screen.clear_square(tx,ty)
self.game_screen.display_gold(self.gold)
class Game(object):
def __init__(self):
pygame.init()
#screen = pygame.display.set_mode(size)
self.clock = pygame.time.Clock()
pygame.mouse.set_visible(1)
self.gameLogic = GameLogic(self.load(mapOfWorld))
self.screenLogic = GameScreen(self.gameLogic)
def load(self, mymap):
tileMap = []
x, y = (0,0)
for line in mymap:
tileLine = []
for value in line:
try:
tile = tilesObject[value]
except KeyError:
return "Error on key"
# problem due to DOOR and polymorphism ... :/
#print tile["bgcolor"]
obj = tile['cls'] (char = value , position = (x,y), **tile ['args'] )
#obj = tile["obj"](name=tile["name"], position=(x, y), char=value, blocked=tile["block"], bgcolor=tile["bgcolor"])
x += 1
tileLine.append(obj)
x = 0
y += 1
tileMap.append(tileLine)
return tileMap
def handle_event(self):
event = pygame.event.wait()
if event.type == KEYDOWN:
key = event.key
if key == K_UP:
self.gameLogic.movePlayer(0, -1)
elif key == K_RIGHT:
self.gameLogic.movePlayer(1, 0)
elif key == K_DOWN:
self.gameLogic.movePlayer(0, 1)
elif key == K_LEFT:
self.gameLogic.movePlayer(-1, 0)
else:
if key == K_i:
print "gestion inventaire"
elif key == K_e:
self.gameLogic.player.take()
return "notEndOfTurn"
elif event.type == QUIT:
return "endOfGame"
def run(self):
state=None
pygame.event.set_allowed(None)
pygame.event.set_allowed([KEYDOWN,QUIT])
count = 0
while state != "endOfGame":
# redraw screen
self.screenLogic.redraw()
pygame.display.update()
self.clock.tick(60)
# state ?
state = self.handle_event()
if state != "notEndOfTurn":
# ai Turn
self.gameLogic.aiTurn()
count +=1
#pygame.display.flip()
pygame.quit()
digits = {
str(num): pygame.image.load(f"images/{num}.png")
for num in range(10)
}
# Load sounds
point_sound = pygame.mixer.Sound("audio/point.wav")
swoosh_sound = pygame.mixer.Sound("audio/swoosh.wav")
hit_sound = pygame.mixer.Sound("audio/hit.wav")
die_sound = pygame.mixer.Sound("audio/die.wav")
bg_height = background.get_height()
# initialize objects
screen = GameScreen(background=background,
base=base,
gameover_sign=gameover_sign,
digits=digits)
bird = Bird(screen=screen.screen,
bg_height=bg_height,
jump_acc=BIRD_JUMP_ACC,
bird_images=bird_images,
bird_die_image=bird_die,
swoosh_sound=swoosh_sound,
score_sound=point_sound,
hit_sound=hit_sound,
die_sound=die_sound,
gravity=GRAVITY)
pipe_system = PipeSystem(bird=bird,
n_pipes=2,
