new file mode 100644

new file mode 100644

@@ -0,0 +1,56 @@

+import src.console

+import collections

+

+class MessageBox(object):

+	def __init__(self, console, num, pos, event=None):

+		self.console = console

+		self.pos = x,y = pos

+		self.messages = collections.deque([], num)

+		self.maxlen = -float('inf')

+		if event is not None:

+			import src.events

+			src.events.EventHandler().handle_event(event, self.msg)

+

+	def msg(self, msg, *a):

+		msg %= a

+		self.messages.append(msg)

+		self.maxlen = max(self.maxlen, len(msg))

+		x,y = self.pos

+		for idx, msg in enumerate(self.messages):

+			self.console.print_( (x,y+idx), msg.ljust(self.maxlen) )

+		return False

+

+class TextBox(object):

+	def __init__(self, console, num, pos, event=None):

+		self.console = console

+		self.pos = x,y = pos

+		self.lines = [''] * num

+		self.maxlen = -float('inf')

+		if event is not None:

+			import src.events

+			src.events.EventHandler().handle_event(event, self.set_line)

+

+	def set_line(self, line, msg, *a):

+		msg = msg % a

+		self.maxlen = max(self.maxlen, len(msg))

+		self.lines[line] = msg

+		x,y = self.pos

+		self.console.print_( (x,y+line), msg.ljust(self.maxlen) )

+		return False

+

+class Label(object):

+	def __init__(self, console, pos, event=None):

+		self.console = console

+		self.pos = x,y = pos

+		self.line = ''

+		self.maxlen = -float('inf')

+		if event is not None:

+			import src.events

+			src.events.EventHandler().handle_event(event, self.set_text)

+	def set_text(self, msg, *a):

+		msg = msg % a

+		self.maxlen = max(self.maxlen, len(msg))

+		self.line = msg

+		x,y = self.pos

+		self.console.print_( (x,y), msg.ljust(self.maxlen) )

+		return False

@@ -5,6 +5,9 @@ from .combat_parts import equipment

 from .combat_parts import skills

 from .combat_parts import constants as const

+from src import events

+eh = events.EventHandler()

+

 import collections

 import random

@@ -48,6 +51,10 @@ class Adventurer(object):

 		if val > const.KNOCKOUT: val = const.KNOCKOUT

 		self.attributes.state = val

+	@property

+	def readable_state(self):

+		return ['healthy', 'wounded', 'knocked out'][self.state if self.state < 3 else 2]

