def tile_explode(g,a):
g.game.sfx['explode'].play()
tiles.t_put(g,a.pos,0)
import tile
tile.tile_to_sprite(g,a)
s = a
s.hit_groups = set()
def loop(g,s):
s.exploded += 2
if s.exploded > 8:
s.active = False
#if s in g.sprites:
#g.sprites.remove(s)
s.loop = loop
def tile_explode(g,a):
g.game.sfx['explode'].play()
tiles.t_put(g,a.pos,0)
import tile
tile.tile_to_sprite(g,a)
s = a
s.hit_groups = set()
def loop(g,s):
s.exploded += 2
if s.exploded > 8:
s.active = False
#if s in g.sprites:
#g.sprites.remove(s)
s.loop = loop
def hit_replace(g, a, b, r):
hit_block(g, a, b, 1, 1, 1, 1)
if 'bubble' in b.groups:
tiles.t_put(g, a.pos, r)
def init(self):
#self._tiles = load_tiles(data.filepath('tiles.tga'))
self._tiles = Level._tiles
fname = self.fname # MYNOTE by default fname = none
if fname == None:
fname, self.title = levels.LEVELS[
self.game.
lcur] #MYNOTE at start lcur of game = 0 !! fname = filename
fname = data.filepath(os.path.join('levels', fname))
else:
self.title = os.path.basename(self.fname)
self.data = load_level(
fname) #load_level of level file to self.data the file is .tga
#MYNOTE self.data is the rgb value of map
#print "running level : "+ self.title
#agentConnect.init(self)
#self.images = load_images(data.filepath('images'))
self.images = Level._images
img = pygame.Surface((1, 1)).convert_alpha()
img.fill((0, 0, 0, 0)) #MYNOTE create img that is a 1*1 of black
self.images[None] = img
for n in xrange(0, len(self._tiles)):
self.images[n] = self._tiles[n]
import tiles
self._images = []
for m in xrange(0, IROTATE): #MYNOTE IROTATE = fixed 64
r = dict(self.images)
#for n,i,t in tiles.TANIMATE:
#n2 = n+(m/t)%i
#r[n] = self.images[n2]
for n, incs in tiles.TANIMATE: #MYNOTE TANIMATE = list for animating an obj
n2 = n + incs[m % len(incs)]
r[n] = self.images[n2]
for n1, n2 in tiles.TREPLACE:
r[n1] = self.images[n2]
self._images.append(r)
self.size = len(self.data[0][0]), len(self.data[0])
self._bkgr_fname = None
self.set_bkgr('1.png')
self.bkgr_scroll = pygame.Rect(0, 0, 1, 1)
self.view = pygame.Rect(0, 0, SW, SH) #MYNOTE the screen?
self.bounds = pygame.Rect(0, 0, self.size[0] * TW, self.size[1] * TH)
self.sprites = []
self.player = None
self.frame = 0
self.codes = {}
# initialize all the tiles ...
self.layer = [[None for x in xrange(0, self.size[0])]
for y in xrange(0, self.size[1])]
for y in xrange(0, self.size[1]):
l = self.data[0][y] #MYNOTE data of color r
for x in xrange(0, self.size[0]):
n = l[x] #MYNOTE n is a tile in data matrix
#n1 = self.data[1][y][x]
#if n1:
#print 'warning place background tiles in the foreground',x,y,n1
#if n == 0: n = n1
if not n: continue
tiles.t_put(self, (x, y), n) #MYNOTE put tile into game.layer
#MYNOTE if comment this the floor will disappear but character is exist
for y in xrange(0, self.size[1]):
l = self.data[2][y] #MYNOTE data of color b
for x in xrange(0, self.size[0]):
n = l[x]
if not n: continue
codes.c_init(self, (x, y), n) #init player and boss
#MYNOTE print(self.layer) may be the tiles in the screen
#print(self.layer)
#just do a loop, just to get things all shined up ..
self.status = None
#self.loop() this is not real loop wtf
self.status = '_first'
self.player.image = None
self.player.exploded = 30 # time when player appear effect
def loop(g,s):
s._prev2 = pygame.Rect(s.rect)
if s.death_counter > 0:
s.groups = set()
if not s.no_explode:
s.exploded += 1
if s.exploded > FPS/2:
s.image = None
else:
s.image = None
s.death_counter -= 1
return
if s.death_counter == 0:
g.status = 'dead'
return
if s.exploded > 0:
if s.powered_up:
s.image = 'player/right'
else:
s.image = 'splayer/right'
s.exploded -=1
return
sprite.apply_gravity(g,s)
sprite.apply_standing(g,s)
if s.door_timer != None:
if s.door_timer == 0:
x,y = s.door_pos#s.rect.centerx/TW,s.rect.centery/TH
import door
#door.hit(g,g.layer[y][x],s)
door.hit(g,(x,y),s)
#tiles.t_put(g,(x,y), 0x30)
#tiles.t_put(g,(x,y-1), 0x20)
s.door_timer = None
else:
s.door_timer -= 1
return
inpt = g.game.input
#if s.standing: s.rect.bottom = s.standing.rect.top
#check if we hit the ceiling
if not s.jumping and s.vy < 0 and s.rect.y == s._prev.y:
s.vy = 0
# We have universal input code now (>__>)
#move by keyboard
#keys = pygame.key.get_pressed()
if s.jumping:
#print s.vy
s.vy -= s.jumping
s.jumping = max(0,s.jumping-0.2)
inc = 0.5
mx = 1.0
if inpt.right and s.vx < mx:
s.vx += inc
s.facing = 'right'
elif not inpt.right and s.vx > 0: s.vx -= inc
if inpt.left and s.vx > -mx:
s.vx -= inc
s.facing = 'left'
elif not inpt.left and s.vx < 0: s.vx += inc
s._prev = pygame.Rect(s.rect)
vx,vy = s.vx,s.vy
s.rect.x += vx
s.rect.y += sprite.myinc(g.frame,s.vy)
#if keys[K_UP]: vy -= 1
#if keys[K_DOWN]: vy += 1
if s.vy < 0:
s.image = 'player/%s-jump' % (s.facing)
elif s.shooting > 0:
if s.shooting > 5:
s.image = 'player/%s-shoot-1' % (s.facing)
else:
s.image = 'player/%s-shoot-2' % (s.facing)
s.shooting -= 1
elif inpt.right or inpt.left and s.standing:
s.image = 'player/%s-walk-%s' % (s.facing, int(s.walk_frame))
s.walk_frame += 0.2
if s.walk_frame > 4:
s.walk_frame = 1
else:
s.image = 'player/%s'%(s.facing)
if s.flash_counter > 0:
if s.flash_timer < 4:
s.image = None
if s.flash_timer == 0:
s.flash_timer = 8
s.flash_counter -= 1
s.flash_timer -= 1
if s.image != None:
if s.powerup_transition > 0:
if (s.powerup_transition % 10) > 5:
s.image = 's' + s.image
s.powerup_transition -= 1
elif not s.powered_up:
s.image = 's' + s.image
s.looking = False
if inpt.up:
g.view.y -= 2
s.looking = True
if inpt.down:
g.view.y += 2
s.looking = True
n = sprite.get_code(g,s,0,0)
if n == CODE_EXIT:
g.status = 'exit'
if n == CODE_DOOR_AUTO:
x,y = s.rect.centerx/TW,s.rect.centery/TH
import door
door.hit(g,(x,y),s)
#pan_screen(g,s)
#if (g.frame%FPS)==0: print 'player vy:',s.vy
if hasattr(g, 'boss'):
#print g.boss.phase, g.boss.phase_frames
if g.boss.phase == 2 and g.boss.phase_frames == 60:
for y in xrange(len(g.layer)):
for x in xrange(len(g.layer[y])):
if g.data[2][y][x] == CODE_BOSS_PHASE2_BLOCK:
tiles.t_put(g,(x,y),0x01) # solid tile
if g.boss.dead:
g.status = 'exit'
def init(self):
#self._tiles = load_tiles(data.filepath('tiles.tga'))
self._tiles = Level._tiles
fname = self.fname
if fname == None:
fname,self.title = levels.LEVELS[self.game.lcur]
fname = data.filepath(os.path.join('levels',fname))
else:
self.title = os.path.basename(self.fname)
self.data = load_level(fname)
#self.images = load_images(data.filepath('images'))
self.images = Level._images
img = pygame.Surface((1,1)).convert_alpha()
img.fill((0,0,0,0))
self.images[None] = img
for n in xrange(0,len(self._tiles)): self.images[n] = self._tiles[n]
import tiles
self._images = []
for m in xrange(0,IROTATE):
r = dict(self.images)
#for n,i,t in tiles.TANIMATE:
#n2 = n+(m/t)%i
#r[n] = self.images[n2]
for n,incs in tiles.TANIMATE:
n2 = n+incs[m%len(incs)]
r[n] = self.images[n2]
for n1,n2 in tiles.TREPLACE:
r[n1] = self.images[n2]
self._images.append(r)
self.size = len(self.data[0][0]),len(self.data[0])
self._bkgr_fname = None
self.set_bkgr('1.png')
self.bkgr_scroll = pygame.Rect(0,0,1,1)
self.view = pygame.Rect(0,0,SW,SH)
self.bounds = pygame.Rect(0,0,self.size[0]*TW,self.size[1]*TH)
self.sprites = []
self.player = None
self.frame = 0
self.codes = {}
# initialize all the tiles ...
self.layer = [[None for x in xrange(0,self.size[0])] for y in xrange(0,self.size[1])]
for y in xrange(0,self.size[1]):
l = self.data[0][y]
for x in xrange(0,self.size[0]):
n = l[x]
#n1 = self.data[1][y][x]
#if n1:
#print 'warning place background tiles in the foreground',x,y,n1
#if n == 0: n = n1
if not n: continue
tiles.t_put(self,(x,y),n)
for y in xrange(0,self.size[1]):
l = self.data[2][y]
for x in xrange(0,self.size[0]):
n = l[x]
if not n: continue
codes.c_init(self,(x,y),n)
#just do a loop, just to get things all shined up ..
self.status = None
self.loop()
self.status = '_first'
self.player.image = None
self.player.exploded = 30
def loop(g, s):
s._prev2 = pygame.Rect(s.rect)
if s.powered_up == 'cannon':
s.weapon = 'cannon'
elif s.powered_up == 'shootgun':
s.weapon = 'shootgun'
elif s.powered_up == 'laser':
s.weapon = 'laser'
elif s.powered_up == 'granadelauncher':
s.weapon = 'granadelauncher'
else:
s.weapon = 'player'
inpt = g.game.input
if s.vy < 0:
s.image = s.jetpack + "/" + s.weapon + '/%s-jump' % s.facing
elif s.shooting > 0:
if s.shooting > 5:
s.image = s.jetpack + "/" + s.weapon + '/%s-shoot-1' % s.facing
else:
s.image = s.jetpack + "/" + s.weapon + '/%s-shoot-2' % s.facing
s.shooting -= 1
elif inpt.right or inpt.left and s.standing:
s.image = s.jetpack + "/" + s.weapon + '/%s-walk-%s' % (s.facing, int(s.walk_frame))
s.walk_frame += 0.2
if s.walk_frame > 4:
s.walk_frame = 1
else:
s.image = s.jetpack + "/" + s.weapon + '/%s' % s.facing
if s.vx > 0:
s.facing = 'right'
elif s.vx < 0:
s.facing = 'left'
if s.image is not None:
if s.damaged_transition > 0:
if (s.damaged_transition % 10) > 5:
s.image = None
else:
if s.vy < 0:
s.image = s.jetpack + "/" + s.weapon + '/%s-jump' % s.facing
elif inpt.right or inpt.left and s.standing:
s.image = s.jetpack + "/" + s.weapon + '/%s-walk-%s' % (s.facing, int(s.walk_frame))
else:
s.image = s.jetpack + "/" + s.weapon + '/%s' % (s.facing)
s.damaged_transition -= 1
"""
elif s.powerup_transition > 0:
if (s.powerup_transition % 10) > 5:
s.image = s.image
s.powerup_transition -= 1
elif s.powered_up == '':
s.image = s.image
"""
if s.got_hit:
if s.facing == "right":
s.rect.x -= 2
else:
s.rect.x += 2
s.got_hit -= 1
if s.death_counter > 0:
s.groups = set()
if not s.no_explode:
s.exploded += 1
if s.exploded > FPS / 2:
s.image = None
else:
s.image = None
s.death_counter -= 1
return
if s.death_counter == 0:
g.status = 'dead'
return
if s.exploded > 0:
s.exploded -= 1
return
sprite.apply_gravity(g, s)
sprite.apply_standing(g, s)
if s.door_timer is not None:
if s.door_timer == 0:
x, y = s.door_pos # s.rect.centerx/TW,s.rect.centery/TH
import door
# door.hit(g,g.layer[y][x],s)
door.hit(g, (x, y), s)
# tiles.t_put(g,(x,y), 0x30)
# tiles.t_put(g,(x,y-1), 0x20)
s.door_timer = None
else:
s.door_timer -= 1
return
# if s.standing: s.rect.bottom = s.standing.rect.top
# check if we hit the ceiling
if not s.jumping and s.vy < 0 and s.rect.y == s._prev.y:
s.vy = 0
# We have universal input code now (>__>)
# move by keyboard
# keys = pygame.key.get_pressed()
if s.jumping:
# print s.vy
s.vy -= s.jumping
if s.vy < -4:
s.vy = -4
if s.jetpack == "double_jump":
s.jump_timer += 5
s.jumping = max(0, s.jumping - 0.2)
elif s.jetpack == 'fly':
s.jumping = max(0, s.jumping)
else:
s.jump_timer += 4
s.jumping = max(0, s.jumping - 0.2)
if s.jump_timer and not s.jumping:
s.jump_timer -= 1
x_speed = 1.0
else:
x_speed = 1.0
if g.frame % s.speed == 0:
if inpt.right:
s.vx = x_speed
s.fancing = 'right'
elif not inpt.right and s.vx > 0:
s.vx = 0
if inpt.left:
s.vx = -x_speed
s.facing = 'left'
elif not inpt.left and s.vx < 0:
s.vx = 0
s._prev = pygame.Rect(s.rect)
vx, vy = s.vx, s.vy
s.rect.x += vx
s.rect.y += sprite.myinc(g.frame, s.vy)
# if keys[K_UP]: vy -= 1
# if keys[K_DOWN]: vy += 1
if s.flash_counter > 0:
if s.flash_timer < 4:
s.image = None
if s.flash_timer == 0:
s.flash_timer = 8
s.flash_counter -= 1
s.flash_timer -= 1
s.looking = False
if inpt.up:
s.view_counter += 1
if s.view_counter >= 60:
g.view.y -= 2
s.looking = True
elif inpt.down:
s.view_counter += 1
if s.view_counter >= 60:
g.view.y += 2
s.looking = True
else:
s.view_counter = 0
n = sprite.get_code(g, s, 0, 0)
if n == CODE_EXIT and (g.game.chips[0] and g.game.chips[1] and g.game.chips[2] and g.game.chips[3]):
g.status = 'exit'
if n == CODE_DOOR_AUTO:
x, y = s.rect.centerx / TW, s.rect.centery / TH
import door
door.hit(g, (x, y), s)
# pan_screen(g,s)
# if (g.frame%FPS)==0: print 'player vy:',s.vy
if hasattr(g, 'boss'):
# print g.boss.phase, g.boss.phase_frames
if g.boss.phase == 2 and g.boss.phase_frames == 60:
for y in xrange(len(g.layer)):
for x in xrange(len(g.layer[y])):
if g.data[2][y][x] == CODE_BOSS_PHASE2_BLOCK:
tiles.t_put(g, (x, y), 0x01) # solid tile
if g.boss.dead:
g.status = 'exit'
# pygame.mixer.music.load("
# g.game.music.play('finish',1)
if hasattr(s, "shoot"):
s.shoot.cooldown -= 1
if s.shoot.cooldown == 0:
s.canshoot = True
if g.game.drone is not None and s.drone != g.game.drone:
s.drone = g.game.drone
if hasattr(s.drone_sprite, "active"):
s.drone_sprite.active = False
s.drone_sprite = sprites.drone.init(g, s.rect, s, s.drone)
if s.drone == "defender" and s.shield is False:
s.shield_sprite = sprites.shield.init(g, s.rect, s)
s.shield = True
if s.drone != "defender" and s.shield is True:
s.shield_sprite.active = False
s.shield = False
if s.shield is False and s.shield_counter:
if s.shield_counter > 1:
s.shield_counter -= 1
else:
s.shield_counter = 0
if s.drone == "defender" and s.shield is False:
s.shield_sprite = sprites.shield.init(g, s.rect, s)
s.shield = True
s.jetpack = g.game.jetpack
s.strength = g.game.strength
s.powered_up = g.game.powerup
def fally_init(g, r, n, *args):
x = r.centerx / TW
y = r.centery / TH
tiles.t_put(g, (x, y), 0x12)
def tile_to_sprite(g, s):
import tiles
x, y = s.rect.centerx / TW, s.rect.centery / TH
tiles.t_put(g, (x, y), 0)
g.sprites.append(s)
def hit_replace(g, a, b, r):
hit_block(g, a, b, 1, 1, 1, 1)
if 'shoot' in b.groups:
tiles.t_put(g, a.pos, r)
def init(self):
#self._tiles = load_tiles(data.filepath('tiles.tga'))
self._tiles = Level._tiles
fname = self.fname
if fname == None:
fname, self.title = levels.LEVELS[self.game.lcur]
fname = data.filepath(os.path.join('levels', fname))
else:
self.title = os.path.basename(self.fname)
self.data = load_level(fname)
#self.images = load_images(data.filepath('images'))
self.images = Level._images
img = pygame.Surface((1, 1)).convert_alpha()
img.fill((0, 0, 0, 0))
self.images[None] = img
for n in xrange(0, len(self._tiles)):
self.images[n] = self._tiles[n]
import tiles
self._images = []
for m in xrange(0, IROTATE):
r = dict(self.images)
#for n,i,t in tiles.TANIMATE:
#n2 = n+(m/t)%i
#r[n] = self.images[n2]
for n, incs in tiles.TANIMATE:
n2 = n + incs[m % len(incs)]
r[n] = self.images[n2]
for n1, n2 in tiles.TREPLACE:
r[n1] = self.images[n2]
self._images.append(r)
self.size = len(self.data[0][0]), len(self.data[0])
self._bkgr_fname = None
self.set_bkgr('1.png')
self.bkgr_scroll = pygame.Rect(0, 0, 1, 1)
self.view = pygame.Rect(0, 0, SW, SH)
self.bounds = pygame.Rect(0, 0, self.size[0] * TW, self.size[1] * TH)
self.sprites = []
self.player = None
self.frame = 0
self.codes = {}
# initialize all the tiles ...
self.layer = [[None for x in xrange(0, self.size[0])]
for y in xrange(0, self.size[1])]
for y in xrange(0, self.size[1]):
l = self.data[0][y]
for x in xrange(0, self.size[0]):
n = l[x]
#n1 = self.data[1][y][x]
#if n1:
#print 'warning place background tiles in the foreground',x,y,n1
#if n == 0: n = n1
if not n: continue
tiles.t_put(self, (x, y), n)
for y in xrange(0, self.size[1]):
l = self.data[2][y]
for x in xrange(0, self.size[0]):
n = l[x]
if not n: continue
codes.c_init(self, (x, y), n)
#just do a loop, just to get things all shined up ..
self.status = None
self.loop()
self.status = '_first'
self.player.image = None
self.player.exploded = 30
def tile_to_sprite(g,s):
import tiles
x,y = s.rect.centerx/TW,s.rect.centery/TH
tiles.t_put(g,(x,y),0)
g.sprites.append(s)
def tile_to_sprite(game, sprite):
x, y = sprite.rect.centerx / TW, sprite.rect.centery / TH
tiles.t_put(game, (x, y), 0)
game.sprites.append(sprite)
def init(self):
self._tiles = Level._tiles
fname = self.fname
if fname is None:
fname, self.title = levels.LEVELS[self.game.lcur]
fname = data.filepath(os.path.join('levels', fname))
else:
self.title = os.path.basename(self.fname)
fg, bg, codes_data = load_level(fname)
self.images = Level._images
self.images[None] = pygame.Surface((1, 1), pygame.SRCALPHA)
import tiles
self.tile_animation = []
for m in xrange(IROTATE):
r = list(self._tiles)
for n, incs in tiles.TANIMATE:
n2 = n + incs[m % len(incs)]
r[n] = self._tiles[n2]
for n1, n2 in tiles.TREPLACE:
r[n1] = self._tiles[n2]
self.tile_animation.append(r)
self.size = len(bg[0]), len(bg)
self._bkgr_fname = None
self.set_bkgr('1.png')
self.bkgr_scroll = pygame.Rect(0, 0, 1, 1)
self.view = pygame.Rect(0, 0, SW, SH)
self.bounds = pygame.Rect(0, 0, self.size[0] * TW, self.size[1] * TH)
self.sprites = []
self.player = None
self.frame = 0
self.codes = {}
self.codes_data = codes_data
# initialize all the tiles ...
self.layer = [[None] * self.size[0] for y in xrange(self.size[1])]
self.drawfg = [[0] * self.size[0] for y in xrange(self.size[1])]
# Create a surface containing solely the immutable background.
# Part of this surface is drawn onto the screen using one blit call,
# followed by the mutable tiles, drawn using one blit call per tile.
# See tiles.TIMMUTABLE for the full definition of 'immutable'.
self.bg2 = pygame.Surface((self.size[0] * TW, self.size[1] * TH),
pygame.SRCALPHA)
rw, rh = xrange(self.size[0]), xrange(self.size[1])
for y in rh:
fg_row, bg_row, codes_row = fg[y], bg[y], codes_data[y]
for x in rw:
fg_tile, bg_tile, codes_tile = fg_row[x], bg_row[x], codes_row[
x]
if bg_tile != 0:
self.bg2.blit(self._tiles[bg_tile], (x * TW, y * TH))
if fg_tile != 0:
tiles.t_put(self, (x, y), fg_tile)
if fg_tile in tiles.TIMMUTABLE:
self.bg2.blit(self._tiles[fg_tile], (x * TW, y * TH))
self.drawfg[y][x] = 0
if codes_tile != 0:
codes.c_init(self, (x, y), codes_tile)
# just do a loop, just to get things all shined up ..
self.status = None
self.loop()
self.status = '_first'
self.player.image = None
self.player.exploded = 30
def fally_init(g, r, n, *params):
x, y = r.centerx / TW, r.centery / TH
tiles.t_put(g, (x, y), 0x12)
def loop(self):
self._prev2 = pygame.Rect(self.rect)
if self.death_counter > 0:
self.groups = set()
if not self.no_explode:
self.exploded += 1
if self.exploded > FPS / 2:
self.image = None
else:
self.image = None
self.death_counter -= 1
return
if self.death_counter == 0:
self.game.status = 'dead'
return
if self.exploded > 0:
if self.powered_up:
self.image = 'player/right'
else:
self.image = 'splayer/right'
self.exploded -= 1
return
self.apply_gravity()
self.apply_standing()
if self.door_timer != None:
if self.door_timer == 0:
x, y = self.door_pos
import door
door.hit(g, (x, y), s)
self.door_timer = None
else:
self.door_timer -= 1
return
inpt = self.game.game.input
#check if we hit the ceiling
if not self.jumping and self.vy < 0 and self.rect.y == self._prev.y:
self.vy = 0
if self.jumping:
self.vy -= self.jumping
self.jumping = max(0, self.jumping - 0.2)
inc = 1.0
mx = 4
if inpt.right and self.vx < mx:
self.vx += inc
self.facing = 'right'
elif not inpt.right and self.vx > 0:
self.vx -= inc
if inpt.left and self.vx > -mx:
self.vx -= inc
self.facing = 'left'
elif not inpt.left and self.vx < 0:
self.vx += inc
self._prev = pygame.Rect(self.rect)
vx = self.vx
vy = self.vy
self.rect.x += vx
self.rect.y += self.myinc(self.vy)
if self.vy < 0:
self.image = 'player/%s-jump' % (self.facing)
elif self.shooting > 0:
if self.shooting > 5:
self.image = 'player/%s-shoot-1' % (self.facing)
else:
self.image = 'player/%s-shoot-2' % (self.facing)
self.shooting -= 1
elif inpt.right or inpt.left and self.standing:
self.image = 'player/%s-walk-%s' % (self.facing,
int(self.walk_frame))
self.walk_frame += 0.2
if self.walk_frame > 4:
self.walk_frame = 1
else:
self.image = 'player/%s' % (self.facing)
if self.flash_counter > 0:
if self.flash_timer < 4:
self.image = None
if self.flash_timer == 0:
self.flash_timer = 8
self.flash_counter -= 1
self.flash_timer -= 1
if self.image != None:
if self.powerup_transition > 0:
if (self.powerup_transition % 10) > 5:
self.image = 's' + self.image
self.powerup_transition -= 1
elif not self.powered_up:
self.image = 's' + self.image
self.looking = False
if inpt.up:
self.game.view.y -= 2
self.looking = True
if inpt.down:
self.game.view.y += 2
self.looking = True
code = self.get_code(0, 0)
if code == CODE_EXIT:
self.game.status = 'exit'
if code == CODE_DOOR_AUTO:
x = self.rect.centerx / TW
y = self.rect.centery / TH
import door #WTF!
door.hit(self.game, (x, y), self)
if hasattr(self.game, 'boss'):
#print g.boss.phase, g.boss.phase_frames
if self.game.boss.phase == 2 and self.game.boss.phase_frames == 60:
for y in xrange(len(self.game.layer)):
for x in xrange(len(self.game.layer[y])):
if self.game.data[2][y][x] == CODE_BOSS_PHASE2_BLOCK:
tiles.t_put(g, (x, y), 0x01) # solid tile
if self.game.boss.dead:
self.game.status = 'exit'
def fally_init(g, r, n, *params):
x, y = r.centerx / TW, r.centery / TH
tiles.t_put(g, (x, y), 0x12)
def loop(g, s):
s._prev2 = pygame.Rect(s.rect)
if s.powered_up == 'cannon':
s.weapon = 'cannon'
elif s.powered_up == 'shootgun':
s.weapon = 'shootgun'
elif s.powered_up == 'laser':
s.weapon = 'laser'
elif s.powered_up == 'granadelauncher':
s.weapon = 'granadelauncher'
else:
s.weapon = 'player'
inpt = g.game.input
if s.vy < 0:
s.image = s.jetpack + "/" + s.weapon + '/%s-jump' % s.facing
elif s.shooting > 0:
if s.shooting > 5:
s.image = s.jetpack + "/" + s.weapon + '/%s-shoot-1' % s.facing
else:
s.image = s.jetpack + "/" + s.weapon + '/%s-shoot-2' % s.facing
s.shooting -= 1
elif inpt.right or inpt.left and s.standing:
s.image = s.jetpack + "/" + s.weapon + '/%s-walk-%s' % (
s.facing, int(s.walk_frame))
s.walk_frame += 0.2
if s.walk_frame > 4:
s.walk_frame = 1
else:
s.image = s.jetpack + "/" + s.weapon + '/%s' % s.facing
if s.vx > 0:
s.facing = 'right'
elif s.vx < 0:
s.facing = 'left'
if s.image is not None:
if s.damaged_transition > 0:
if (s.damaged_transition % 10) > 5:
s.image = None
else:
if s.vy < 0:
s.image = s.jetpack + "/" + s.weapon + '/%s-jump' % s.facing
elif inpt.right or inpt.left and s.standing:
s.image = s.jetpack + "/" + s.weapon + '/%s-walk-%s' % (
s.facing, int(s.walk_frame))
else:
s.image = s.jetpack + "/" + s.weapon + '/%s' % (s.facing)
s.damaged_transition -= 1
"""
elif s.powerup_transition > 0:
if (s.powerup_transition % 10) > 5:
s.image = s.image
s.powerup_transition -= 1
elif s.powered_up == '':
s.image = s.image
"""
if s.got_hit:
if s.facing == "right":
s.rect.x -= 2
else:
s.rect.x += 2
s.got_hit -= 1
if s.death_counter > 0:
s.groups = set()
if not s.no_explode:
s.exploded += 1
if s.exploded > FPS / 2:
s.image = None
else:
s.image = None
s.death_counter -= 1
return
if s.death_counter == 0:
g.status = 'dead'
return
if s.exploded > 0:
s.exploded -= 1
return
sprite.apply_gravity(g, s)
sprite.apply_standing(g, s)
if s.door_timer is not None:
if s.door_timer == 0:
x, y = s.door_pos # s.rect.centerx/TW,s.rect.centery/TH
import door
# door.hit(g,g.layer[y][x],s)
door.hit(g, (x, y), s)
# tiles.t_put(g,(x,y), 0x30)
# tiles.t_put(g,(x,y-1), 0x20)
s.door_timer = None
else:
s.door_timer -= 1
return
# if s.standing: s.rect.bottom = s.standing.rect.top
# check if we hit the ceiling
if not s.jumping and s.vy < 0 and s.rect.y == s._prev.y:
s.vy = 0
# We have universal input code now (>__>)
# move by keyboard
# keys = pygame.key.get_pressed()
if s.jumping:
# print s.vy
s.vy -= s.jumping
if s.vy < -4:
s.vy = -4
if s.jetpack == "double_jump":
s.jump_timer += 5
s.jumping = max(0, s.jumping - 0.2)
elif s.jetpack == 'fly':
s.jumping = max(0, s.jumping)
else:
s.jump_timer += 4
s.jumping = max(0, s.jumping - 0.2)
if s.jump_timer and not s.jumping:
s.jump_timer -= 1
x_speed = 1.0
else:
x_speed = 1.0
if g.frame % s.speed == 0:
if inpt.right:
s.vx = x_speed
s.fancing = 'right'
elif not inpt.right and s.vx > 0:
s.vx = 0
if inpt.left:
s.vx = -x_speed
s.facing = 'left'
elif not inpt.left and s.vx < 0:
s.vx = 0
s._prev = pygame.Rect(s.rect)
vx, vy = s.vx, s.vy
s.rect.x += vx
s.rect.y += sprite.myinc(g.frame, s.vy)
# if keys[K_UP]: vy -= 1
# if keys[K_DOWN]: vy += 1
if s.flash_counter > 0:
if s.flash_timer < 4:
s.image = None
if s.flash_timer == 0:
s.flash_timer = 8
s.flash_counter -= 1
s.flash_timer -= 1
s.looking = False
if inpt.up:
s.view_counter += 1
if s.view_counter >= 60:
g.view.y -= 2
s.looking = True
elif inpt.down:
s.view_counter += 1
if s.view_counter >= 60:
g.view.y += 2
s.looking = True
else:
s.view_counter = 0
n = sprite.get_code(g, s, 0, 0)
if n == CODE_EXIT and (g.game.chips[0] and g.game.chips[1]
and g.game.chips[2] and g.game.chips[3]):
g.status = 'exit'
if n == CODE_DOOR_AUTO:
x, y = s.rect.centerx / TW, s.rect.centery / TH
import door
door.hit(g, (x, y), s)
# pan_screen(g,s)
# if (g.frame%FPS)==0: print 'player vy:',s.vy
if hasattr(g, 'boss'):
# print g.boss.phase, g.boss.phase_frames
if g.boss.phase == 2 and g.boss.phase_frames == 60:
for y in xrange(len(g.layer)):
for x in xrange(len(g.layer[y])):
if g.data[2][y][x] == CODE_BOSS_PHASE2_BLOCK:
tiles.t_put(g, (x, y), 0x01) # solid tile
if g.boss.dead:
g.status = 'exit'
# pygame.mixer.music.load("
# g.game.music.play('finish',1)
if hasattr(s, "shoot"):
s.shoot.cooldown -= 1
if s.shoot.cooldown == 0:
s.canshoot = True
if g.game.drone is not None and s.drone != g.game.drone:
s.drone = g.game.drone
if hasattr(s.drone_sprite, "active"):
s.drone_sprite.active = False
s.drone_sprite = sprites.drone.init(g, s.rect, s, s.drone)
if s.drone == "defender" and s.shield is False:
s.shield_sprite = sprites.shield.init(g, s.rect, s)
s.shield = True
if s.drone != "defender" and s.shield is True:
s.shield_sprite.active = False
s.shield = False
if s.shield is False and s.shield_counter:
if s.shield_counter > 1:
s.shield_counter -= 1
else:
s.shield_counter = 0
if s.drone == "defender" and s.shield is False:
s.shield_sprite = sprites.shield.init(g, s.rect, s)
s.shield = True
s.jetpack = g.game.jetpack
s.strength = g.game.strength
s.powered_up = g.game.powerup
def loop(g, s):
if s.death_counter > 0:
s.groups = set()
s.exploded += 1
if s.exploded > FPS / 2:
s.image = None
s.death_counter -= 1
return
if s.death_counter == 0:
g.status = 'dead'
return
if s.exploded > 0:
if s.powered_up:
s.image = 'player/right'
else:
s.image = 'splayer/right'
s.exploded -= 1
return
sprite.apply_gravity(g, s)
sprite.apply_standing(g, s)
if s.door_timer != None:
if s.door_timer == 0:
x, y = s.door_pos #s.rect.centerx/TW,s.rect.centery/TH
import door
#door.hit(g,g.layer[y][x],s)
door.hit(g, (x, y), s)
#tiles.t_put(g,(x,y), 0x30)
#tiles.t_put(g,(x,y-1), 0x20)
s.door_timer = None
else:
s.door_timer -= 1
return
inpt = g.game.input
#if s.standing: s.rect.bottom = s.standing.rect.top
#check if we hit the ceiling
if not s.jumping and s.vy < 0 and s.rect.y == s._prev.y:
s.vy = 0
# We have universal input code now (>__>)
#move by keyboard
#keys = pygame.key.get_pressed()
if s.jumping:
#print s.vy
s.vy -= s.jumping
s.jumping = max(0, s.jumping - 0.2)
inc = 0.5
mx = 2
if inpt.right and s.vx < mx:
s.vx += inc
s.facing = 'right'
elif not inpt.right and s.vx > 0:
s.vx -= inc
if inpt.left and s.vx > -mx:
s.vx -= inc
s.facing = 'left'
elif not inpt.left and s.vx < 0:
s.vx += inc
s._prev = pygame.Rect(s.rect)
vx, vy = s.vx, s.vy
s.rect.x += vx
s.rect.y += sprite.myinc(g.frame, s.vy)
#if keys[K_UP]: vy -= 1
#if keys[K_DOWN]: vy += 1
if s.vy < 0:
s.image = 'player/%s-jump' % (s.facing)
elif s.shooting > 0:
if s.shooting > 5:
s.image = 'player/%s-shoot-1' % (s.facing)
else:
s.image = 'player/%s-shoot-2' % (s.facing)
s.shooting -= 1
elif inpt.right or inpt.left and s.standing:
s.image = 'player/%s-walk-%s' % (s.facing, int(s.walk_frame))
s.walk_frame += 0.2
if s.walk_frame > 4:
s.walk_frame = 1
else:
s.image = 'player/%s' % (s.facing)
if s.flash_counter > 0:
if s.flash_timer < 4:
s.image = None
if s.flash_timer == 0:
s.flash_timer = 8
s.flash_counter -= 1
s.flash_timer -= 1
if s.image != None:
if s.powerup_transition > 0:
if (s.powerup_transition % 10) > 5:
s.image = 's' + s.image
s.powerup_transition -= 1
elif not s.powered_up:
s.image = 's' + s.image
if inpt.up:
g.view.y -= 2
if inpt.down:
g.view.y += 2
n = sprite.get_code(g, s, 0, 0)
if n == CODE_EXIT:
g.status = 'exit'
if n == CODE_DOOR_AUTO:
x, y = s.rect.centerx / TW, s.rect.centery / TH
import door
door.hit(g, (x, y), s)
#pan_screen(g,s)
#if (g.frame%FPS)==0: print 'player vy:',s.vy
if hasattr(g, 'boss'):
#print g.boss.phase, g.boss.phase_frames
if g.boss.phase == 2 and g.boss.phase_frames == 60:
for y in xrange(len(g.layer)):
for x in xrange(len(g.layer[y])):
if g.data[2][y][x] == CODE_BOSS_PHASE2_BLOCK:
tiles.t_put(g, (x, y), 0x01) # solid tile
if g.boss.dead:
g.status = 'exit'
