Merge lp:pyqtrpg/debug into lp:pyqtrpg/trunk

[Alistair Broomhead]

merging features and fixes from debug to trunk

[Alistair Broomhead (alistair-broomhead)]

now runs fine on windows

review: Approve

=== added file 'Display.py'
--- Display.py	1970-01-01 00:00:00 +0000
+++ Display.py	2011-01-14 22:02:00 +0000
@@ -0,0 +1,4 @@
+from _Display import (DisplayObject,
+                      DisplayWindow,
+                      Interface,
+                      DebugOutput)
\ No newline at end of file

=== added file 'GameObjects/_Character.py'
--- GameObjects/_Character.py	1970-01-01 00:00:00 +0000
+++ GameObjects/_Character.py	2011-01-14 22:02:00 +0000
@@ -0,0 +1,46 @@
+from PyQt4.Qt import pyqtSignal
+from _Containable    import Containable
+class Character(Containable):
+  broadcast = pyqtSignal(str)
+  def tick(self):
+    def getcmd(c):
+      x =  c.getfirst()
+      return x[0], x[1:]
+    c = self.commands
+    if c.len:
+      obj,cmd = getcmd(c)
+      while obj != self:
+        obj.commands.add(c.pop())
+        obj,cmd = getcmd(c)
+      x,y = self.position
+      self.broadcast.emit("%s@%s:\t%s"%(self.name, self.position,`cmd`))
+      if cmd[0] == 'up':
+        self.position = (x,y-1)
+        c.pop()
+      elif cmd[0] == 'down':
+        self.position = (x,y+1)
+        c.pop()
+      elif cmd[0] == 'left':
+        self.position = (x-1,y)
+        c.pop()
+      elif cmd[0] == 'right':
+        self.position = (x+1,y)
+        c.pop()
+      elif cmd[0] in ['move', 'attack']:
+        X,Y = cmd[1]
+        if X-x > 0:
+          self.position = (x+1,y)
+        elif X-x < 0:
+          self.position = (x-1,y)
+        elif Y-y > 0:
+          self.position = (x,y+1)
+        elif Y-y < 0:
+          self.position = (x,y-1)
+        if (X-x)**2 + (Y-y)**2 == 1:
+          c.pop()
+      self._allObjects[0].Changed.emit()
+
+  def __init__(self, **kwargs):
+    if not 'name' in kwargs:
+      kwargs['name'] = 'Unknown Character'
+    Containable.__init__(self, **kwargs)
\ No newline at end of file

=== modified file 'GameObjects/_Containable.py'
--- GameObjects/_Containable.py	2010-11-22 06:47:41 +0000
+++ GameObjects/_Containable.py	2011-01-14 22:02:00 +0000
@@ -9,5 +9,6 @@
       assert isinstance(info[1], info[0])
       self.container = container
       container.addContent(self)
-    except Exception, e: 
+      container.contents.sort()
+    except Exception, e:
       e.args = self._custAssert(info, e.args),
\ No newline at end of file

=== modified file 'GameObjects/_GameObject.py'
--- GameObjects/_GameObject.py	2010-11-22 06:47:41 +0000
+++ GameObjects/_GameObject.py	2011-01-14 22:02:00 +0000
@@ -1,4 +1,9 @@
-class GameObject(object):
+from commandList import commandQueue
+from PyQt4.QtCore import QObject, pyqtSignal
+class _contentList(list):
+  def sort(self):
+    list.sort(self,key=lambda tile:tile.flag)
+class GameObject(QObject):
   """
   This is the class which all objects in the game must subclass. This
   enables us to keep a list of all game objects.
@@ -7,6 +12,8 @@
   detection - this should also be useful for debugging, and probably for
   purposes I have not yet thought of.
   """
+  ItemAdded = pyqtSignal(str)
+  Changed   = pyqtSignal()
   _allObjects = []
   def __getitem__(self,i):
     return self.contents[i]
@@ -17,7 +24,7 @@
     """Returns all GameObjects decended from the same type as self"""
     return [x for x in self._allObjects
             if isinstance(x, type(self))]
