class GameState (State):
def __init__(self, window, level, diff, pair_generator, win_conditions, *args, **kwargs):
print "++++ new game state"
self.level = level
self.diff = diff
self.pair_generator = pair_generator
self.win_conditions = win_conditions
State.__init__(self, window, "game", *args, **kwargs)
self.build_scene()
self.current_rung = None
self.longest_streak = 0
self.time = 0
self.mutation_counter = 0
def build_scene(self):
self.camera = Camera((0.0, -8.0, 1.0), (0,0,1.0))
self.score = Score(0)
self.streak = Streak(0)
self.atcg_display = ATCGDisplay()
self.endzone = EndZone((-1.4,0,-1.3), 2.8, 0.18)
self.attaboy = MsgQueue()
self.mutation = Mutation(0)
if self.win_conditions.has_key('time'):
self.timer = Timer(self.win_conditions['time'])
else:
self.timer = None
# speed_dif = self.level * 0.07 * (self.diff*0.8)
# spawn_dif = self.level * 0.07 + (self.diff*0.03)
## lower down
# self.helix = Helix(speed = 0.7 + speed_dif, spawn_rate=0.7-spawn_dif,
# starthgt=7, endhgt=-5, spins=2.5, pair_generator=self.pair_generator)
if self.level >= 4:
starthgt = 7
endhgt = -2.5
spins = 2.5
else:
starthgt = 5
endhgt = -2.5
spins = 1.5
l, d = self.level, self.diff
speed_dif = 0.8 + (l * 0.04 * (d*0.6))
spawn_dif = 0.5 - (l * 0.07 * (d*0.09))
self.helix = Helix(speed = speed_dif, spawn_rate=spawn_dif,
starthgt=starthgt, endhgt=endhgt, spins=spins, pair_generator=self.pair_generator)
self.helix.register_callbacks(self.enter_callback, self.exit_callback)
# for n in range(100):
# self.helix.update(0.1)
self.attaboy.add_centered_fade("level %d\n%s\n%s" % (self.level,
diff[self.diff], messages.EASY_LEVELS[self.level]), 0.2, 0.1)
def enter_callback(self, r):
self.current_rung = r
def exit_callback(self, r):
if r.get_pair_data()[0] == None or r.get_pair_data()[1] == None:
self.bad_move()
self.current_rung = None
def destroy_scene(self):
pass
def on_draw(self):
set3D(self.window)
self.window.clear()
glLoadIdentity()
self.camera.focus()
batch.get_batch().draw()
set2D(self.window)
return pyglet.event.EVENT_HANDLED
def bad_move(self):
audio.play_sound('lose_streak')
r = self.current_rung
if r:
r.miss()
self.camera.shake(1,2, 1)
self.attaboy.add_centered_fade(messages.random_bad_move(), 0.25, 1, ([0.7,0.7,0.7,1.0], [0.1,0.1,0.1,1.0]))
self.streak.reset()
l, d = self.level, self.diff
self.helix.mutate(0.2 + (l * 0.04))
self.mutation_counter += 5 * (self.level*0.5)
if self.mutation_counter > 100:
self.lose()
self.mutation.set_mutation(self.mutation_counter)
def good_move(self):
audio.play_sound('hit')
r = self.current_rung
if r:
r.hit()
if self.mutation_counter > 1:
self.mutation_counter -= 1
self.mutation.set_mutation(self.mutation_counter)
s = self.streak.inc()
p = s*0.5*100
self.attaboy.add_score_fade(p)
self.score.inc_score(p)
def on_key_press(self, k, args):
## =A++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++===
if k == key.A:
self.atcg_display.A.on()
if check_hit('A', self.current_rung):
self.good_move()
else:
self.bad_move()
## =S++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++===
elif k == key.S:
self.atcg_display.T.on()
if check_hit('T', self.current_rung):
self.good_move()
else:
self.bad_move()
## =D++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++===
elif k == key.D:
self.atcg_display.C.on()
if check_hit('C', self.current_rung):
self.good_move()
else:
self.bad_move()
## =F++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++===
elif k == key.F:
self.atcg_display.G.on()
if check_hit('G', self.current_rung):
self.good_move()
else:
self.bad_move()
## ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
elif k == key.LEFT:
pass
elif k == key.RIGHT:
pass
elif k == key.ESCAPE:
self.pause()
return pyglet.event.EVENT_HANDLED
elif k == key.F11:
if self.window.fullscreen:
self.window.set_fullscreen(False)
else:
self.window.set_fullscreen(True)
return pyglet.event.EVENT_HANDLED
def on_key_release(self, k, args):
if k == key.A:
self.atcg_display.A.off()
elif k == key.S:
self.atcg_display.T.off()
elif k == key.D:
self.atcg_display.C.off()
elif k == key.F:
self.atcg_display.G.off()
return pyglet.event.EVENT_HANDLED
def on_mouse_scroll(self, x, y, scroll_x, scroll_y):
pass
def lose(self):
self.window.pop_state()
self.window.replace_state(transitions.ScriptedTransition, script=script.lose, script_name="lose")
def win(self):
self.window.replace_state(transitions.ScriptedTransition, script=script.win, script_name="win")
def on_lose_focus(self):
pyglet.clock.unschedule(self.on_update)
return pyglet.event.EVENT_HANDLED
def on_gain_focus(self):
self.helix.unobscure()
self.helix.update(0.1)
pyglet.clock.schedule_interval(self.on_update, 1.0/60.0)
return pyglet.event.EVENT_HANDLED
def check_win_conditions(self):
if self.win_conditions.has_key('score'):
if self.score.points > self.win_conditions['score']:
self.win()
elif self.win_conditions.has_key('streak'):
if self.streak.streak >= self.win_conditions['streak']:
self.win()
elif self.win_conditions.has_key('time'):
if self.timer.time < 0:
self.win()
def on_update(self, dt):
self.camera.update(dt)
self.attaboy.update(dt)
self.atcg_display.update(dt)
self.check_win_conditions()
self.helix.update(dt)
if self.win_conditions.has_key('time'):
self.timer.update_time(dt)
def pause(self):
self.helix.obscure()
self.helix.update(0.1)
self.window.push_state(transitions.Pause, "game")
class Game(object):
"""this is the Game class"""
def __init__(self):
pygame.mixer.pre_init(48000,-16,2, 1024) #Sound Settings
pygame.init()
#sets the screen resolution for the game and sets a rect for the game screen
self.screen = pygame.display.set_mode((1024,768))
self.screen_rect = self.screen.get_rect()
#initializes a clock for the game
self.clock = pygame.time.Clock()
#initializes a menu object and HUD object and Score object
self.menu = Menu()
self.hud = Hud()
self.score = Score()
#sets a boolean for whether you are still in the menu or not
self.inMenu = True
#sets a camera for the world
self.camBorder = 32
self.cam = Camera(pygame.Rect(100, 100, 1024, 768), pygame.Rect(self.camBorder, self.camBorder, 2048 - self.camBorder, 1536 - self.camBorder))
self.camShakeFactor = 0 #Magnitude of shake
self.camShakeDecayFactor = 0.08 #Lerp Amount
#Timing
self.timer = pygame.time.get_ticks()
self.elapsed = 0
#Sound Controller
self.soundCon = SoundCon()
#Game Values
self.backgroundImg = pygame.image.load("Images/Arena/Arena2.png").convert_alpha()
self.backgroundImgRect = self.backgroundImg.get_rect()
self.player = Player( self.hud )
#Effects
self.effectInstances = []
self.spawnSound = pygame.mixer.Sound("Sounds/ShipRev.wav")
self.deathSound = pygame.mixer.Sound("Sounds/shipExplo.wav")
self.enemyExplo = pygame.mixer.Sound("Sounds/enemyExplo.wav")
self.clashSound = pygame.mixer.Sound("Sounds/clash.wav")
self.boostSound = pygame.mixer.Sound("Sounds/boostLow.wav")
#Game over fade out
self.fadeImage = pygame.image.load("Images/HUD/CrackedGlass.png").convert_alpha()
self.fadeRect = self.fadeImage.get_rect()
self.fadeSurface = pygame.Surface((1024, 768), pygame.SRCALPHA)
self.fadeSurfaceAlpha = 0
self.fadeSurfaceRate = 1
self.doFade = False
self.restartGame = False
#Enemies
self.enemyList = []
self.baseNumEnemies = 2
self.spawnTime = 10
self.currentSpawnTime = 30
def process_events(self):
"""process all game events"""
#sets a variable containing the position of the mouse
self.mousePos = pygame.mouse.get_pos()
for event in pygame.event.get():
if self.inMenu:
#passes the current event and mouse position to the menu's 'process_events' function
self.inMenu = self.menu.process_events(event, self.mousePos)
else:
#Run everything else's 'process_events' functions
#print("This is where the game would process events")
self.readInputs( event )
if event.type == pygame.KEYDOWN:
#exits the program if the esc key is pressed
if event.key == pygame.K_ESCAPE:
sys.exit(0)
def readInputs(self, event):
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
sys.exit(0)
if event.key == pygame.K_w or event.key == pygame.K_UP:
self.player.moving[0] = True
if event.key == pygame.K_s or event.key == pygame.K_DOWN:
self.player.moving[1] = True
if event.key == pygame.K_a or event.key == pygame.K_LEFT:
self.player.moving[2] = True
if event.key == pygame.K_d or event.key == pygame.K_RIGHT:
self.player.moving[3] = True
if event.key == pygame.K_SPACE or event.key == pygame.K_z:
self.player.moving[4] = True
self.boostSound.play()
if event.key == pygame.K_p:
self.soundCon.currentTime = 30
self.currentSpawnTime = 1
self.player.currentInvincTime = 1
if event.type == pygame.KEYUP:
if event.key == pygame.K_w or event.key == pygame.K_UP:
self.player.moving[0] = False
if event.key == pygame.K_s or event.key == pygame.K_DOWN:
self.player.moving[1] = False
if event.key == pygame.K_a or event.key == pygame.K_LEFT:
self.player.moving[2] = False
if event.key == pygame.K_d or event.key == pygame.K_RIGHT:
self.player.moving[3] = False
if event.key == pygame.K_SPACE or event.key == pygame.K_z:
self.player.moving[4] = False
self.boostSound.stop()
def update(self):
"""updates the game"""
if not self.inMenu:
self.player.update(self.cam )
self.cam.move_to(self.player.pos[0], self.player.pos[1])
self.soundCon.update()
#Enemy Spawning
self.elapsed = (pygame.time.get_ticks() - self.timer) / 1000.0
self.currentSpawnTime -= self.elapsed
if ( self.currentSpawnTime <= 0 ):
self.currentSpawnTime = self.spawnTime
self.spawnEnemy()
#Enemy update
for tempEnemy in self.enemyList:
tempEnemy.update(self.cam)
self.player.checkColl(tempEnemy, self.cam, self)
#Check enemy deaths
for tempEnemy in self.enemyList:
if tempEnemy.deathFlag:
self.score.total += 100
self.makeLineBurst( tempEnemy.rect.centerx, tempEnemy.rect.centery, tempEnemy.deathAngle, 60, 200, 50, (255,255,0), 0.1, True )
self.makeLineBurst( tempEnemy.rect.centerx, tempEnemy.rect.centery, tempEnemy.deathAngle, 60, 200, 50, (255,255,255), 0.1, True )
self.makeLineBurst( self.player.rect.centerx, self.player.rect.centery, 0, 360, 100, 50, (255,255,255), 0.05, True )
self.makeLineBurst( self.player.rect.centerx, self.player.rect.centery, 0, 360, 100, 40, (255,0,0), 0.05, True )
self.enemyExplo.play()
self.enemyList.remove( tempEnemy )
self.spawnEnemy()
#Effect update
for effect in self.effectInstances:
if not effect.active:
self.effectInstances.remove( effect )
#Shake and Decay
self.camShakeFactor = self.camShakeFactor - ( self.camShakeFactor * self.camShakeDecayFactor )
if ( self.camShakeFactor < 1 ):
self.camShakeFactor = 0
self.cam.shake(random.random() * self.camShakeFactor, random.random() * self.camShakeFactor)
#Player boost effect
if ( self.player.boosting ):
self.makeLineBurst( self.player.rect.centerx, self.player.rect.centery, -self.player.ang * 180 / math.pi + 180, 30, 3, 30, (255,255,155), 0.1, True )
self.makeLineBurst( self.player.rect.centerx, self.player.rect.centery, -self.player.ang * 180 / math.pi + 180, 30, 3, 30, (255,0,0), 0.1, True )
if ( self.player.thrusting ):
self.makeLineBurst( self.player.rect.centerx, self.player.rect.centery, -self.player.ang * 180 / math.pi + 180, 20, 2, 20, (255,255,255), 0.1, True )
#Update Score in HUD
self.hud.updateScore(self.score.getTotal())
#Death
if self.player.dead and self.player.canMakeDeadEffect:
self.player.canMakeDeadEffect = False
self.shakeScreen( 64 )
self.soundCon.playDeathSound()
self.deathSound.play()
#self.makeExplosion( 500, 500, "Images/Effects/Explosion2Spr.png", 200, 200, 8, 8, True)
self.makeLineBurst( self.player.rect.centerx, self.player.rect.centery, 0, 360, 200, 30, (255,255,0), 0.1, True )
self.makeLineBurst( self.player.rect.centerx, self.player.rect.centery, 0, 360, 200, 30, (255,0,0), 0.1, True )
self.makeLineBurst( self.player.rect.centerx, self.player.rect.centery, 0, 360, 100, 30, (255,155,0), 0.05, True )
self.makeLineBurst( self.player.rect.centerx, self.player.rect.centery, 0, 360, 100, 40, (255,0,0), 0.05, True )
self.makeLineBurst( self.player.rect.centerx, self.player.rect.centery, 0, 360, 100, 50, (255,255,255), 0.05, True )
self.player.numLives -= 1
if ( self.player.numLives <= 0 ):
self.doFade = True
self.player.currentDeadTime = 30
if ( self.player.reformEffect ):
self.player.reformEffect = False;
self.spawnSound.play()
self.makeLineBurst( self.player.rect.centerx, self.player.rect.centery, 0, 360, 150, 15, (255,255,255), 0.1, False )
self.makeLineBurst( self.player.rect.centerx, self.player.rect.centery, 0, 360, 150, 30, (255,255,255), 0.1, False )
self.makeLineBurst( self.player.rect.centerx, self.player.rect.centery, 0, 360, 150, 50, (255,255,255), 0.1, False )
self.timer = pygame.time.get_ticks()
def shakeScreen(self, magnitude):
self.camShakeFactor = magnitude #Magnitude of shake
def makeLineBurst(self, x, y, direction, spread, count, maxSpeed, color, lerpPercent, doRandom):
newBurst = LineBurst( x, y, direction, spread, count, maxSpeed, color, lerpPercent, doRandom )
self.effectInstances.append( newBurst )
def makeExplosion(self, x, y, imagePath, imageWidth, imageHeight, numFrames, imageSpeed, doLoop):
newAnim = EffectAnimation( x, y, imagePath, imageWidth, imageHeight, numFrames, imageSpeed, doLoop )
self.effectInstances.append( newAnim )
def spawnEnemy(self):
if ( len(self.enemyList) == 0 ):
for i in range( self.baseNumEnemies ):
self.enemyList.append(AI(self.player, self.cam, self))
else:
self.enemyList.append(AI(self.player, self.cam, self))
def draw(self):
"""draw the gameworld"""
self.screen.fill((0,0,0))
if self.inMenu:
#calls the menu's draw function
self.menu.draw(self.screen)
else:
#Draw the regular game
backRect = self.backgroundImgRect.move(-self.cam.rect.x + self.camBorder / 2, -self.cam.rect.y + self.camBorder / 2)
self.screen.blit(self.backgroundImg, backRect)
self.player.draw( self.screen, self.cam )
#Enemy draw
for tempEnemy in self.enemyList:
tempEnemy.draw(self.screen, self.cam)
#Effect draw
for effect in self.effectInstances:
effect.draw(self.screen, self.cam)
#HUD draw
self.hud.draw(self.screen)
#Game Over fade
if self.doFade:
self.fadeSurfaceAlpha += self.fadeSurfaceRate
if ( self.fadeSurfaceAlpha >= 255 ):
self.inMenu = True
pygame.mixer.stop()
pygame.mixer.music.stop()
self.restartGame = True
else:
self.fadeSurface.fill((0,0,0,self.fadeSurfaceAlpha))
self.fadeSurface.set_alpha( self.fadeSurfaceAlpha )
#tempRect = self.fadeRect.move(-self.cam.rect.x, -self.cam.rect.y)
self.fadeSurface.blit(self.fadeImage, (0,0))
self.screen.blit(self.fadeSurface,(-self.cam.rect.x + self.cam.rect.left,-self.cam.rect.y + self.cam.rect.top))
class GameMode(mode.Mode):
name = "game_mode"
STEP_SIZE = 15
SLOW_START = 120
FPS_FONT_SIZE = 10
def __init__(self, editor_mode=True, level_name=None):
super(GameMode, self).__init__()
self.editor_mode = editor_mode
self.level_name = level_name
def connect(self, controller):
super(GameMode, self).connect(controller)
self.tool = TriggerTool()
self.alt_tool = EraseTool()
self.init_opengl()
self.skip_level = False
self.game_complete = False
self.fps_magic = pyglet.clock.ClockDisplay(font=pyglet.font.load([], self.FPS_FONT_SIZE))
self.mouse_pos = (self.window.width / 2, self.window.height / 2)
self.renderer = None
if not self.level_name:
self.level_name = self.get_default_level_name()
grid, level_help = self.load_grid_from_file(self.level_name)
self.game_session = session.Session(grid)
self.game_status = None
self.level_help = None
self.charge_player = None
if level_help and not self.editor_mode:
level_help += '\n\nClick to continue.\n'
font = gui.GameMenuFont()
self.level_help = TextFloat(level_help, 0, -200, 500, font.name, 12)
self.init_level()
self.init_renderer()
self.init_gui()
self.init_camera()
def init_camera(self):
grid = self.game_session.game.grid
if grid:
minx = miny = float("Inf")
maxx = maxy = float("-Inf")
for x, y in grid:
minx = min(minx, x)
miny = min(miny, y)
maxx = max(maxx, x)
maxy = max(maxy, y)
else:
minx = miny = maxx = maxy = 0
cx = minx + (maxx - minx) / 2
cy = miny + (maxy - miny) / 2
self.camera = Camera(Vector3(cx, cy, 20), Vector3(cx, cy, 0), Vector3(0, 1, 0))
self.camera.resize(0, 0, self.window.width, self.window.height)
def disconnect(self):
self.delete_renderer()
self.shutdown_opengl()
self.stop_charge_player()
def init_opengl(self):
glLoadIdentity()
glEnable(GL_COLOR_MATERIAL)
glEnable(GL_LIGHTING)
glEnable(GL_LIGHT0)
glEnable(GL_DEPTH_TEST)
glLightfv(GL_LIGHT0, GL_POSITION, ptr(5, 5, 5, 1))
glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, ptr(5, 5, -5, 1))
glLightfv(GL_LIGHT0, GL_DIFFUSE, ptr(.8, .8, .8, 1))
glLightfv(GL_LIGHT0, GL_SPECULAR, ptr(.8, .8, .8, 1))
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, ptr(.5, .5, .5, 1))
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, ptr(0, 0, 0, 0))
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 0)
def shutdown_opengl(self):
glDisable(GL_LIGHTING)
glDisable(GL_DEPTH_TEST)
def init_renderer(self):
self.renderer = render.GameRenderer(self.game_session.game)
def delete_renderer(self):
if self.renderer:
self.renderer.delete()
self.renderer = None
def init_gui(self):
font = gui.GameMenuFont()
build_menu = gui.Submenu([(cls.human_name, font, gui.SELECT, DrawTool(cls)) for cls in core.ALL_BLOCKS])
build_menu.choices.append((gui.LABEL_REMOVE, font, gui.SELECT, EraseTool()))
self.b_start_stop = gui.Button(gui.LABEL_START, font, self.on_game_start_stop)
if self.editor_mode:
self.gui.replace([
gui.Button(u'\u270f Build\u2026', font, build_menu),
gui.Button(u'\u2798 Save', font, self.on_save_pressed),
gui.Button(u'\u2744 Lock', font, gui.SELECT, LockTool()),
self.b_start_stop,
gui.Button(gui.LABEL_BACK, font, self.on_back_pressed),
])
else:
self.block_buttons = {
block_class: gui.CountButton(block_class.human_name, font, count, gui.SELECT, DrawTool(block_class))
for block_class, count in self.game_session.game.inventory.items()
}
block_buttons = [self.block_buttons[cls] for cls in core.ALL_BLOCKS if cls in self.block_buttons]
self.gui.replace(block_buttons + [
gui.Button(gui.LABEL_REMOVE, font, gui.SELECT, EraseTool()),
gui.Button(u'\u21ba Retry', font, self.on_game_reset),
gui.Button(gui.LABEL_BACK, font, self.on_back_pressed),
])
def tick(self):
if not self.level_help:
self.time += 1
if self.time == 1 and not self.editor_mode:
self.charge_player = sounds.play('charge.wav')
new_status = self.game_session.get_status()
if self.game_status == core.Game.STATUS_ON and new_status == core.Game.STATUS_DEFEAT:
self.camera.shake(1)
sounds.play('boom.wav', 0.4)
self.game_status = new_status
if not self.editor_mode:
if new_status == core.Game.STATUS_VICTORY or self.skip_level:
next_level_name = self.level_name if self.editor_mode else self.get_next_level_name()
if next_level_name:
self.control.switch_handler("game_mode", False, next_level_name)
return
elif not self.game_complete:
self.gui.show_popup("Congrats! You completed the game!")
self.game_complete = True
if not self.editor_mode and self.time > self.SLOW_START and new_status == core.Game.STATUS_NEW:
self.game_session.start()
self.stop_charge_player()
sounds.play('start.wav')
if self.time > self.next_step and new_status == core.Game.STATUS_ON:
self.game_session.step()
self.next_step = self.time + self.STEP_SIZE # / (self.game_session.game.speed + 1)
cam_idx = 2 if self.keys[key.LSHIFT] or self.keys[key.RSHIFT] else 1
cam_pos = self.camera.eye.next_value
if self.keys[key.UP]:
cam_pos[cam_idx] += 0.2
if self.keys[key.DOWN]:
cam_pos[cam_idx] -= 0.2
if self.keys[key.LEFT]:
cam_pos.x -= 0.2
if self.keys[key.RIGHT]:
cam_pos.x += 0.2
cam_pos.x = min(20, max(-20, cam_pos.x))
cam_pos.y = min(20, max(-20, cam_pos.y))
cam_pos.z = min(40, max(5, cam_pos.z))
self.camera.tick()
self.renderer.tick()
def stop_charge_player(self):
if self.charge_player:
self.charge_player.pause()
self.charge_player = None
def on_resize(self, w, h):
self.camera.resize(0, 0, w, h)
return pyglet.event.EVENT_HANDLED
def on_draw(self):
self.window.clear()
glLoadIdentity()
self.camera.setup()
if self.gui.selected:
self.tool = self.gui.selected.args
else:
self.tool = TriggerTool()
self.update_mouse()
self.renderer.draw(self.tool.draw_locks)
with gl_disable(GL_LIGHTING, GL_DEPTH_TEST):
with gl_ortho(self.window):
self.gui.draw()
self.fps_magic.draw()
if self.level_help:
self.level_help.draw(self.window)
def update_mouse(self):
self.mouse_pos_world = self.camera.unproject(self.mouse_pos)
self.mouse_pos_grid = Vector3(*[int(round(v)) for v in self.mouse_pos_world])
self.renderer.mouse.pos = self.mouse_pos_grid
self.tool.update_cursor(self.renderer.mouse)
def on_mouse_motion(self, x, y, dx, dy):
self.mouse_pos = (x, y)
def on_key_press(self, sym, mods):
self.hide_help()
if sym == key.F12:
self.skip_level = True
return pyglet.event.EVENT_HANDLED
def hide_help(self):
if self.level_help:
self.level_help.delete()
self.level_help = None
def on_mouse_release(self, x, y, button, modifiers):
if self.level_help:
self.hide_help()
return
self.mouse_pos = (x, y)
self.update_mouse()
mpos = self.mouse_pos_grid.xy
grid = self.game_session.game.grid
block = grid.get(mpos)
if block and block.locked and not self.editor_mode:
self.camera.shake(0.1)
sounds.play('noway.wav')
return
try:
if button == mouse.LEFT:
tool = self.tool
if button == mouse.RIGHT or (button == mouse.LEFT and modifiers & key.MOD_SHIFT):
tool = self.alt_tool
if tool.apply(mpos, self.game_session.game, self.editor_mode):
self.renderer.mark_dirty(mpos)
except Exception as e:
self.camera.shake(0.2)
sounds.play('noway.wav')
self.update_inventory()
def update_inventory(self):
if not self.editor_mode:
for cls, count in self.game_session.game.inventory.items():
self.block_buttons[cls].count = count
def on_mouse_scroll(self, x, y, scroll_x, scroll_y):
cam_pos = self.camera.eye.next_value
cam_pos.z -= scroll_y
def on_game_start_stop(self, manager, args):
if self.game_session.get_status() == core.Game.STATUS_NEW:
try:
self.game_session.start()
self.b_start_stop.label.text = gui.LABEL_STOP
except Exception, e:
self.gui.show_popup("%s" % e)
self.init_level()
else:
