class Editor (object):
"""A puzzle editor (Game backend).
Takes arguments to pass to Editor.load.
METHODS
load
change
resize
insert
delete
set_block
undo
redo
click_tile
switch_puzzle
reset
menu
ATTRIBUTES
game: as given.
event_handler: as given.
ID: as given.
selector: puzzle used to select blocks/surfaces to add.
editor: the puzzle being edited.
editor_rect: the rect the editor puzzle is drawn in, or None if unknown.
puzzle: the current visible puzzle (editor or selector).
editing: whether the current puzzle is editor.
changes: a list of changes that have been made to the puzzle.
state: the current position in the changes list.
"""
def __init__ (self, game, event_handler, ID = None, defn = None):
self.game = game
# add event handlers
event_handler.add_event_handlers({
pygame.MOUSEBUTTONDOWN: self._click,
pygame.MOUSEBUTTONUP: self._unclick,
pygame.MOUSEMOTION: lambda e: setattr(self, 'mouse_moved', True)
})
pzl_args = (
eh.MODE_ONDOWN_REPEAT,
max(int(conf.MOVE_INITIAL_DELAY * conf.FPS), 1),
max(int(conf.MOVE_REPEAT_DELAY * conf.FPS), 1)
)
menu_args = (
eh.MODE_ONDOWN_REPEAT,
max(int(conf.MENU_INITIAL_DELAY * conf.FPS), 1),
max(int(conf.MENU_REPEAT_DELAY * conf.FPS), 1)
)
od = eh.MODE_ONDOWN
held = eh.MODE_HELD
l = conf.KB_LAYOUT
event_handler.add_key_handlers([
(conf.KEYS_MOVE_LEFT[l], [(self._move, (0,))]) + pzl_args,
(conf.KEYS_MOVE_UP[l], [(self._move, (1,))]) + pzl_args,
(conf.KEYS_MOVE_RIGHT[l], [(self._move, (2,))]) + pzl_args,
(conf.KEYS_MOVE_DOWN[l], [(self._move, (3,))]) + pzl_args,
(conf.KEYS_BACK, self.menu, od),
(conf.KEYS_TAB, self.switch_puzzle, od),
(conf.KEYS_INSERT, self._insert_cb, od),
(conf.KEYS_DEL, self.delete, od),
(conf.KEYS_UNDO, self.undo) + menu_args,
(conf.KEYS_REDO, self.redo) + menu_args,
(conf.KEYS_RESET, self.reset, od)
])
self.event_handler = event_handler
# create block/surface selection grid
blocks = xrange(conf.MAX_ID + 1)
surfaces = xrange(-1, conf.MIN_ID - 1, -1)
self._selector_defn = '3 {0}\n{1}\n\n{2}\n{3}'.format(
max(len(blocks), len(surfaces)),
'\n'.join('{0} 0 {1}'.format(b, i) for i, b in enumerate(blocks)),
'\n'.join('{0} 1 {1}'.format(b, i) for i, b in enumerate(blocks)),
'\n'.join('{0} 2 {1}'.format(s, i) for i, s in enumerate(surfaces))
)
self.selector = Puzzle(game, self._selector_defn)
self.FRAME = conf.FRAME
self.load(ID, defn)
def load (self, ID = None, defn = None):
"""Load a level.
load([ID][, defn])
ID: custom level ID.
defn: if ID is not given, load a level from this definition; if this is not
given, load a blank level.
"""
if ID is None:
if defn is None:
# blank grid
defn = conf.BLANK_LEVEL
self.ID = None
else:
# get data from file
d = conf.LEVEL_DIR_DRAFT if ID[0] == 2 else conf.LEVEL_DIR_CUSTOM
with open(d + ID[1]) as f:
defn = f.read()
self.ID = ID[1]
if hasattr(self, 'editor'):
self.editor.load(defn)
else:
self.editor = Puzzle(self.game, defn)
self.editor_rect = None
self.editor.deselect()
self.editor.select((0, 0))
self.selector.deselect()
self.selector.select((0, 0), True)
self.puzzle = self.editor
self.editing = True
self.dirty = True
self.changes = []
self.state = 0
self.mouse_moved = False
self.resizing = False
def change (self, *data):
"""Make a change to the puzzle; takes data to store in self.changes."""
cs = self.changes
# purge 'future' states
cs = cs[:self.state]
cs.append(data)
# purge oldest state if need to (don't need to increment state, then)
if len(cs) > conf.UNDO_LEVELS > 0:
cs.pop(0)
else:
self.state += 1
self.changes = cs
def resize (self, amount, dirn):
"""Like Editor.editor.resize, but do some wrapper stuff."""
lost = self.editor.resize(amount, dirn)
# might not have changed
if lost is not False:
self.dirty = True
self.change('resize', amount, dirn, lost)
def _move (self, key, event, mods, direction):
"""Callback for arrow keys."""
resize = False
mods = (mods & pygame.KMOD_SHIFT, mods & pygame.KMOD_ALT)
shrink = bool(mods[direction <= 1])
grow = bool(mods[direction > 1])
resize = shrink ^ grow
if resize:
# things could get messy if we're already mouse-resizing
if not self.resizing:
self.resize(1 if grow else -1, direction)
else:
# move selection
self.puzzle.move_selected(direction)
def insert (self):
"""Insert a block or surface at the current position."""
if not self.editing:
return
# get type and ID of selected tile in selector puzzle
col, row = self.selector.selected.keys()[0]
x, y = self.editor.selected.keys()[0]
is_block = col == 0 and row <= conf.MAX_ID
if is_block:
ID = row
# will be here for col = 0 if past end of blocks
elif col == 0 or col == 1:
ID = row
if ID > conf.MAX_ID:
ID = conf.DEFAULT_SURFACE
else:
ID = -row - 1
if ID >= 0:
ID = conf.DEFAULT_SURFACE
# make changes to selected tile in editor puzzle if necessary
current = self.editor.grid[x][y]
if is_block:
if current[1] is None or current[1].type != ID:
old_b = current[1]
b = self.editor.add_block((BoringBlock, ID), x, y)
self.game.play_snd('place_block')
self.change('set_block', old_b, b, x, y)
else:
if current[0] != ID:
old_ID = current[0]
self.editor.set_surface(x, y, ID)
self.game.play_snd('place_surface')
self.change('set_surface', old_ID, ID, x, y)
def _insert_cb (self, *args):
"""Callback for conf.KEYS_INSERT."""
if self.editing:
self.insert()
else:
self.switch_puzzle()
def delete (self, *args):
"""Delete a block or surface in the currently selected tile."""
if self.editing:
x, y = self.editor.selected.keys()[0]
data = self.editor.grid[x][y]
snd = True
# delete block, if any
if data[1] is not None:
b = self.editor.rm_block(None, x, y)
self.change('set_block', b, None, x, y)
# set surface to blank if not already
elif data[0] != conf.S_BLANK:
s = self.editor.set_surface(x, y, conf.S_BLANK)
self.change('set_surface', s, conf.S_BLANK, x, y)
else:
snd = False
if snd:
self.game.play_snd('delete')
def set_block (self, b, x, y):
"""Add or remove a block to or from the puzzle.
set_block(b, x, y)
b: BoringBlock instance, or None to remove.
x, y: tile position.
"""
if b is None:
self.editor.rm_block(None, x, y)
else:
self.editor.add_block(b, x, y)
def undo (self, *args):
"""Undo changes to the puzzle."""
if self.state > 0:
self.state -= 1
# get change data
data = self.changes[self.state]
c, data = data[0], data[1:]
# make the change to the puzzle
if c == 'set_block':
old_b, new_b, x, y = data
self.set_block(old_b, x, y)
elif c == 'set_surface':
old, new, x, y = data
self.editor.set_surface(x, y, old)
elif c == 'resize':
amount, direction, lost = data
self.editor.resize(-amount, (direction - 2) % 4)
# restore stuff that was lost in the resize
for obj, x, y in lost:
if isinstance(obj, int):
self.editor.set_surface(x, y, obj)
else:
self.set_block(obj, x, y)
self.dirty = True
def redo (self, *args):
"""Redo undone changes."""
if self.state < len(self.changes):
# get change data
data = self.changes[self.state]
c, data = data[0], data[1:]
self.state += 1
# make the change to the puzzle
if c == 'set_block':
old_b, new_b, x, y = data
self.set_block(new_b, x, y)
elif c == 'set_surface':
old, new, x, y = data
self.editor.set_surface(x, y, new)
elif c == 'resize':
amount, direction, lost = data
self.editor.resize(amount, direction)
self.dirty = True
def click_tile (self, insert, pos):
"""Insert or delete a block or surface at the given position.
click_tile(insert, pos)
insert: whether to insert the current block or surface (else delete).
pos: on-screen position to try to perform the action at.
"""
# get clicked tile
p = self.editor.point_tile(pos)
if p:
# clicked a tile in self.editor: switch to and select
if not self.editing:
self.switch_puzzle()
self.editor.deselect()
self.editor.select(p)
(self.insert if insert else self.delete)()
else:
p = self.selector.point_tile(pos)
if p:
# clicked a tile in self.selector: switch to selector, then
# select the tile
if self.editing:
self.switch_puzzle()
self.selector.deselect()
self.selector.select(p)
def _click (self, evt):
"""Handle mouse clicks."""
button = evt.button
pos = evt.pos
if button in (1, 3):
# left-click to insert, right-click to delete
self.click_tile(button == 1, pos)
elif button == 2:
rel_pos = self.editor.point_pos(pos)
# make sure we're clicking in the grid
if rel_pos is None:
return
self._resize_sides = []
# exclude a zone in the middle
b = conf.RESIZE_DEAD_ZONE_BOUNDARY
for i in (0, 1):
if b < rel_pos[i] < 1 - b:
self._resize_sides.append(None)
else:
# the axes we can resize on depends on where we start from
self._resize_sides.append(1 if rel_pos[i] > .5 else -1)
if self._resize_sides == [None, None]:
return
self.resizing = list(pos)
def _unclick (self, evt):
"""Handle mouse click release."""
if evt.button == 2 and self.resizing:
self.resizing = False
del self._resize_sides
def switch_puzzle (self, *args):
"""Switch selected puzzle between editor and block selector."""
self.editing = not self.editing
pzls = (self.editor, self.selector)
if self.editing:
new, old = pzls
else:
old, new = pzls
# deselect old and select new
for colour, pzl in enumerate((new, old)):
pos = pzl.selected.keys()[0]
pzl.deselect()
pzl.select(pos, colour)
self.puzzle = new
def reset (self, *args):
"""Confirm resetting the puzzle."""
if self.state > 0:
self.game.start_backend(Menu, 1, self)
# else nothing to reset
def menu (self, *args):
"""Show the editor menu."""
self.game.start_backend(Menu, 0, self)
def _do_reset (self):
"""Actually reset the puzzle."""
# just reset to original state - to whatever was loaded, if anything
while self.state > 0:
self.undo()
def update (self):
"""Handle mouse movement."""
if self.mouse_moved:
pos = pygame.mouse.get_pos()
if self.resizing:
# change puzzle size if middle-click-dragging
old_pos = self.resizing
for i in (0, 1):
side = self._resize_sides[i]
if side is None:
# can't resize on this axis
continue
diff = pos[i] - old_pos[i]
threshold = min(conf.RESIZE_LENGTH * conf.RES[0],
self.editor.tile_size(i))
while abs(diff) >= threshold:
# resize
sign = 1 if diff > 0 else -1
self.resize(sign * side, i + 2 * (sign == 1))
# prepare for resizing again
old_pos[i] += sign * threshold
diff -= sign * threshold
else:
# change selection based on mouse position
# get tile under mouse
tile = self.editor.point_tile(pos)
if tile:
# editor: select tile under mouse
if not self.editing:
self.switch_puzzle()
self.editor.deselect()
self.editor.select(tile)
else:
# selector: just make sure it's the current puzzle
tile = self.selector.point_tile(pos)
if tile:
if self.editing:
self.switch_puzzle()
self.mouse_moved = False
def draw (self, screen):
"""Draw the puzzles."""
w, h = screen.get_size()
w1 = int(conf.EDITOR_WIDTH * w)
w2 = w - w1
pad = int(conf.EDITOR_ARROW_PADDING * w)
if self.dirty:
screen.fill(conf.BG[conf.THEME])
# get puzzle sizes
e = self.editor.tiler
s = self.selector.tiler
if w1 != s.offset[0]:
# screen size changed: need to change puzzle positions
e.offset = (pad, pad)
s.offset = (w1, 0)
s.reset()
# draw puzzles
drawn1 = self.editor.draw(screen, self.dirty,
(w1 - 2 * pad, h - 2 * pad))
drawn2 = self.selector.draw(screen, self.dirty, (w2, h))
# and return the sum list of rects to draw in
drawn = []
for d in (drawn1, drawn2):
if d:
drawn += d
# draw arrows
if self.dirty:
self.editor_rect = drawn1
# TODO
to_draw = range(8)
special = []
drawn = True
else:
# TODO
to_draw = []
special = []
drawn += []
if to_draw:
# get draw area position and size
l, t, w, h = self.editor_rect[0]
tl = (l - pad, t - pad)
br = (l + w, t + h)
sz = (w + 2 * pad, h + 2 * pad)
# generate required arrow images
fn = conf.IMG_DIR + conf.THEME + os.sep + '{0}.png'
imgs = []
for ID in ('arrow', 'arrow-special'):
imgs.append(self.game.img(fn.format(ID), (pad / 2, None)))
for i in xrange(1, 4):
imgs.append(None)
img_s = [img for img in imgs if img is not None][0].get_size()
# draw
for i in to_draw:
p = [0, 0]
axis = (i / 2) % 2
p[axis] = (br if i > 3 else tl)[axis] + img_s[0] * (i % 2)
p[not axis] = tl[not axis] + (sz[not axis] - img_s[1]) / 2
img = (axis + 2 * (i % 2)) % 4
if i in special:
img += 4
if imgs[img] is None:
source = imgs[4 * (i in special)]
imgs[img] = pygame.transform.rotate(source, -90 * img)
screen.blit(imgs[img], p)
self.dirty = False
return drawn