+

 	@classmethod

 	def randomize(cls, stat_sum=28):

 		name = '%s %s%s' % (

@@ -89,7 +96,9 @@ class Adventurer(object):

 		if pass_:

 			if self.weapon is not None:

 				damage += self.weapon.damage_mod

-			print '%s inflicts %d damage upon %s' % (self.name, damage, opponent.name)

+			eh.trigger_event('msg',

+				'%s inflicts %d damage upon %s' % (self.name, damage, opponent.name)

+			)

 			opponent.take_damage(damage)

 	def take_damage(self, damage):

@@ -104,7 +113,9 @@ class Adventurer(object):

 		if not result:

 			if damage > 0:

 				self.state += 1

-				print '%s takes %d damage and is now %s' % (self.name, damage, ['healthy', 'wounded', 'ko'][self.state if self.state < 3 else 2])

+				eh.trigger_event('msg',

+					'%s takes %d damage and is now %s' % (self.name, damage, self.readable_state)

+				)

 				if self.state >= const.KNOCKOUT:

 					self.die()

@@ -1,3 +1,4 @@

+from src import events

 import abc

 import collections

 from . import combat

@@ -13,6 +14,7 @@ class Overlay(object):

 	def pos(self):

 		return self.x, self.y

 	def __init__(self, x,y, map):

+		print self.handled_events

 		self.events = collections.OrderedDict()

 		self.x = x

 		self.y = y

@@ -38,21 +40,30 @@ class Overlay(object):

 			result = result is None or result # if the event returns a false value besides None, break

 			if result == False: break

-	handled_events = collections.OrderedDict()

-	@classmethod

-	def handle_event(cls, event):

-		def _inner(cb):

-			cls.handled_events.setdefault(event, []).append(cb)

-			return cb

+	@staticmethod

+	def add_event(event,  cb_name):

+		def _inner(cls):

+			if not hasattr(cls,  'handled_events'):

+				cls.handled_events = {}

+				for base in cls.bases:

+					if hasattr(base,  'handled_events'):

+						cls.handled_events.update(base.handled_events)

+			cls.handled_events.setdefault(event,  []).append(getattr(cls,  cb_name))

+			return cls

 		return _inner

+	def tick(self):

+		pass

+@Overlay.add_event('attacked',  'attacked_by')

+@Overlay.add_event('bumped',  'bumped_by')

 class Actor(Overlay):

 	char = ord('@')

 	color = (255,0,0)

 	blocks = True

+	handled_events = collections.OrderedDict()

 	@property

 	def pos(self):

 		return self.x, self.y

@@ -63,18 +74,35 @@ class Actor(Overlay):

 		if adventurer is None:

 			adventurer = combat.Adventurer.randomize()

 		self.adventurer = adventurer

+		self.repeated_actions = {}

-	def move(self, dx, dy):

-		dx, dy = self.map.move(self, dx,dy)

+	def add_repeated_action(self, time, action, *args, **kw):

+		print 'adding action', action, args, kw

+		self.repeated_actions.setdefault(time, []).append( (action, args, kw) )

+

+	def update_pos(self, dx,dy):

 		self.x += dx

 		self.y += dy

+	def move(self, dx, dy):

+		print 'moving'

+		self.map.move(self, dx,dy, self.update_pos)

+

 	def tick(self):

 		result = True

 		if self.adventurer.state >= 2:

 			result = False

 			self.char = ord('%')

 			self.blocks = False

+		else:

+			ractions = {}

+			for nleft, actions in self.repeated_actions.items():

+				for (action,args,kwargs) in actions:

+					print action,args,kwargs

+					action(*args, **kwargs)

+					if nleft > 1:

+						ractions.setdefault(nleft-1, []).append( (action,args,kwargs) )

+			self.repeated_actions = ractions

 		return result

 	def ishostile(self, other):

@@ -85,32 +113,43 @@ class Actor(Overlay):

 		if isinstance(other, Actor) and other.ishostile(self):

 			self.adventurer.attack(other.adventurer)

 			other.trigger_event('attacked', self)

-		elif isinstance(other, Object):

+

+	def interact(self, other):

+		result = False

+		if isinstance(other, Object):

+			result = True

 			self.pickup(other)

 			other.trigger_event('picked_up', self)

 		other.trigger_event('bumped', self)

+		return result

+

+	def pickup(self, other):

+		self.inventory.append(other)

-	@Overlay.handle_event('attacked')

 	def attacked_by(self, other):

 		if self.adventurer.skills.check('agility'):

 			self.adventurer.attack(other.adventurer)

-	@Overlay.handle_event('bumped')

 	def bumped_by(self, other):

 		print '%s was bumped by %s' % (type(self).__name__, type(other).__name__)

+@Overlay.add_event('picked_up',  'picked_up_by')

+@Overlay.add_event('bumped',  'bumped_by')

 class Object(Overlay):

 	item = None

-	@Overlay.handle_event('picked_up')

+	handled_events = collections.OrderedDict()

 	def picked_up_by(self, other):

+		events.EventHandler().trigger_event('msg', 'picked up a %s' % self)

 		self.map.remove(self)

+	def bumped_by(self, other): pass

 class Weapon(Object):

 	item = None

 class Potion(Object):

 	char = ord('!')

+	def __str__(self): return 'potion'

 class Scroll(Object):

 	char = ord('!')

@@ -1,3 +1,6 @@

+if __name__ == '__main__':

+    execfile('/home/edwlan/python_envs/roguelike/bin/activate_this.py',  dict(__file__='/home/edwlan/python_envs/roguelike/bin/activate_this.py'))

+

 import libs.patch_random

 import random

 #random.seed(2)

@@ -5,6 +8,7 @@ import random

 import libtcodpy as tc

 import numpy as np

+from gui import text_display

 from libs import overlay

 from libs import combat

 from src import events

@@ -15,20 +19,32 @@ from src import map

 import random

 import bisect

+from twisted.internet import reactor

+import twisted.internet

-WIDTH = 79

-HEIGHT = 46

+

+WIDTH = 118

+HEIGHT = 62

 class Application(object):

 	def __init__(self):

-		self.screen = console.Screen(WIDTH, HEIGHT)

+		self.screen = console.Screen(WIDTH, HEIGHT+5)

+		self.console = console.Console(WIDTH, HEIGHT, self.screen)

+		self.message_console = console.Console(WIDTH, 5, self.screen, (0,HEIGHT))

+		self.messages = text_display.MessageBox(self.message_console, 5, (10,0), 'msg')

+		self.fps_display = text_display.Label(self.message_console, (0,0), None)

+

 		self.terrain_registry = map.TerrainRegistry()

 		self.terrain_registry.load_from_file('data/terrain.yml')

-		self.map = map.Map(WIDTH,HEIGHT, self.terrain_registry)

-		self.player = player.Player(4,5, self.map, combat.Adventurer.randomize())

+		self.map = map.Map(200,200, self.terrain_registry)

+		self.tc_events = events.TCODEventHandler()

 		self.events = events.EventHandler()

-		player.ArrowHandler(self.player, self.events)

-		self.actors = []

+		self.player = player.Player(4,5, self.map, combat.Adventurer.randomize())

+		self.player_stat = text_display.TextBox(self.message_console, 4, (0,1))

+		self.player.claim_display(self.player_stat)

+		player.ArrowHandler(self.player, self.tc_events)

+

+		self.actors = [self.player]

 		for x in range(40):

 			self.actors.append(overlay.Actor(random.randrange(WIDTH), random.randrange(HEIGHT), self.map))

@@ -36,7 +52,7 @@ class Application(object):

 		for x in range(50):

 			self.objects.append(overlay.Potion(random.randrange(WIDTH), random.randrange(HEIGHT), self.map))

-		tc.sys_set_fps(60)

+		tc.sys_set_fps(30)

 	def update_actors(self):

 		to_pop = []

@@ -44,25 +60,33 @@ class Application(object):

 			if not actor.tick():

 				bisect.insort(to_pop, idx)

 		for pop in reversed(to_pop):

-			self.actors.pop(pop)

+			actor = self.actors.pop(pop)

+			self.objects.append(actor)

 	def init(self):

 		self.screen.init("test")

-		self.player.draw()

+		self.message_console.fill(0,0,128)

+		#self.player.draw()

 		self.update_actors()

 		for overlay in self.actors + self.objects:

 			overlay.draw()

-	def run(self):

-		while not tc.console_is_window_closed():

-			self.events.tick()

-			self.update_actors()

-			self.map.draw(self.screen)

-			tc.console_print(0, 0,1, '%d' % tc.sys_get_fps())

-			tc.console_flush()

+	def tick(self):

+		self.tc_events.tick()

+		self.fps_display.set_text('%d', tc.sys_get_fps())

+		self.update_actors()

+		self.map.draw(self.console)

+		self.console.blit()

+		self.message_console.blit()

+		tc.console_flush()

+		if tc.console_is_window_closed():

+			reactor.stop()

+		else:

+			reactor.callLater(0, self.tick)

 if __name__ == '__main__':

 	app = Application()

 	app.init()

-	app.run()

+	reactor.callWhenRunning(app.tick)

+	reactor.run()

@@ -1,14 +1,55 @@

 import libtcodpy as tc

+import numpy as np

 class Console(object):

 	# TBI: must have a self.con member with the console to be drawn on

-	pass

+	@property

+	def dim(self):

+		return self.width, self.height

-class Screen(object):

-	def __init__(self, w, h):

+	def __init__(self, w,h, parent=None, offset=(0,0)):

 		self.width = w

 		self.height = h

-		self.con = 0

+		self.offset = offset

+		self.parent = parent

+

+		if parent is None:

+			self.con = 0

+		else:

+			self.con = tc.console_new(w,h)

+

+	def blit(self):

+		if self.parent is not None:

+			xdst,ydst = self.offset

+			tc.console_blit(self.con, 0,0, self.width, self.height, self.parent.con, xdst,ydst)

+

+	def set_bg(self, r,g,b):

+		tc.console_set_default_background(self.con, r,g,b)

+

+	def set_fg(self, r,g,b):

+		tc.console_set_default_foreground(self.con, r,g,b)

+

+	def clear(self):

+		tc.console_clear(self.con)

+

+	def fill(self, r,g,b):

+		r = np.ones(self.dim) * r

+		g = np.ones(self.dim) * g

+		b = np.ones(self.dim) * b

+		tc.console_fill_background(self.con, r,g,b)

+

+	def print_(self, pos, msg, *fmt):

+		x,y = pos

+		tc.console_print(self.con, x,y, msg % fmt)

+

+

+

+

+class Screen(Console):

+	# Root console

 	def init(self, title, fullscreen=False):

 		tc.console_init_root(self.width, self.height, title, fullscreen, 2)

 		return self

+

+	def flush(self):

+		tc.console_flush()

@@ -1,6 +1,22 @@

 import libtcodpy as tc

+import collections

 class EventHandler(object):

+	events = {}

+	def register_event(self, event):

+		return self.events.setdefault(event, [])

+	def handle_event(self, event, cb, *a, **kw):

+		cbs = self.register_event(event)

+		cbs.append( (cb, a, kw) )

+	def trigger_event(self, event, *a, **kw):

+		for cb, args, kwargs in self.events.get(event,[]):

+			kw.update(kwargs)

+			a += args

+			result = cb(*a, **kw)

+			if result is not None and not result: break

+

+

+class TCODEventHandler(object):

 	def __init__(self):

 		self.key = tc.Key()

 		self.mouse = tc.Mouse()

@@ -51,35 +51,47 @@ class Map(object):

 			for other in self.overlays[x,y]:

 				object.bump(other)

-	def move(self, object, dx,dy):

-		self.overlays[object.pos].remove(object)

+	def interact(self, a, bs):

+		print 'interacting with:', bs

+		for b in bs:

+			a.interact(b)

-		collide_x, collide_y = None, None

+	def remove(self, object):

+		pos = object.pos

+		if pos in self.overlays and object in self.overlays[pos]:

+			self.overlays[pos].remove(object)

+

+	def move(self, object, dx,dy, update_cb):

+		ox,oy = object.pos

 		if abs(dx) < 2 and abs(dy) < 2:

-			ox,oy = object.pos

+			self.overlays[object.pos].remove(object)

+

+			collide_x, collide_y = None, None

 			x = squeeze(ox+dx, 0, self.width-1)

 			y = squeeze(oy+dy, 0, self.height-1)

 			if not self.is_passable((x,y)):

 				collide_x, collide_y = x,y

 				x,y = ox,oy

+			update_cb(x-ox, y-oy)

+

+			if collide_x is not None:

+				self.check_and_execute_bump(object, collide_x, collide_y)

+			if object.pos in self.overlays:

+				self.interact(object, self.overlays[object.pos])

+			self.overlays.setdefault((x,y), []).append(object)

+			self.update_overlay(ox,oy)

 		else:

-			ox,oy = object.pos

-			tx,ty = ox+dx, oy+dy

-			gx,gy = ox,oy

-			for x,y in libs.bresenham.line(ox,oy, tx,ty, 1):

-				if not self.is_passable((x,y)):

-					collide_x, collide_y = x,y

+			# calculate the deltas for each step

+			line = list(libs.bresenham.line(0,0, dx,dy, 0))

+			line = [(bx-ax, by-ay) for (ax,ay), (bx,by) in zip(line,line[1:])]

+			print line

+			for x,y in line:

+				if self.move(object, x,y, update_cb) != (x,y):

 					break

-				else: gx,gy = x,y

-			x,y = gx,gy

+			x,y = object.pos

-		if collide_x is not None:

-			self.check_and_execute_bump(object, collide_x, collide_y)

-

-		self.overlays.setdefault((x,y), []).append(object)

-		self.update_overlay(ox,oy)

 		return x-ox, y-oy

 	def update_overlay(self, x=None, y=None):

@@ -102,38 +114,55 @@ class Map(object):

 	def get_rgb(self, colors, fg=True,slices=(slice(0),slice(0))):

-		result = np.rollaxis(colors[slices], 2)

+		result = np.rollaxis(colors, 2)

 		return [x.transpose() for x in result]

 	def draw(self, con, tl=(0,0)):

+		def mv(x,y, (lx,ty)):

+			return x-lx, y-ty

 		br = tl[0]+con.width, tl[1]+con.height

+		slices = slice(tl[0], br[0]), slice(tl[1], br[1])

 		fgcolors = self.fgcolors.astype('int')

 		bgcolors = self.bgcolors.astype('int')

 		color_mask = np.ones( (con.width, con.height, 3) )

 		char_mask = np.ones( (con.width, con.height) ).astype('bool')

+

 		if self.pov is not None:

 			origin, radius = self.pov

+			ox, oy = origin

+			if ox+radius >= br[0] or oy+radius >= br[1]:

+				xmod, ymod = 0,0

+				if ox + radius >= br[0]:

+					xmod = min(ox + radius - br[0], self.width - br[0])

+				if oy + radius >= br[1]:

+					ymod =  min(oy + radius - br[1], self.height - br[1])

+				br = br[0] + xmod, br[1] + ymod

+				tl = tl[0] + xmod, tl[1] + ymod

+				slices = slice(tl[0], br[0]), slice(tl[1], br[1])

 			def calc_mask():

 				for x in range(tl[0], br[0]):

 					for y in range(tl[1], br[1]):

 						if not self.fov.is_visible(origin, radius, (x,y)):

-							color_mask[x,y] = (0.25, 0.5, 0.5)

-							char_mask[x,y] = False

+							color_mask[x-tl[0], y-tl[1]] = (0.25, 0.5, 0.5)

+							char_mask[x-tl[0], y-tl[1]] = False

 				return color_mask, char_mask

-			color_mask, char_mask = self.povcache.get( (origin,radius), calc_mask )

-			fgcolors = (fgcolors * color_mask).astype('int')

-			bgcolors = (bgcolors * color_mask).astype('int')

+			color_mask, char_mask = self.povcache.get( (origin,radius,tl), calc_mask )

+			fgcolors = (fgcolors[slices] * color_mask).astype('int')

+			bgcolors = (bgcolors[slices] * color_mask).astype('int')

+		else:

+			fgcolors = fgcolors[slices]

+			bgcolors = bgcolors[slices]

-		slices = slice(tl[0], tl[0]+con.width), slice(tl[1], tl[1]+con.height)

-		tc.console_fill_foreground(con.con, *self.get_rgb(fgcolors, slices=slices))

-		tc.console_fill_background(con.con, *self.get_rgb(bgcolors, False,slices=slices))

+		tc.console_fill_foreground(con.con, *self.get_rgb(fgcolors))

+		tc.console_fill_background(con.con, *self.get_rgb(bgcolors, False))

 		chars = np.copy(self.map[slices])

 		for x,y in self.overlays:

 			screen_x = x-tl[0]

 			screen_y = y-tl[1]

-			if not char_mask[screen_x,screen_y]: continue

+			if (not (tl[0] <= x < br[0])) or (not (tl[1] <= y < br[1])): continue

+			elif not char_mask[screen_x,screen_y]: continue

 			if 0 <= screen_x < con.width and 0 <= screen_y < con.height:

 				obj = self.overlays[x,y][-1]

 				chars[screen_x,screen_y] = obj.char

@@ -183,7 +212,7 @@ class FovCache(object):

 			self.fovmaps[key] = fovmap

 			x,y = origin

-			tc.map_compute_fov(fovmap, x,y, radius)

+			tc.map_compute_fov(fovmap, x,y, radius, algo=tc.FOV_DIAMOND)

 		return fovmap

@@ -10,10 +10,17 @@ class Player(libs.overlay.Actor):

 		libs.overlay.Actor.__init__(self, x,y, map, adventurer)

 		print 'Player\'s name is %s' % self.adventurer.name

 		self.map.set_pov((self.pos, self.light_radius))

+		self.display = None

 	def move(self, dx, dy):

 		libs.overlay.Actor.move(self, dx,dy)

 		self.map.set_pov((self.pos, self.light_radius))

+	def claim_display(self, display):

+		self.display = display

+	def tick(self):

+		print 'player_tick'

+		return libs.overlay.Actor.tick(self)

+

 class ArrowHandler(object):

 	def __init__(self, player, eh):

 		self.player = player

@@ -21,28 +28,23 @@ class ArrowHandler(object):

 		eh.register(tc.KEY_RIGHT,self.right)

 		eh.register(tc.KEY_UP,self.up)

 		eh.register(tc.KEY_DOWN,self.down)

+

+	def do_move(self, shift, dx, dy):

+		self.player.add_repeated_action(10 if shift else 1, self.player.move, dx,dy)

+

 	def left(self, alt, shift, ctrl):

-		val = 10 if shift else 1

-		if alt:

-			self.player.move(-val, -val)

-		else:

-			self.player.move(-val, 0)

+		dx,dy = (-1,-1) if alt else (-1,0)

+		self.do_move(shift, dx,dy)

+

 	def right(self, alt, shift, ctrl):

-		val = 10 if shift else 1

-		if alt:

-			self.player.move(val, val)

-		else:

-			self.player.move(val, 0)

+		dx,dy = (1,1) if alt else (1,0)

+		self.do_move(shift, dx,dy)

+

 	def up(self, alt, shift, ctrl):

-		val = 10 if shift else 1

-		if alt:

-			self.player.move(val, -val)

-		else:

-			self.player.move(0, -val)

+		dx,dy = (1,-1) if alt else (0,-1)

+		self.do_move(shift, dx,dy)

+

 	def down(self, alt, shift, ctrl):

-		val = 10 if shift else 1

-		if alt:

-			self.player.move(-val, val)

-		else:

-			self.player.move(0, val)

+		dx,dy = (-1,1) if alt else (0,1)

+		self.do_move(shift, dx,dy)