-            
+
   def _custAssert(self,(expected, got, input), e_args):
     return ' '.join(("You tried to input a", `input`, ':',
                      `type(got)`, ',', `got`, 'into ',
@@ -28,7 +35,7 @@
       info = (GameObject, content, "Item to be added to "+self.name)
       assert isinstance(info[1], info[0])
       self.contents.append(content)
-    except Exception, e: 
+    except Exception, e:
       e.args = self._custAssert(info, e.args),
       raise
   def __init__(self, position=(0,0),
@@ -36,10 +43,23 @@
                      size=(-1,-1),
                      stats={},
                      contents=[],
-                     name="Unknown Object"):
+                     name="Unknown Object",
+                     image='',
+                     flag=0):
+    QObject.__init__(self)
+
+    self.commands = commandQueue()
     try:
+      # On some platforms there is no support for python beyond 2.5.4
+      # ABC's were only implemented in python 2.6 so we'll fall back to
+      # integers if we can't use Number - the base class for int and float etc
       from numbers import Number
-      # Check position is a tuple 
+    except:
+      Number = int
+    try:
+      self.flag = flag
+      
+      # Check position is a tuple
       info = (tuple, position, "position")
       assert isinstance(info[1], info[0])
       info = (Number, position[0], "position_x")
@@ -47,8 +67,8 @@
       info = (Number, position[1], "position_y")
       assert isinstance(info[1], info[0])
       self.position = position
-      
-      # Check size is a tuple
+
+      # Check heading is a tuple
       info = (tuple, heading, "heading")
       assert isinstance(info[1], info[0])
       info = (Number, heading[0], "heading_speed")
@@ -56,30 +76,39 @@
       info = (Number, heading[1], "heading_XY_angle")
       assert isinstance(info[1], info[0])
       self.heading = heading
-      
+
       # Check size is a tuple
       info = (tuple, size, "size")
       assert isinstance(info[1], info[0])
       self.size = size
-      
-      # Check size is a tuple
+
+      # Check name is a string
       info = (str, name, "name")
       assert isinstance(info[1], info[0])
       self.name = name
-      
+
       # Check stats is a dictionary
       info = (dict, stats, "stats")
       assert isinstance(info[1], info[0])
       self.stats = stats.copy()
-      
+
       # Check contents is a list
       info = (list, contents, "contents")
       assert isinstance(info[1], info[0])
       for obj in contents:
           info = (GameObject, obj, "object in contents")
           assert isinstance(info[1], info[0])
-      self.contents = contents[:]
+      def _sort():
+        pass
+      self.contents = _contentList(contents[:])
+      #self.contents.sort = _sort
       self._allObjects.append(self)
-    except Exception, e: 
+      self._allObjects[0].ItemAdded.emit(self.name)
+
+      # Check image is a string
+      info = (str, image, "image")
+      assert isinstance(info[1], info[0])
+      self.image = image
+    except Exception, e:
       e.args = self._custAssert(info, e.args),
-      raise
\ No newline at end of file
+      raise

=== added file 'GameObjects/_Level.py'
--- GameObjects/_Level.py	1970-01-01 00:00:00 +0000
+++ GameObjects/_Level.py	2011-01-14 22:02:00 +0000
@@ -0,0 +1,5 @@
+from _World   import World
+class Level(World):
+  def __init__(self, container, **kwargs):
+    kwargs.setdefault('name', 'Unknown Level')
+    parent = World.__init__(self, container, **kwargs)
\ No newline at end of file

=== modified file 'GameObjects/__init__.py'
--- GameObjects/__init__.py	2010-11-22 06:47:41 +0000
+++ GameObjects/__init__.py	2011-01-14 22:02:00 +0000
@@ -1,10 +1,12 @@
 from _GameObject    import GameObject
 from _Containable   import Containable
 from _World         import World
+from _Level         import Level
 from _Weapon        import Weapon
+
+# Further object types being defined
+from _Character     import Character as Character
 # Further object types to be implemented
 #from _Potion        import Potion
-#from _Resource      import Resource
-#from _Character     import Character
-#from _NCP           import NCP
+#from _Resource      import Resource
#from _NCP           import NCP
 #from _Quests        import Quests

=== added file 'GameObjects/_fifo.py'
--- GameObjects/_fifo.py	1970-01-01 00:00:00 +0000
+++ GameObjects/_fifo.py	2011-01-14 22:02:00 +0000
@@ -0,0 +1,47 @@
+class _first(object):
+  def __get__(self):
+    new_ = (x for x in self._parent._list[0])
+    return self._parent._list[0]
+  def __set__(self, new_):
+    #new_ = (x for x in new_)
+    self._parent._parent.takenFrom.emit(self._parent._list[0])
+    self._parent._parent.addedTo.emit(new_)
+    self._parent._list[0] = (new_)
+  def __del__(self):
+    self._parent._parent.takenFrom.emit(self._parent._list.pop(0))
+    if not self._parent._list:
+      self._parent._parent.isEmpty.emit()
+  def __init__(self,parent):
+    self._parent = parent
+
+class _fifo(object):
+  def __get__(self):
+    new_ = [x for x in self._list]
+    return new_
+  def __set__(self, new_):
+    #new_ = (x for x in new_)
+    if not self._list:
+      self._parent.isNotEmpty.emit()
+    self._list.extend(new_)
+    for item in new_:
+      self._parent.addedTo.emit(item)
+  def __getitem__(self, k):
+    new_ = (x for x in self._list[k])
+    return self._list[k]
+  def getfirst(self):
+    new_ = (x for x in self._list[0])
+    return self._list[0]
+  def pop(self):
+    item = self.getfirst()
+    self.first.__del__()
+    return item
+  def append(self, item):
+    self.__set__([item,])
+  def __init__(self, parent, other=None):
+    self._list = []
+    self._parent = parent
+    self.first = _first(self)
+    if other:
+      for X in other:
+        #X = (x for x in X)
+        self._list.append(X)
\ No newline at end of file

=== added file 'GameObjects/commandList.py'
--- GameObjects/commandList.py	1970-01-01 00:00:00 +0000
+++ GameObjects/commandList.py	2011-01-14 22:02:00 +0000
@@ -0,0 +1,21 @@
+from PyQt4.Qt import (QObject,
+                      pyqtSignal,
+                      QString)
+from _fifo import _fifo
+class commandQueue(QObject):
+  addedTo = pyqtSignal(tuple)
+  takenFrom = pyqtSignal(tuple)
+  isNotEmpty = pyqtSignal()
+  isEmpty = pyqtSignal()
+  def add(self, *item):
+    self._fifo.append(tuple(item))
+  def __init__(self):
+    QObject.__init__(self)
+    self._fifo = _fifo(self)
+    self.first = self._fifo.first
+    self.getfirst = self._fifo.getfirst
+    self.pop = self._fifo.pop
+    self.isEmpty.emit()
+  @property
+  def len(self):
+    return len(self._fifo._list)
\ No newline at end of file

=== added directory 'Levels'
=== added file 'Levels/Level00.py'
--- Levels/Level00.py	1970-01-01 00:00:00 +0000
+++ Levels/Level00.py	2011-01-14 22:02:00 +0000
@@ -0,0 +1,27 @@
+# Levels are defined as tuple grids - each square of the tuple grid
+# is a square of a game map.
+from objects import *
+level = (
+( Wall,   Wall,   Wall,   Wall,   Wall,   Wall,   Wall,   Wall,   Wall,   Wall,   Wall,   Wall),
+
+( Wall,   Floor,  Floor,  Floor,  Wall,   Out,    Out,    Wall,   Floor,  Floor,  Floor,  Wall),
+
+( Wall,   Floor, (Floor,
+                  Player),Floor,  Wall,   Out,    Out,    Wall,   Floor,  Floor,  Floor,  Wall),
+
+( Wall,   Floor,  Floor,  Floor,  Wall,   Wall,   Wall,   Floor,  Floor,  Floor,  Floor,  Wall),
+
+( Wall,   Floor, (Floor,
+                  Sword), Floor,  Floor,  Floor,  Floor,  Floor,  Wall,   Wall,   Floor, (Floor,
+                                                                                          Door)),
+
+( Wall,   Floor,  Floor,  Floor,  Floor,  Floor,  Floor,  Wall,   Out,    Wall,   Floor,  Wall),
+
+( Wall,   Floor,  Floor,  Floor,  Floor,  Floor,  Floor,  Wall,   Out,    Wall,   Floor,  Wall),
+
+( Wall,   Floor,  Floor,  Floor,  Floor,  Floor,  Floor,  Wall,   Out,    Wall,   Floor,  Wall),
+
+( Wall,   Floor,  Floor,  Floor,  Floor,  Floor,  Floor,  Wall,   Out,    Wall,   Floor,  Wall),
+
+( Wall,   Wall,   Wall,   Wall,   Wall,  Wall,    Wall,   Wall,   Wall,   Wall,   Wall,   Wall),
+)
\ No newline at end of file

=== added file 'Levels/Level01.py'
=== added file 'Levels/World00.py'
--- Levels/World00.py	1970-01-01 00:00:00 +0000
+++ Levels/World00.py	2011-01-14 22:02:00 +0000
@@ -0,0 +1,3 @@
+world = []
+import Level00; world.append(Level00.level)
+#import Level01; world.append(Level01.level)
\ No newline at end of file

=== added file 'Levels/__init__.py'
--- Levels/__init__.py	1970-01-01 00:00:00 +0000
+++ Levels/__init__.py	2011-01-14 22:02:00 +0000
@@ -0,0 +1,2 @@
+worlds = []
+import World00; worlds.append(World00.world)
\ No newline at end of file

=== added file 'Levels/objects.py'
--- Levels/objects.py	1970-01-01 00:00:00 +0000
+++ Levels/objects.py	2011-01-14 22:02:00 +0000
@@ -0,0 +1,92 @@
+# This gives a set of objects that can be used to build levels
+
+class _statsobject(object):
+  def __get__(self):
+    return self.__dict__.__get__()
+  def __str__(self):
+    return self.__dict__.__str__()
+  def __repr__(self):
+    return self.__dict__.__repr__()
+  def copy(self):
+    return self.__init__(self)
+  def __getattr__(self,k):
+    return None
+  def __init__(self,old=None):
+    if old:
+      self.__dict__ = old.__dict__.copy()
+    else: self.__dict__ = {}
+class _flagobject(object):
+  def __call__(self, flag):
+    if type(flag) == type(int) and flag&self._value:
+      return True
+    if type(flag) == type(self) and flag._value&self._value:
+      return True
+    return False
+  def __get__(self):
+    return self._value.__get__()
+  def __str__(self):
+    return hex(self._value)
+  def __repr__(self):
+    return repr(hex(self._value))
+  def __init__(self,flag):
+    if flag == 0:
+      self._value = 0
+    else:
+      self._value = 2**(flag-1)
+class _objectMarker(object):
+  @property
+  def stats(self):
+    return self._stats
+  @property
+  def flag(self):
+    return self._flag
+  @property
+  def image(self):
+    return self._image
+  def __get__(self):
+    return self._flag.__get__()
+  def __str__(self):
+    return self._flag.__str__()
+  def __repr__(self):
+    return self._flag.__repr__()
+  def __nonzero__(self):
+    return self._flag.__nonzero__()
+  def __cmp__(self, other):
+    return self._flag.__cmp__(other)
+  def __init__(self,flag,image='',**kwargs):
+    self.__dict__['_flag'] = _flagobject(flag)
+    self.__dict__['_stats'] = _statsobject()
+    self.__dict__['_stats'].__dict__ = kwargs
+    self.__dict__['_image'] = image
+  def __setattr__(self,k,v):
+    try:
+      assert k in self.__dict__
+      self.__dict__[k] = v
+    except AssertionError:
+      raise AttributeError, "'%s' is not an attribute of class '%s'"%(k,self.__class__.__name__)
+
+
+Out      = _objectMarker(0)
+
+Floor    = _objectMarker(1,  'GenericCarpet')
+Wall     = _objectMarker(2,  'GenericWall')
+Door     = _objectMarker(3)
+
+Player   = _objectMarker(4,  'GenericCharacter')
+#Friend   = _objectMarker(5)
+#Neutral  = _objectMarker(6)
+#Enemy    = _objectMarker(7)
+
+#Book     = _objectMarker(8)
+#Scroll   = _objectMarker(9)
+#HPotion  = _objectMarker(10)
+#MPotion  = _objectMarker(11)
+
+#Box      = _objectMarker(12)
+#Resource = _objectMarker(13)
+
+#Dagger   = _objectMarker(14)
+#Bow      = _objectMarker(15)
+#Axe      = _objectMarker(16)
+Shield   = _objectMarker(17)
+Sword    = _objectMarker(18,  'GenericWeapon')

=== added directory '_Display'
=== added directory '_Display/Buttons'
=== added file '_Display/Buttons/attack.png'
Binary files _Display/Buttons/attack.png	1970-01-01 00:00:00 +0000 and _Display/Buttons/attack.png	2011-01-14 22:02:00 +0000 differ
=== added file '_Display/Buttons/close.png'
Binary files _Display/Buttons/close.png	1970-01-01 00:00:00 +0000 and _Display/Buttons/close.png	2011-01-14 22:02:00 +0000 differ
=== added file '_Display/Buttons/down.png'
Binary files _Display/Buttons/down.png	1970-01-01 00:00:00 +0000 and _Display/Buttons/down.png	2011-01-14 22:02:00 +0000 differ
=== added file '_Display/Buttons/fullscr.png'
Binary files _Display/Buttons/fullscr.png	1970-01-01 00:00:00 +0000 and _Display/Buttons/fullscr.png	2011-01-14 22:02:00 +0000 differ
=== added file '_Display/Buttons/left.png'
Binary files _Display/Buttons/left.png	1970-01-01 00:00:00 +0000 and _Display/Buttons/left.png	2011-01-14 22:02:00 +0000 differ
=== added file '_Display/Buttons/move.png'
Binary files _Display/Buttons/move.png	1970-01-01 00:00:00 +0000 and _Display/Buttons/move.png	2011-01-14 22:02:00 +0000 differ
=== added file '_Display/Buttons/right.png'
Binary files _Display/Buttons/right.png	1970-01-01 00:00:00 +0000 and _Display/Buttons/right.png	2011-01-14 22:02:00 +0000 differ
=== added file '_Display/Buttons/up.png'
Binary files _Display/Buttons/up.png	1970-01-01 00:00:00 +0000 and _Display/Buttons/up.png	2011-01-14 22:02:00 +0000 differ
=== added directory '_Display/Sprites'
=== added file '_Display/Sprites/Generic.png'
Binary files _Display/Sprites/Generic.png	1970-01-01 00:00:00 +0000 and _Display/Sprites/Generic.png	2011-01-14 22:02:00 +0000 differ
=== added file '_Display/Sprites/GenericCarpet.png'
Binary files _Display/Sprites/GenericCarpet.png	1970-01-01 00:00:00 +0000 and _Display/Sprites/GenericCarpet.png	2011-01-14 22:02:00 +0000 differ
=== added file '_Display/Sprites/GenericCharacter.png'
Binary files _Display/Sprites/GenericCharacter.png	1970-01-01 00:00:00 +0000 and _Display/Sprites/GenericCharacter.png	2011-01-14 22:02:00 +0000 differ
=== added file '_Display/Sprites/GenericPotion.png'
Binary files _Display/Sprites/GenericPotion.png	1970-01-01 00:00:00 +0000 and _Display/Sprites/GenericPotion.png	2011-01-14 22:02:00 +0000 differ
=== added file '_Display/Sprites/GenericWall.png'
Binary files _Display/Sprites/GenericWall.png	1970-01-01 00:00:00 +0000 and _Display/Sprites/GenericWall.png	2011-01-14 22:02:00 +0000 differ
=== added file '_Display/Sprites/GenericWeapon.png'
Binary files _Display/Sprites/GenericWeapon.png	1970-01-01 00:00:00 +0000 and _Display/Sprites/GenericWeapon.png	2011-01-14 22:02:00 +0000 differ
=== added file '_Display/Sprites/Thumbs.db'
Binary files _Display/Sprites/Thumbs.db	1970-01-01 00:00:00 +0000 and _Display/Sprites/Thumbs.db	2011-01-14 22:02:00 +0000 differ
=== added file '_Display/_DebugOutput.py'
--- _Display/_DebugOutput.py	1970-01-01 00:00:00 +0000
+++ _Display/_DebugOutput.py	2011-01-14 22:02:00 +0000
@@ -0,0 +1,32 @@
+from PyQt4.Qt import QTextEdit, QString
+class DebugOutput(QTextEdit):
+  def __init__(self, player, parent, *args, **kwargs):
+    QTextEdit.__init__(self, *args, **kwargs)
+    QTextEdit.setFontPointSize(self, 10)
+    self.setFixedWidth(320)
+    self.setReadOnly(True)
+    x = self.property("kineticScroller").toPyObject()
+    if x:
+      x.setEnabled(True)
+    del x
+    self.text = ''
+    self.parent = parent
+    self.player = player
+    player.commands.addedTo.connect(self._append)
+    player.broadcast.connect(self._append)
+  def _append(self,line):
+    self.append(str(line))
+    #anchor = QString(line)
+    #self.text += '\n'+line
+    #QTextEdit.setText(self,self.text)
+    #self.scrollContentsBy(0,-self.rect().height())
+
+  def resizeEvent(self, event):
+    rect = self.rect()
+    # self.append( 'Debug output:\t' +
+                 # `rect.width()` +
+                 # "x" +
+                 # `rect.height()`)
+    QTextEdit.resizeEvent(self, event)
+  def paintEvent(self, event):
+    QTextEdit.paintEvent(self, event)

=== added file '_Display/_DisplayObject.py'
--- _Display/_DisplayObject.py	1970-01-01 00:00:00 +0000
+++ _Display/_DisplayObject.py	2011-01-14 22:02:00 +0000
@@ -0,0 +1,52 @@
+from PyQt4.Qt       import QMainWindow, QTimer
+class DisplayObject(QMainWindow):
+  def doTicks(s):
+    for char in s.Game.Player.getAllSameClass():
+      char.tick()
+  def exec_(s):
+    s._a.exec_()
+  def __init__(s, Game):
+    from _DebugOutput   import DebugOutput
+    from _DisplayWindow import DisplayWindow
+    from _Interface     import Interface
+    from PyQt4.Qt import QApplication, QWidget, QGridLayout, QIcon
+    from sys import argv
+    import os.path
+    win = (800, 480)
+    s.Game = Game
+    a = QApplication(argv)        # We'll need a QApplication.
+    QMainWindow.__init__(s)       # And it'll be a subclass of QMainWindow,
+    s.resize(*win)                # so initialise it and give it a size.
+    central = QWidget()
+    s.setCentralWidget(central)   # Central widget to contain layout,
+    s.grid = QGridLayout(central) # like so...
+    s.setWindowTitle("pyRPG")     # Let's give it a nice title.
+    s._a = a
+    s.commands = Game.commands
+    iconpath = ("Display/pyrpg.png")
+    s.icon_ = QIcon()
+    s.icon_.addFile(iconpath)
+    s.setWindowIcon(s.icon_)
+
+    s.DebugOutput = DebugOutput(player=Game.Player,parent=s)
+    s.MainGraphicView = DisplayWindow(player=Game.Player,textstream=s.DebugOutput)
+    s.Options = Interface(player=Game.Player,parent=s,textstream=s.DebugOutput)
+    
+    s.grid.addWidget(s.MainGraphicView, 0, 0)
+    s.grid.addWidget(s.Options, 1, 0, 1, 0)
+    s.grid.addWidget(s.DebugOutput, 0, 1)
+
+    s.grid.setMargin(0)
+    s.grid.setSpacing(0)
+    s.grid.setRowStretch (0, 400)
+    s.grid.setRowStretch (1, 80)
+    s.grid.setColumnStretch (0, 480)
+    s.grid.setColumnStretch (1, 320)
+    
+    s.Timer = QTimer()
+    s.Timer.start(200)
+    s.Timer.timeout.connect(s.doTicks)
+    s.Game.Changed.connect(s.MainGraphicView.update)
+
+    s.showFullScreen()            # There's no point doing all of this if we
+                                  # don't show it(FullScreen?)

=== added file '_Display/_DisplayWindow.py'
--- _Display/_DisplayWindow.py	1970-01-01 00:00:00 +0000
+++ _Display/_DisplayWindow.py	2011-01-14 22:02:00 +0000
@@ -0,0 +1,79 @@
+from PyQt4.Qt import (QWidget,
+                      QColor,
+                      QPainter,
+                      QBrush,
+                      pyqtSignal,
+                      QRect)
+
+from PyQt4.QtCore import Qt
+
+class DisplayWindow(QWidget):
+  pressed = pyqtSignal(tuple)
+  released = pyqtSignal(tuple)
+  clicked = pyqtSignal(tuple)
+  dragged = pyqtSignal(tuple)
+  def giveTile(self,x,y):
+    x += self.x_offset
+    y += self.y_offset
+    tsx,tsy = self.tilesize
+    X = x/tsx - 1  + ((x % tsx) != 0)
+    Y = y/tsy - 1 + ((y % tsy) != 0)
+    return X,Y
+  def mousePressEvent(self, event):
+    if event.button() == Qt.LeftButton:
+      pos = self.giveTile(event.x(),event.y())
+      self.pressed.emit(pos)
+      self._TouchStarted = pos
+  def mouseReleaseEvent(self, event):
+    if event.button() == Qt.LeftButton:
+      x,y = self.giveTile(event.x(),event.y())
+      self.released.emit((x,y))
+      X,Y = self._TouchStarted
+      if (x,y) == (X,Y):
+        self.clicked.emit((x,y))
+      else:
+        self.dragged.emit((X-x,Y-y))
+      self._TouchStarted = None
+  def __init__(self, player, textstream, **kwargs):
+    QWidget.__init__(self)
+    self.qp = QPainter()
+    self.textstream = textstream
+    self._TouchStarted = None
+    self.displayQueue = []
+    self.x_offset = 0
+    self.y_offset = 0
+    self.tilesize = (40,40)
+    self.player = player
+  def resizeEvent(self, event):
+    rect = self.rect()
+    self.textstream.append( 'Display window:\t' + `rect.width()` + "x" + `rect.height()`)
+  def _showtile(self, tile, event):
+    from _clickableIcon import clickableIcon
+    for subtile in tile.contents:
+      self._showTile(subtile, event)
+    if tile.image:
+      image = clickableIcon(self, tile.image)
+      x,y = tile.position
+      X,Y = self.tilesize
+      image.setRect(x*X, y*Y, X, Y)
+      image.paintEvent(event)
+  def paintEvent(self, event):
+    self.qp = QPainter()
+    c = (QColor("#121"),
+         QColor("#101"))
+    brush = QBrush(Qt.SolidPattern)
+    rect = self.rect()
+    self.qp.begin(self)
+    self.qp.setBrush(brush)
+    currlevel = self.player.container
+    currworld = currlevel.container
+    otherlevels = (    level
+                   for level
+                   in  currworld.contents
+                   if  type(level) == type(currlevel)
+                   and level != currlevel)
+    for tile in currlevel.contents:
+      self._showtile(tile, event)
+    self.qp.end()
+    QWidget.paintEvent(self, event)
+    self.textstream.append("Drawing")
\ No newline at end of file

=== added file '_Display/_Interface.py'
--- _Display/_Interface.py	1970-01-01 00:00:00 +0000
+++ _Display/_Interface.py	2011-01-14 22:02:00 +0000
@@ -0,0 +1,114 @@
+from PyQt4.QtGui import (QGridLayout,
+                         QWidget,
+                         QColor,
+                         QPainter,
+                         QBrush)
+
+from PyQt4.QtCore import Qt
+import os.path
+class Interface(QWidget):
+  def toggleFullscreen(self):
+    p = self.parent
+    if p.isFullScreen():
+      p.setWindowState(Qt.WindowNoState)
+    else:
+      p.setWindowState(Qt.WindowFullScreen)
+  def move_up(self):
+    self.player.commands.add(self.player,'up')
+  def move_down(self):
+    self.player.commands.add(self.player,'down')
+  def move_left(self):
+    self.player.commands.add(self.player,'left')
+  def move_right(self):
+    self.player.commands.add(self.player,'right')
+  def set_attack(self,bool_in):
+    self.attackmode = bool_in
+  def set_move(self,bool_in):
+    self.movemode = bool_in
+  def handleDisplayDragged(self, pos):
+    self.textstream.append('screen dragged by: '+`pos`)
+  def handleDisplayClicked(self, pos):
+    if self.attackmode:
+      self.player.commands.add(self.player,'attack',pos)
+      self.B_ATTK.toggle()
+    elif self.movemode:
+      self.player.commands.add(self.player,'move',pos)
+      self.B_MOVE.toggle()
+    else:
+      self.textstream.append('screen clicked at: '+`pos`)
+
+  def __init__(self, player, parent, textstream, **kwargs):
+    QWidget.__init__(self)
+
+    def mkbutton(y,x,h=1,w=1,image=None,act=None,toggle=False):
+      from _interfaceButton import interfaceButton
+      if image:
+        b = interfaceButton(self, "_Display/Buttons/"+image+".png")
+      else:
+        b = interfaceButton(self)
+      self.OptionsGrid.addWidget(b,y,x,h,w)
+      if act:
+        if toggle:
+          b.setCheckable(True)
+          b.toggled.connect(act)
+        else:
+          b.clicked.connect(act)
+      return b
+
+    self.qp = QPainter()
+    self.OptionsGrid = QGridLayout(self)
+    self.parent = parent
+    self.player = player
+    self.textstream = textstream
+    self.height = 32
+    self.margin = 4
+    self.spacing = 8
+    self.attackmode = False
+    self.movemode = False
+
+    self.OptionsGrid.setMargin(self.margin)
+    self.OptionsGrid.setSpacing(self.spacing)
+
+    self.parent.MainGraphicView.clicked.connect(self.handleDisplayClicked)
+    self.parent.MainGraphicView.dragged.connect(self.handleDisplayDragged)
+
+    if True: #Spawn buttons
+      self.B_ATTK = mkbutton(0,0,1,1,"Attack",  self.set_attack,True)
+      self.B_MVUP = mkbutton(0,1,1,1,"up",      self.move_up)
+      self.B_MOVE = mkbutton(0,2,1,1,"Move",    self.set_move,True)
+      self.B_0__3 = mkbutton(0,3)
+      self.B_0__4 = mkbutton(0,4)
+      self.B_0__5 = mkbutton(0,5)
+      self.B_0__6 = mkbutton(0,6)
+      self.B_0__7 = mkbutton(0,7)
+      self.B_MVLT = mkbutton(1,0,1,1,"left",    self.move_left)
+      self.B_MVDN = mkbutton(1,1,1,1,"down",    self.move_down)
+      self.B_MVRT = mkbutton(1,2,1,1,"right",   self.move_right)
+      self.B_1__3 = mkbutton(1,3)
+      self.B_1__4 = mkbutton(1,4)
+      self.B_1__5 = mkbutton(1,5)
+      self.B_1__6 = mkbutton(1,6)
+      self.B_1__7 = mkbutton(1,7)
+      self.B_QUIT = mkbutton(0,12,2,2,"close",  self.parent.close)
+      self.B_FULL = mkbutton(0,14,2,2,"fullscr",self.toggleFullscreen)
+    self.rowcount = self.OptionsGrid.rowCount()
+    self.setFixedHeight(self.height*self.rowcount +
+                        self.margin*2 +
+                        self.spacing*(self.rowcount-1))
+  def resizeEvent(self, event):
+    rect = self.rect()
+    self.textstream.append( 'Interface:\t\t' +
+                            `rect.width()` +
+                            "x" +
+                            `rect.height()`)
+  def paintEvent(self, event):
+    #print "Painting options"
+    charcoal = QColor("#101010")
+    black = QColor("#000000")
+    brush = QBrush(Qt.SolidPattern)
+    rect = self.rect()
+    self.qp.begin(self)
+    self.qp.setBrush(brush)
+    self.qp.fillRect(rect, charcoal)
+    self.qp.end()
+

=== added file '_Display/__init__.py'
--- _Display/__init__.py	1970-01-01 00:00:00 +0000
+++ _Display/__init__.py	2011-01-14 22:02:00 +0000
@@ -0,0 +1,4 @@
+from _DisplayObject import DisplayObject
+from _DisplayWindow import DisplayWindow
+from _Interface     import Interface
+from _DebugOutput   import DebugOutput
\ No newline at end of file

=== added file '_Display/_clickableIcon.py'
--- _Display/_clickableIcon.py	1970-01-01 00:00:00 +0000
+++ _Display/_clickableIcon.py	2011-01-14 22:02:00 +0000
@@ -0,0 +1,29 @@
+from PyQt4.QtGui import QPushButton, QBrush, QIcon
+from PyQt4.QtCore import Qt, QRect
+
+class clickableIcon(QPushButton):
+  def paintEvent(self, event):
+    r = QRect(self.x, self.y, self.w, self.h)
+    self.image.paint(self.qp, r)
+  def setRect(self,x,y,w,h):
+    r = self.rect()
+    self.x = x
+    self.y = y
+    self.w = w
+    self.h = h
+    r.setRect(x,y,w,h)
+    self.setGeometry(r)
+  def centre(self):
+    r = self.rect()
+    return (r.x()+r.width()/2, r.y()+r.height()/2)
+  def __init__(self,parent,image):
+    QPushButton.__init__(self)
+    self.image = QIcon()
+    self.qp = parent.qp
+    self.x = 0
+    self.y = 0
+    self.w = 0
+    self.h = 0
+    self.imagename = "_Display/Sprites/"+image+".png"
+    self.image.addFile(self.imagename)
+    #self.move(x,y) translates the sprite's rectangle
\ No newline at end of file

=== added file '_Display/_interfaceButton.py'
--- _Display/_interfaceButton.py	1970-01-01 00:00:00 +0000
+++ _Display/_interfaceButton.py	2011-01-14 22:02:00 +0000
@@ -0,0 +1,51 @@
+from PyQt4.QtGui import (QColor,
+                         QPainter,
+                         QIcon,
+                         QImage,
+                         QBrush,
+                         QPushButton,
+                         QLabel,
+                         QSizePolicy,
+                         QKeySequence)
+from PyQt4.QtCore import (QString,
+                          QSize,
+                          Qt)
+import os.path
+class interfaceButton(QPushButton):
+  def paintEvent_(self, event):
+    black = QColor("#000000")
+    charcoal = QColor("#101010")
+    orange = QColor("#F08038")
+    if self.isDown() or (self.isChecked() and self.isCheckable()):
+      background = orange
+    else:
+      background = black
+    brush = QBrush(Qt.SolidPattern)
+    self.qp.begin(self)
+    self.qp.setBrush(brush)
+    self.qp.fillRect(self.rect(), background)
+    self.image.paint(self.qp, self.rect(), state=QIcon.On)
+    self.qp.end()
+  def paintEvent__(self, event):
+    QPushButton.paintEvent(self, event)
+    pass
+  def __init__(self, parent, display='', shortcut=None):
+    QPushButton.__init__(self)
+    self.parent = parent
+    self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
+    try:
+      assert os.path.isfile(display)
+      self.imagename = display
+      self.image = QIcon()
+      self.image.addFile(display)
+      self.image.sizeHint = self.sizeHint
+      self.qp = parent.qp
+      self.paintEvent = self.paintEvent_
+      self.setFlat(True)
+    except:
+      self.setText(display)
+      if display=='':
+        self.setFlat(True)
+      self.paintEvent = self.paintEvent__
+    if shortcut:
+      self.setShortcut(QKeySequence(shortcut))
\ No newline at end of file

=== added file '_Display/pyrpg.png'
Binary files _Display/pyrpg.png	1970-01-01 00:00:00 +0000 and _Display/pyrpg.png	2011-01-14 22:02:00 +0000 differ
=== added file 'layered.ico'
Binary files layered.ico	1970-01-01 00:00:00 +0000 and layered.ico	2011-01-14 22:02:00 +0000 differ
=== modified file 'pyrpg.py'
--- pyrpg.py	2010-11-22 06:47:41 +0000
+++ pyrpg.py	2011-01-14 22:02:00 +0000
@@ -1,20 +1,76 @@
-from GameObjects import GameObject, Containable, World, Weapon
+#!/usr/bin/python
+#
+from GameObjects import GameObject, World, Level, Weapon, Character, Containable
+from Display import DisplayObject
+from Levels import worlds
+from Levels import objects
+def setupTile(x, y, tile, thisLevel, Game):
+  cont = thisLevel
+  if tile.flag != objects.Out.flag:
+    if tile.flag(objects.Floor.flag):# This needs to not be collision-tested
+      Containable(flag=tile.flag, container=cont, position=(x,y), name="Floor@%s"%(`(x,y)`), image=tile.image)
+    if tile.flag(objects.Wall.flag): # This needs to be indestructable
+      Containable(flag=tile.flag, container=cont, position=(x,y), name="Wall@%s"%(`(x,y)`), image=tile.image)
+    if tile.flag(objects.Door.flag): # This needs to link levels
+      Containable(flag=tile.flag, container=cont, position=(x,y), name="Door@%s"%(`(x,y)`), image=tile.image)
+    if tile.flag(objects.Player.flag):
+      Game.Player = Character(flag=tile.flag, container=cont, position=(x,y), name="Player 1", image=tile.image)
+    # if tile.flag(objects.Box.flag):     # Not implemented yet
+      # print "Adding a box","at %s"%(`(x,y)`)
+    # if tile.flag(objects.Resource.flag):# Not implemented yet
+      # print "Adding a resource stash","at %s"%(`(x,y)`)
+    # if tile.flag(objects.Friend.flag):  # Not implemented yet
+      # print "Adding a friend","at %s"%(`(x,y)`)
+    # if tile.flag(objects.Enemy.flag):   # Not implemented yet
+      # print "Adding an enemy","at %s"%(`(x,y)`)
+    # if tile.flag(objects.Neutral.flag): # Not implemented yet
+      # print "Adding a neutral party","at %s"%(`(x,y)`)
+    # if tile.flag(objects.Book.flag):    # Not implemented yet
+      # print "Adding a book","at %s"%(`(x,y)`)
+    # if tile.flag(objects.Scroll.flag):  # Not implemented yet
+      # print "Adding a scroll","at %s"%(`(x,y)`)
+    # if tile.flag(objects.HPotion.flag): # Not implemented yet
+      # print "Adding a health potion","at %s"%(`(x,y)`)
+    # if tile.flag(objects.MPotion.flag): # Not implemented yet
+      # print "Adding a mana potion","at %s"%(`(x,y)`)
+    # if tile.flag(objects.Dagger.flag):  # Not implemented yet
+      # print "Adding a dagger","at %s"%(`(x,y)`)
+    # if tile.flag(objects.Bow.flag):     # Not implemented yet
+      # print "Adding a bow","at %s"%(`(x,y)`)
+    # if tile.flag(objects.Axe.flag):     # Not implemented yet
+      # print "Adding an axe","at %s"%(`(x,y)`)
+    if tile.flag(objects.Shield.flag):
+      Weapon(flag=tile.flag, container=cont, position=(x,y), name="Sheild@%s"%(`(x,y)`), image=tile.image)
+    if tile.flag(objects.Sword.flag):
+      Weapon(flag=tile.flag, container=cont, position=(x,y), name="Sword@%s"%(`(x,y)`), image=tile.image)
+  return cont
+
+
+def setupGame():
+  Game = GameObject(flag=objects.Out.flag, name="Game")
+  DisplayList = []
+  
+  wn = 0
+  for world in worlds:
+    thisWorld = World(flag=objects.Out.flag, container=Game, name="World_%s"%(`wn`))
+    ln = 0
+    for level in world:
+      thisLevel = Level(flag=objects.Out.flag, container=thisWorld, name="Level_%s.%s"%(`wn`,`ln`))
+      x,y = 0,0
+      for line in level:
+        for tile in line:
+          if type(tile) == type(tuple()):
+            cont = thisLevel
+            for item in tile:
+              cont = setupTile(x, y, item, cont, Game)
+          else:
+            setupTile(x, y, tile, thisLevel, Game)
+          x += 1
+        x =  0
+        y += 1
+    wn += 1
+  return Game
 if __name__ == "__main__":
-  print '\n'*100
-  Game = GameObject(name="Game")
-  w1 = World(container=Game, name="World1")
-  w2 = World(container=Game, name="World2")
-  W1 = Weapon(container=w1, name="Weapon1")
-  print "W2"
-  W2 = Weapon(container=w2, name="Weapon2")
-  print '\n'*100
-  Objects = Game.getAllSameClass()
-  for Object in Objects:
-    if len(Object.contents):
-      print `Object.name`, "contains:\n\t", ', '.join([`x.name` for x in Object])
-    else:
-      print `Object.name`, "is empty."
-    if hasattr(Object, 'container'):
-      print `Object.name`, "contained by", `Object.container.name`+'.'
-    else:
-      print `Object.name`, "has no container."
\ No newline at end of file
+  Game = setupGame()
+  d = DisplayObject(Game)
+  d.exec_()