class TheEnd(State):
def __init__(self):
State.__init__(self)
self.bg_image = GLOBALS["backgrounds"]["the_end.png"]
self.overlay = StaticWidget((638, 169))
self.overlay.set_pos((2, 160))
self.overlay.set_alpha(255)
self.overlay.fill((0, 0, 0))
self.wait = Timer(50)
def main_start(self):
pygame.mouse.set_visible(0)
GLOBALS["jb"].stop()
def update_screen(self):
self.background.fill((0, 0, 0))
self.background.blit(self.bg_image, (0, 0))
if not self.wait.active:
alpha = self.overlay.get_alpha()
if alpha > 0:
self.overlay.set_alpha(alpha - 10)
if alpha < 20:
self.add_kbevent(KEYDOWN, K_ESCAPE, self.quit)
elif self.wait.update():
self.wait.deactivate()
self.overlay.draw(self.background)
State.update_screen(self)
def __init__(self, bgimg=None):
BgState.__init__(self, bgimg)
pygame.mouse.set_visible(1)
#background of message
size = (250, 100)
msg_bg = StaticWidget(size)
draw_border(msg_bg)
pos = utils.center(size, (800, 600))
msg_bg.set_pos(pos)
self.msg_bg = msg_bg
msg_pos = pos
txt_img = TextLine("Paused", fontsize=30)
pos = (utils.center(txt_img.get_size(), size))
msg_bg.blit(txt_img, pos)
msg_bg.draw(self.background)
#continue/cancel buttons
btn = FixedTextButton((100, 24), "Abort Game", callback=self.to_menu)
btn.set_pos((msg_pos[0], msg_pos[1] + size[1] + 4))
btn.draw_border()
self.add_button("cancel", btn)
btn.draw(self.background)
btn = FixedTextButton((100, 24), "Continue", callback=self.quit)
btn.set_pos((msg_pos[0] + size[0] - 100, msg_pos[1] + size[1] + 4))
btn.draw_border()
self.add_button("start", btn)
btn.draw(self.background)
self.upd = 1
def __init__(self, bgimg=None, mapname="", folder="", pacmode=False):
BgState.__init__(self, bgimg)
pygame.mouse.set_visible(1)
self.pacmode = pacmode
self.mapname = mapname
self.folder = folder
#background of message
size = (250, 100)
msg_bg = StaticWidget(size)
draw_border(msg_bg)
pos = utils.center(size, (800, 600))
msg_bg.set_pos(pos)
self.msg_bg = msg_bg
msg_pos = pos
txt_img = TextLine("You lose.", fontsize=30)
pos = (utils.center(txt_img.get_size(), size))
msg_bg.blit(txt_img, pos)
msg_bg.draw(self.background)
#continue/cancel buttons
btn = FixedTextButton((100, 24), "Abort Game", callback=self.quit)
btn.set_pos((msg_pos[0], msg_pos[1] + size[1] + 4))
btn.draw_border()
self.add_button("cancel", btn)
btn.draw(self.background)
btn = FixedTextButton((100, 24), "Try Again", callback=self.tryagain)
btn.set_pos((msg_pos[0] + size[0] - 100, msg_pos[1] + size[1] + 4))
btn.draw_border()
self.add_button("start", btn)
btn.draw(self.background)
self.add_kbevent(KEYDOWN, K_ESCAPE, self.quit)
self.upd = 1
class Outro(State):
def __init__(self):
State.__init__(self)
self.fps = 40
#animation checkpoints and flags
self.opening = 0
self.closing = 0
self.door_timer = Timer(15) #open slowly, then faster
self.maelstrom_timer = Timer(30) #open doors a bit.. then pull
self.nanji_command = None
#generate pseudo-map
screen_size = GLOBALS["screen_size"]
self.bg_image = pygame.Surface(screen_size)
self.top_layer = pygame.Surface(screen_size)
self.top_layer.set_colorkey((255, 0, 255))
self.top_layer.fill((255, 0, 255))
#draw map background
bg = GLOBALS["backgrounds"]["fuji.png"]
self.bg_image.blit(bg, (0, 0))
#draw grass
tsize = GLOBALS["tile_size"]
grass_tile = GLOBALS["ts_tileset"][1, 0]
x = -tsize
y = screen_size[1] - tsize
for i in xrange(22):
self.top_layer.blit(grass_tile, (x, y))
x += tsize
#draw mysterious
myst = GLOBALS["ui_stuff"]["mysterious.png"]
#draw full signet board on mysterious
board = GLOBALS["ui_stuff"]["board_filled.png"]
x, y = 66, 197
myst.blit(board, (x, y))
x = 5 * tsize
y = screen_size[1] - myst.get_size()[1] - tsize
self.myst = StaticWidget(myst.get_size())
self.myst.set_colorkey((255, 0, 255))
self.myst.fill((255, 0, 255))
self.myst.blit(myst, (0, 0))
self.myst.set_pos((x, y))
self.myst.pos = (x, y)
self.myst.draw(self.top_layer)
myst_centerx = x + myst.get_size()[0] / 2
myst_top = y + 30
#init doors
self.door_speed = 1
door_left_image = GLOBALS["ui_stuff"]["door_left.png"]
door_right_image = GLOBALS["ui_stuff"]["door_right.png"]
self.door_left = StaticWidget(door_left_image.get_size())
self.door_left.blit(door_left_image, (0, 0))
self.door_left.set_pos((self.myst.pos[0] + 99, self.myst.pos[1] + 63))
self.door_right = StaticWidget(door_right_image.get_size())
self.door_right.blit(door_right_image, (0, 0))
self.door_right.set_pos(
(self.myst.pos[0] + 177, self.myst.pos[1] + 63))
#init whirling vortex
self.vortex = Vortex(centerpos=(myst_centerx, myst_top))
#init Nanji
self.nanji = Nanji(cam=None)
self.nanji.status = 0
self.nanji.set_pos((205, 401))
self.nanji_angle = 0
self.nanji_fly_img = self.nanji.all_images["landing"][0]
self.nanji_shrink = 1
self.sprites.add(self.nanji)
self.nanji_do("throw")
def main_start(self):
pygame.mouse.set_visible(0)
State.main_start(self)
def update_doors(self):
if self.opening:
lx, ly = self.door_left.get_pos()
rx, ry = self.door_right.get_pos()
self.door_left.set_pos((lx - self.door_speed, ly))
self.door_right.set_pos((rx + self.door_speed, ry))
if self.door_timer.update():
self.door_speed = 2
self.opening = lx > 165
elif self.closing:
self.door_speed = 1
lx, ly = self.door_left.get_pos()
rx, ry = self.door_right.get_pos()
self.door_left.set_pos((lx + 1, ly))
self.door_right.set_pos((rx - 1, ry))
self.closing = lx < 258
if not self.closing:
self.maelstrom_timer.set_interval(50)
self.nanji_do("waitquit")
self.door_left.draw(self.background)
self.door_right.draw(self.background)
def nanji_do(self, do="throw"):
self.nanji_command = do
if do == "throw": #lift paw
self.nanji.change_images("throwing")
self.nanji.anim_timer.set_interval(5)
self.nanji.play()
elif do == "unthrow": #put paw down
images = self.nanji.images[:]
images.reverse()
self.nanji.set_images(images)
self.nanji.play()
elif do == "wait_door":
self.nanji.change_images("idle")
self.opening = 1
self.nanji.pause()
elif do == "walk" or do == "walk2":
self.nanji.look = -1
self.nanji.change_images("walking")
self.nanji.anim_timer.set_interval(8)
self.nanji.play()
elif do == "sprint" or do == "sprint2":
self.nanji.change_images("sprinting")
self.nanji.anim_timer.set_interval(8)
self.nanji.play()
elif do == "duck":
self.nanji.change_images("ducking")
self.nanji.pause()
elif do == "lift":
self.nanji.change_images("landing")
self.nanji.pause()
def update_nanji(self):
if self.nanji_command is None:
return
#update old command
cmd = self.nanji_command
x, y = self.nanji.pos #get pulled
if cmd == "throw" and self.nanji.cur_image >= 3: #paw up
self.nanji_do("unthrow")
elif cmd == "unthrow" and self.nanji.cur_image >= 3: #paw down
self.nanji_do("wait_door")
elif cmd == "wait_door" and self.maelstrom_timer.update(): #wait
self.nanji_do("walk")
elif cmd == "walk":
if x > 150: #walk left
self.nanji.set_pos((x - 1, y))
else:
self.nanji_do("walk2")
elif cmd == "walk2":
if x < 190:
self.nanji.set_pos((x + 1, y))
else:
self.nanji_do("sprint")
elif cmd == "sprint": #try to sprint
if x > 170:
self.nanji.set_pos((x - 1, y))
else:
self.nanji_do("sprint2")
elif cmd == "sprint2":
self.nanji.set_pos((x + 1, y))
if self.maelstrom_timer.update():
self.nanji_do("duck")
elif cmd == "duck" and self.maelstrom_timer.update():
self.nanji_do("duckpull")
elif cmd == "duckpull":
if x < 250:
self.nanji.set_pos((x + 1, y))
else:
self.nanji_do("lift")
elif cmd == "lift":
if x < 280:
self.nanji.set_pos((x + 1, y))
else:
self.nanji_do("liftoff")
self.maelstrom_timer.set_interval(10)
elif cmd == "liftoff":
self.nanji.set_pos((x, y - 1))
if self.maelstrom_timer.update():
self.nanji_do("whirl")
elif cmd == "whirl":
img = self.nanji_fly_img.copy()
sx, sy = img.get_size()
img = pygame.transform.scale(
img, (sx - self.nanji_shrink, sy - self.nanji_shrink))
self.nanji_shrink += 1
if sx - self.nanji_shrink < 0 or sy - self.nanji_shrink < 0:
self.nanji_do("done")
self.nanji_angle += 10
if self.nanji_angle > 360:
self.nanji_angle = self.nanji_angle - 360
img = pygame.transform.rotate(img, self.nanji_angle)
center = self.nanji.rect.center
self.nanji.set_image(img)
self.nanji.rect.center = center
if y > 350:
y -= 1
if x < 350:
x += 1
self.nanji.set_pos((x, y))
elif cmd == "done":
self.nanji_do(None)
self.closing = 1
elif cmd == "waitquit" and self.maelstrom_timer.update():
self.next = TheEnd()
self.quit()
def update_screen(self):
self.background.blit(self.bg_image, (0, 0))
#update and draw vortex
self.vortex.update()
self.background.blit(self.vortex.image, self.vortex.pos)
#update and draw doors
self.update_doors()
#draw grass, building
self.background.blit(self.top_layer, (0, 0))
#draw nanji
self.update_nanji()
State.update_screen(self)
class Level(State):
def __init__(self, lvl_map="tutorial.map", testing=False, prev=None):
State.__init__(self)
self.fps = 60
self.prev = prev
tsize = GLOBALS["tile_size"]
self.trigger = None
self.exit_timer = Timer(50)
self.exit_timer.deactivate()
pygame.mixer.music.set_volume(1)
GLOBALS["jb"].play("bgm.xm", -1)
player_data["health"] = 9 #always full health on map start
#player_data["lives"] = #for gameover testing
#scrolling background - maybe later XD
#bg_back = GLOBALS["backgrounds"]["fuji.png"]
#bg_front = GLOBALS["backgrounds"]["trees.png"]
#self.scroll_bg = Background(bg_back, bg_front)
#non-scrolling background
self.bg = GLOBALS["backgrounds"]["fuji.png"]
#map
self.map_filename = lvl_map
self.map = Map(lvl_map)
self.lvl_map = self.map["tilemap"]
x, y = self.map["max"]
self.lvl_img, self.blocks = self.map.draw(editing=False)
self.lvl_layer = pygame.Surface(self.lvl_img.get_size())
#other spritegroups
self.bullets = pygame.sprite.Group()
#player
self.player = Nanji(None)
self.player.set_pos((self.map["start"][0]*tsize, self.map["start"][1]*tsize))
self.sprites.add(self.player)
#camera
self.camera = Camera(self.player)
screen_x, screen_y = GLOBALS["screen_size"]
mx = self.map["max"][0] * tsize - screen_x
my = self.map["max"][1] * tsize - screen_y + 4*tsize
self.camera.set_max(mx,my)
self.player.camera = self.camera
self.camera.update()
#add enemies
self.enemies = pygame.sprite.Group()
clan = self.map["options"]["clan"]
for e in self.map.enemies:
ninjat = Ninjat(self.camera, clan)
ninjat.set_pos((e[0]*tsize, e[1]*tsize-32))#FIXME:enemies are spawned too low..?
self.enemies.add(ninjat)
self.sprites.add(ninjat)
#ui layer
self.ui_layer = StaticWidget((GLOBALS["screen_size"][0], 30))
self.ui_layer.fill((255,0,255))
self.ui_layer.set_colorkey((255,0,255))
self.ui_layer.set_pos((0,0))
self.heart_img = GLOBALS["ui_stuff"]["heart"]
self.heart_empty_img = GLOBALS["ui_stuff"]["heart_empty"]
self.life_img = GLOBALS["ui_stuff"]["life"]
self.fontholder = TextLine("", fontsize=16)
self.update_ui()
#keyboard events
self.key_pressed = {
"up": 0, "down": 0, "left": 0, "right": 0,
"jump":0, "sprint":0, "throw": 0, "shuriken": 0,
}
self.add_kbevent(KEYDOWN, K_LEFT, self.set_keypress, k="left", v=1) #move
self.add_kbevent(KEYDOWN, K_RIGHT, self.set_keypress, k="right", v=1)
self.add_kbevent(KEYDOWN, K_UP, self.set_keypress, k="up", v=1)
self.add_kbevent(KEYDOWN, K_DOWN, self.set_keypress, k="down", v=1)
self.add_kbevent(KEYDOWN, K_SPACE, self.set_keypress, k="jump", v=1) #jump
self.add_kbevent(KEYDOWN, K_LSHIFT, self.set_keypress, k="sprint", v=1) #sprint
self.add_kbevent(KEYDOWN, K_RSHIFT, self.set_keypress, k="sprint", v=1)
self.add_kbevent(KEYDOWN, K_RCTRL, self.set_keypress, k="throw", v=1) #throw
self.add_kbevent(KEYDOWN, K_LCTRL, self.set_keypress, k="throw", v=1)
self.add_kbevent(KEYUP, K_LEFT, self.set_keypress, k="left", v=0)
self.add_kbevent(KEYUP, K_RIGHT, self.set_keypress, k="right", v=0)
self.add_kbevent(KEYUP, K_UP, self.set_keypress, k="up", v=0)
self.add_kbevent(KEYUP, K_DOWN, self.set_keypress, k="down", v=0)
self.add_kbevent(KEYUP, K_SPACE, self.set_keypress, k="jump", v=0)
self.add_kbevent(KEYUP, K_LSHIFT, self.set_keypress, k="sprint", v=0)
self.add_kbevent(KEYUP, K_RSHIFT, self.set_keypress, k="sprint", v=0)
self.add_kbevent(KEYUP, K_RCTRL, self.set_keypress, k="throw", v=0)
self.add_kbevent(KEYUP, K_LCTRL, self.set_keypress, k="throw", v=0)
if testing:
self.add_kbevent(KEYUP, K_ESCAPE, self.quit)
def main_start(self):
pygame.mouse.set_visible(0)
State.main_start(self)
def reset_keys(self):
self.key_pressed = {
"up": 0, "down": 0, "left": 0, "right": 0,
"jump":0, "sprint":0, "throw": 0, "shuriken": 0,
}
def update_other(self):
if self.player.exiting:
self.show_exit_anim()
return
kp = self.key_pressed
vx = 0
if kp["left"] and not kp["right"]:
vx = -1
if kp["right"] and not kp["left"]:
vx = 1
self.player.mod_vel(vx=vx)
if kp["jump"]:
self.player.jump()
elif self.player.status==4:
self.player.unjump()
if kp["sprint"]:
self.player.sprint()
#self.scroll_bg.front_speed = 8
elif self.player.status==2:
self.player.unsprint()
#self.scroll_bg.front_speed = 4
if kp["down"]:
self.player.duck()
elif self.player.status==7:
self.player.unduck()
if kp["throw"]:
kp["throw"] = 0
if self.player.throw():
self.bullets.add(Shuriken(self.player, self.camera))
def set_keypress(self, k, v):
self.key_pressed[k] = v
def show_exit_anim(self):
self.fps = 30
self.reset_keys()
if self.player.exiting == -1:
self.player.set_vel((0,0))
self.player.set_image(GLOBALS["nanji"]["idle"][0])
if not self.exit_timer.active:
self.exit_timer.activate()
elif self.player.vel[1]:
self.player.status = 5
else:
self.player.status = 1
self.player.mod_vel(vx=1)
if self.player.pos[0] > self.map["exit"][0]*tsize+10*tsize or \
self.exit_timer.update():
#TODO: play some funky tune / do SOMETHING on level exit
if self.prev:
self.prev.success = True
self.quit()
def show_dialog(self, dialog_id):
self.pause()
self.next = ShowDialog(dialog_id, self.screen)
self.quit()
def unpause(self):
self.reset_keys()
State.unpause(self)
def check_collisions(self):
#check bullet collisions
b = self.bullets
s = self.enemies
bl = self.blocks
#test if bullet hit player
coll = pygame.sprite.spritecollide(self.player, self.bullets, False)
for bullet in coll:
if bullet.thrower is not self.player and bullet.flying and not \
self.player.invincible:
bullet.kill()
self.player.get_hit()
self.rem_health()
#test if bullet hit wall
dead = []
for bullet in self.bullets:
if bullet.rect.collidelist(bl) > -1:
dead.append(bullet)
for d in dead:
if d.flying:
d.kill()
#test if bullet hit enemy (ninjats can't shoot each other)
coll = pygame.sprite.groupcollide(s, b, False, False)
for victim in coll.keys(): #my code gets weird...
for murderer in coll[victim]:
if murderer.thrower is self.player:
victim.die()
murderer.kill()
#test player vs. enemy collisions
coll = pygame.sprite.spritecollide(self.player, s, False)
pbottom = self.player.rect.bottom
for enemy in coll:
if enemy.status == 8: #enemy dead.. ignore!
continue
etop = enemy.rect.top
if self.player.status==5 and pbottom >= etop:
#enemy below player and player is falling -> enemy crushed!
enemy.die()
self.player.bounce()
elif not self.player.invincible and not self.player.status==7:
#not ducking -> get hit
self.player.get_hit()
self.rem_health()
def rem_health(self):
player_data["health"] -= 1
GLOBALS["sfx"][sfx_hit].play()
if player_data["health"] <= 0:
self.player.die()
self.update_ui()
def update_ui(self):
self.ui_layer.fill((255,0,255))
#health
x, y, add = 4, 2, self.heart_img.get_size()[0] + 2
for i in xrange(9):
if i < player_data["health"]: #TODO: if i < hp
self.ui_layer.blit(self.heart_img, (x,y))
else:
self.ui_layer.blit(self.heart_empty_img, (x,y))
x += add
#lives
x, y, add = 595, 2, self.life_img.get_size()[0] + 2
self.ui_layer.blit(self.life_img, (x,y))
lives = player_data["lives"]
life_text = self.fontholder.font.render("x"+str(lives), False, (255,255,255))
self.ui_layer.blit(life_text, (x+add, y+10))
def update_screen(self):
for s in self.sprites:
s.update_status()
if not s.ai: #update player
s.update()
if not s.status==8 and not self.player.off_screen():
s.check_mapcollisions(self.blocks)
trig = s.check_trigcollisions(self.map.triggers)
if trig:
if trig.name=="exit":
self.player.exiting = 1
elif trig.name=="dtrigger":
self.show_dialog(trig.params)
if trig.params=="tut08":
self.player.exiting = -1
self.player.set_image(GLOBALS["nanji"]["idle"][0])
else:
player_data["health"] = 9
player_data["lives"] -= 1
if player_data["lives"] > 0:
next = Level(self.map_filename, prev=self.prev)
else:
next = GameOver()
self.next = FadeState(self.screen, next.background, next)
self.quit()
else: #update ai
if s.ai_update(self): #throw shuriken?
self.bullets.add(Shuriken(s, self.camera))
self.bullets.update()
self.camera.update()
#draw bg
#self.scroll_bg.update(self.player.vel[0])
self.background.blit(self.bg, (0,0))
#draw map and sprites
self.lvl_layer.fill((255,0,255))
self.lvl_layer.blit(self.lvl_img, self.camera.pos, [self.camera.pos, GLOBALS["screen_size"]])
self.lvl_layer.set_colorkey((255,0,255))
self.bullets.draw(self.lvl_layer)
self.sprites.draw(self.lvl_layer)
#pygame.draw.rect(self.lvl_layer, (255,255,0), self.player.colrect, 1) #draw collision rect of nanji
if self.player.exiting: #draw semi-black image over dojo entry while entering
self.lvl_layer.blit(GLOBALS["objects"]["dojo_entry"], self.map.dojo_pos)
self.background.blit(self.lvl_layer, (0,0), [self.camera.pos, GLOBALS["screen_size"]])
self.ui_layer.draw(self.background)
self.screen.blit(self.background, (0,0))
pygame.display.flip()
class Editor(State):
def __init__(self):
State.__init__(self)
self.buttons = {}
#tileset area
self.tileset_area = StaticWidget((1020, 280))
self.tileset_area.set_pos((2, 485))
self.tileset_area.pos = (2, 485)
ca = ClickArea(pygame.Rect([2, 485, 1024, 280]), self.choose_tiletype)
self.widgets.append(ca)
self.tileset_id = "ts_tileset"
self.marked_type = None
self.load_tileset()
#set clan
buttons = [
"wood", "day", "fire", "life", "earth", "night", "metal", "water",
"death"
]
x, y = 900, 50
for clan in buttons:
btn = ImgButton(GLOBALS["signets"][clan][1], \
self.set_clan, clan=clan)
btn.set_pos((x, y))
self.widgets.append(btn)
self.buttons[clan] = btn
btn.draw(self.background)
y = y + btn.get_size()[1] + 5
self.clan = "fire"
#Camera
self.camera = Camera(None)
#load empty map
self.filename = ""
self.load_map(new=True)
#map area
self.map_area = StaticWidget((640, 480))
self.map_area.set_pos((0, 0))
self.map_area_rect = pygame.Rect([0, 0, 640, 480])
self.widgets.append(ca)
#grid overlay for map area
w, h = self.map_area.get_size()
self.grid = StaticWidget((w, h))
self.grid.fill((255, 0, 255))
self.grid.set_colorkey((255, 0, 255))
self.grid.set_alpha(100)
for row in xrange(h / tsize):
for col in xrange(w / tsize):
pygame.draw.line(self.grid, (255, 255, 255), (col * 32, 0),
(col * 32, h))
pygame.draw.line(self.grid, (255, 255, 255), (0, row * 32),
(w, row * 32))
self.grid.set_pos(self.map_area.get_pos())
#buttons
buttons = [(" NEW ", self.new_map), (" LOAD ", self.open_file),
(" SAVE AS ", self.save_file), (" SAVE ", self.save_map)]
x, y = 650, 1
for b in buttons:
name, callback = b
btn = ImgButton(TextLine(name), callback)
btn.set_pos((x, y))
btn.draw_border((255, 255, 255))
self.widgets.append(btn)
btn.draw(self.background)
x = x + btn.get_size()[0] + 4
#add objects
buttons = [
(" delete obj", "delete"),
(" add start ", "start"),
(" add exit ", "exit"),
(" add enemy ", "enemy"),
(" add dialog-trigger ", "dtrigger"),
]
x, y = 650, 50
for b in buttons:
name, cmd = b
btn = ImgButton(TextLine(name, fontsize=15), \
self.select_add_object, cmd=cmd)
btn.set_pos((x, y))
self.widgets.append(btn)
btn.draw(self.background)
y = y + btn.get_size()[1] + 5
self.buttons[cmd] = btn
#TEST button :)
btn = ImgButton(TextLine(" TEST ", fontsize=25), self.test)
btn.set_pos((900, 420))
btn.draw_border((255, 255, 255))
self.widgets.append(btn)
btn.draw(self.background)
#keyboard events
pygame.key.set_repeat(10, 20)
#scroll map
self.add_kbevent(KEYDOWN, K_UP, self.scroll_map, vy=-1)
self.add_kbevent(KEYDOWN, K_DOWN, self.scroll_map, vy=1)
self.add_kbevent(KEYDOWN, K_LEFT, self.scroll_map, vx=-1)
self.add_kbevent(KEYDOWN, K_RIGHT, self.scroll_map, vx=1)
def update_screen(self):
#draw map
self.lvl_layer.set_colorkey(None)
self.lvl_layer.fill((255, 0, 255))
self.lvl_layer.blit(self.lvl_img, (0, 0))
self.lvl_layer.set_colorkey((255, 0, 255))
self.map_area.fill((0, 0, 0))
self.map_area.blit(self.lvl_layer, (0, 0),
area=[self.camera.pos, GLOBALS["screen_size"]])
self.map_area.draw_border((255, 255, 255))
#draw map area
self.map_area.draw(self.background)
self.grid.draw(self.background)
State.update_screen(self)
def test(self):
self.save_map()
if self.filename:
self.pause()
self.next = Level(self.filename, testing=True)
self.quit()
def set_clan(self, clan):
#unmark previous selection
self.buttons[self.clan].draw_border((0, 0, 0))
self.buttons[self.clan].draw(self.background)
#mark current selection
self.clan = clan
self.buttons[self.clan].draw_border((255, 255, 255))
self.map["options"]["clan"] = self.clan
self.buttons[self.clan].draw(self.background)
def set_option(self, param):
old_value = ""
if self.map["options"].has_key(param):
old_value = self.map["options"][param]
entry = tkSimpleDialog.askstring(title="Set " + param,
prompt="Enter " + param + ":",
initialvalue=old_value)
print param, ":", entry
if entry is not None:
self.map["options"][param] = entry
def select_add_object(self, cmd):
#dehighlight old button
if self.buttons.has_key(self.marked_type):
self.buttons[self.marked_type].draw_border((0, 0, 0))
self.buttons[self.marked_type].draw(self.background)
elif self.marked_type:
self.mark_tile(None) #deselect tile
#highlight button
self.buttons[cmd].draw_border((255, 255, 255))
self.buttons[cmd].draw(self.background)
self.marked_type = cmd
def load_map(self, filename="", new=False):
if not new:
try:
new_map = Map(filename)
except:
print "Could not load map"
return
else:
new_map = Map()
self.filename = filename
pygame.display.set_caption(filename)
self.map = new_map
self.lvl_map = self.map["tilemap"]
self.lvl_img, blocks = self.map.draw(editing=True)
self.lvl_layer = pygame.Surface(self.lvl_img.get_size())
self.camera.set_pos((0, tsize * 20))
self.load_tileset(self.map["tset"])
self.set_clan(self.map["options"]["clan"])
def scroll_map(self, vx=0, vy=0):
x, y = self.camera.pos
self.camera.set_pos((x + vx * tsize, y + vy * tsize))
def open_file(self):
filename = tkFileDialog.askopenfilename(title="Open",
initialfile=map_path)
if filename:
self.load_map(filename)
def save_file(self):
self.asksaveasfilename()
if self.filename:
self.save_map()
def asksaveasfilename(self):
filename = tkFileDialog.asksaveasfilename(title="Save as",
initialfile=map_path)
if filename:
self.filename = filename
def save_map(self):
if not self.filename:
self.asksaveasfilename()
if self.filename:
self.map.save_map(path=self.filename)
else:
self.map.save_map(path=self.filename)
def new_map(self):
ok = tkMessageBox.askyesno(title="Just asking..",
message="Really create a new map?")
if ok:
self.load_map(new=True)
self.load_tileset()
def choose_tiletype(self):
x, y = pygame.mouse.get_pos()
off_x, off_y = self.tileset_area.pos
x, y = (x - off_x) / (tsize + 2), (y - off_y) / (tsize + 2)
if GLOBALS[self.tileset_id].has_key((x, y)):
self.mark_tile((x, y))
def mark_tile(self, coord):
def draw_tile_border(coord, color=(255, 255, 255)):
x, y = coord[0] * (tsize + 2), coord[1] * (tsize + 2)
r = pygame.Rect([x - 1, y - 1, tsize + 2, tsize + 2])
pygame.draw.rect(self.tileset_area, color, r, 1)
if self.marked_type:
if GLOBALS[self.tileset_id].has_key(self.marked_type):
draw_tile_border(self.marked_type, (0, 0, 0))
elif self.buttons.has_key(self.marked_type):
self.buttons[self.marked_type].draw_border((0, 0, 0))
self.buttons[self.marked_type].draw(self.background)
if coord:
draw_tile_border(coord)
self.marked_type = coord
self.tileset_area.draw(self.background)
def load_tileset(self, tset="tileset"):
ts_id = "ts_" + tset
if not GLOBALS.has_key(ts_id):
ts_id = "ts_tileset"
self.marked_type = None
self.tileset_area.fill((0, 0, 0))
self.tileset_id = ts_id
tiles = GLOBALS[ts_id]
keys = tiles.keys()
keys.sort()
for k in keys:
x, y = k[0] * (tsize + 2), k[1] * (tsize + 2)
self.tileset_area.blit(tiles[k], (x, y))
self.tileset_area.draw(self.background)
def check_collisions(self):
#check if map was clicked -> put tiles on map
mpos = pygame.mouse.get_pos()
pressed = pygame.mouse.get_pressed()
lbutton, rbutton = pressed[0], pressed[2]
if not self.map_area_rect.collidepoint(mpos) or \
(not rbutton and not (lbutton and self.marked_type)):
return
#calculate map coordinates
off_x, off_y = self.camera.pos
x, y = (mpos[0] + off_x) / tsize, (mpos[1] + off_y) / tsize
#set tile info
if rbutton and self.lvl_map.has_key((x, y)):
self.lvl_map.pop((x, y))
elif lbutton and GLOBALS[self.tileset_id].has_key(self.marked_type):
#place tile
self.lvl_map[x, y] = self.marked_type
elif lbutton and self.buttons.has_key(self.marked_type):
#place object
if self.marked_type == "delete" and self.map["objects"].has_key(
(x, y)):
self.map["objects"].pop((x, y))
else:
params = None
t = self.marked_type
if t == "dtrigger":
params = tkSimpleDialog.askstring(
title="Set dialog id",
prompt="Enter dialog ID:",
)
if params is None: #didn't want to add that trigger anyway
return
if not dialog.has_key(params):
print "Warning: Dialog id not found... just for your information. ^^"
self.map["objects"][x, y] = (self.marked_type, params)
if params:
self.mark_tile(None)
self.lvl_img, blocks = self.map.draw(editing=True)
self.lvl_layer = pygame.Surface(self.lvl_img.get_size())
class SaveMenu(BgState):
def __init__(self, img, map, mapname="", folder="custom"):
BgState.__init__(self, img)
self.map = map
self.folder = folder
pygame.mouse.set_visible(1)
#background image + "save as"
self.menu = StaticWidget((250, 100))
self.menu.fill((0, 0, 0))
txt = TextLine("Save as:", fontsize=15)
self.menu.blit(txt, (10, 10))
w, h = self.menu.get_size()
pygame.draw.lines(self.menu, (0, 0, 255), True,
((0, 0), (w - 4, 0), (w - 4, h - 4), (0, h - 4)), 4)
x, y = utils.center((w, h), (800, 600))
self.menu.set_pos((x, y))
#text entry + ".map"
self.entry = TextEntry(text=mapname[:-4])
self.entry.set_pos((x + 10, y + 30))
txt = TextLine(".map", fontsize=20)
self.menu.blit(txt, (self.entry.get_size()[0] + 15, 30))
#save/cancel buttons
msg_pos = self.menu.get_pos()
size = self.menu.get_size()
btn = FixedTextButton((100, 24), "Cancel", callback=self.quit)
btn.set_pos((msg_pos[0], msg_pos[1] + size[1] + 4))
btn.draw_border()
self.add_button("cancel", btn)
btn.draw(self.background)
btn = FixedTextButton((100, 24), "Save", callback=self.submit)
btn.set_pos((msg_pos[0] + size[0] - 100, msg_pos[1] + size[1] + 4))
btn.draw_border()
self.add_button("save", btn)
btn.draw(self.background)
self.redraw()
self.quit_timer = utils.Timer(20)
self.quit_timer.deactivate()
self.add_kbevent(KEYDOWN, K_ESCAPE, callback=self.quit)
self.add_textentry_events(self.entry)
def redraw(self):
self.menu.draw(self.background)
for b in self.buttons.keys():
self.buttons[b].draw(self.background)
self.entry.draw(self.background)
self.upd = 1
def update_other(self):
if self.quit_timer.active:
if self.quit_timer.update():
self.quit()
elif self.entry.update():
self.redraw()
def submit(self):
if self.quit_timer.active:
return
filename = self.entry.text + ".map"
if not self.map.save(filename, self.folder):
txt = "Ok, map saved."
self.next = Editor(filename, folder=self.folder)
else:
txt = "ERROR: Could not save map."
size = self.menu.get_size()
msg = pygame.Surface((size[0] - 2, size[1] - 2))
msg.fill((0, 0, 0))
txt = TextLine(txt)
msg.blit(txt, utils.center(txt.get_size(), msg.get_size()))
self.menu.blit(msg, (1, 1))
self.menu.draw(self.background)
self.upd = 1
self.quit_timer.activate()