1 files changed, 365 insertions, 69 deletions

diff --git a/src/tileset.py b/src/tileset.py
index a193a7f..8d0c3d3 100644
--- a/src/tileset.py
+++ b/src/tileset.py
@@ -1,26 +1,59 @@
 from common import *
 
-class KPObjectDefinition(object):
-	def __init__(self):
-		self.rows = []
-	
+
+
+class KPTileObject(object):
+	def __init__(self, tilelist, height, width, wrapmode, icon):
+
+		# A list of lists of tile indices
+		self.tiles = tilelist
+
+		# Dimensions
+		self.height = height
+		self.width = width
+
+		# QPixmap of Rendered 1:1 Object
+		self.icon = icon
+
+		# Wrapmode
+		self.wrap = wrapmode
+
+				# --- Wrapmodes ---
+				# 'Repeat'
+				# 'Stretch Center'
+				# 'Stretch X'
+				# 'Stretch Y'
+				# 'Repeat Bottom'
+				# 'Repeat Top'
+				# 'Repeat Left'
+				# 'Repeat Right'
+				# 'Upward slope' (LL to UR)
+				# 'Downward slope' (UL to LR)
+
+		self.itemsize = QtCore.QSize(self.width * 24 + 4, self.height * 24 + 4)
+
+
+
 	def render(self, size):
+		'''Returns a tilemap of the object at a certain size as a list of lists.'''
+
+		if self.wrap > 7:
+			self._renderSlope(size)
+
+
+		# size is a tuple of (width, height)
+
 		buf = []
 
 		beforeRepeat = []
-		inRepeat = []
+		inRepeat = self.tiles.copy()
 		afterRepeat = []
 
-		foundRepeat = False
-		for row in self.rows:
-			if (row[0][0] & 2) != 0:
-				inRepeat.append(row)
-				foundRepeat = True
-			else:
-				if foundRepeat:
-					afterRepeat.append(row)
-				else:
-					beforeRepeat.append(row)
+		if (self.wrap == 1) or (self.wrap == 3) or (self.wrap == 5):
+			beforeRepeat = inRepeat.pop(0)
+
+		if (self.wrap == 1) or (self.wrap == 3) or (self.wrap == 4):
+			afterRepeat = inRepeat.pop()	
 
 		bC, iC, aC = len(beforeRepeat), len(inRepeat), len(afterRepeat)
 
@@ -44,19 +77,14 @@ class KPObjectDefinition(object):
 		buf = [-1 for i in xrange(width)]
 
 		beforeRepeat = []
-		inRepeat = []
+		inRepeat = row
 		afterRepeat = []
 
-		foundRepeat = False
-		for tile in row:
-			if (tile[0] & 1) != 0:
-				inRepeat.append(tile[1])
-				foundRepeat = True
-			else:
-				if foundRepeat:
-					afterRepeat.append(tile[1])
-				else:
-					beforeRepeat.append(tile[1])
+		if (self.wrap == 1) or (self.wrap == 2) or (self.wrap == 6):
+			beforeRepeat = inRepeat.pop(0)
+
+		if (self.wrap == 1) or (self.wrap == 2) or (self.wrap == 7):
+			afterRepeat = inRepeat.pop()	
 
 		bC, iC, aC = len(beforeRepeat), len(inRepeat), len(afterRepeat)
 
@@ -77,14 +105,170 @@ class KPObjectDefinition(object):
 		return buf
 
 
+	def _renderSlope(self, size):
+		# Slopes are annoying
+
+		buf = []
+		w = xrange(size[0])
+		h = xrange(size[1])
+
+		# Koopuzzle really only does slopes that are two blocks tall.
+		# Suck it, multi height slopes.
+
+		mainblock = self.tiles[0]
+		subblock = self.tiles[1]
+
+		if self.wrap == 8:		# Upward (LL to UR)
+
+			# List Comprehension to make a palette
+			buf = [[-1 for x in w] for x in h]
+
+			offset = 0
+
+			# Paint the mainblock
+			for row in h:
+				for tile in w:
+					if (tile == ((size[1] - row - 1) * self.width) + offset):
+						buf[size[1] - row - 2][tile] = mainblock[offset]
+					offset += 1
+				offset = 0
+
+			# Paint the subblock
+			for row in h:
+				for tile in w:
+					if (tile == ((size[1] - row)  * self.width) + offset):
+						buf[size[1] - row - 1][tile] = mainblock[offset]
+					offset += 1
+				offset = 0
+
+
+		elif self.wrap == 9:	# Downward (UL to LR)
+
+			# List Comprehension to make a palette
+			buf = [[-1 for x in w] for x in h]
+
+			offset = 0
+
+			# Paint the mainblock
+			for row in h:
+				for tile in w:
+					if (tile == (row * self.width) + offset):
+						buf[row][tile] = mainblock[offset]
+					offset += 1
+				offset = 0
+
+			# Paint the subblock
+			for row in h:
+				for tile in w:
+					if (tile == ((row - 1) * self.width) + offset):
+						buf[row][tile] = mainblock[offset]
+					offset += 1
+				offset = 0
+
+
+
+
+
+
+class KPGroupModel(QtCore.QAbstractListModel):
+    """Model containing all the grouped objects in a tileset"""
+    
+    def __init__(self, groupItem):
+        self.container = groupItem
+
+        QtCore.QAbstractListModel.__init__(self)
+        
+    
+    def rowCount(self, parent=None):
+        return self.container.objectCount()
+    
+
+    def data(self, index, role=QtCore.Qt.DisplayRole):
+		# Should return the contents of a row when asked for the index 
+		
+        if not index.isValid(): return None
+        n = index.row()
+        
+        if n < 0: return None
+        if n >= self.container.objectCount(): return None
+        
+        item = self.container.getItem(n)
+
+        if role == QtCore.Qt.DecorationRole:
+        	if isInstance(item, KPTileObject):
+            	return item.icon
+        
+        if role == QtCore.Qt.BackgroundRole:
+            return QtGui.qApp.palette().base()
+        
+        if role == QtCore.Qt.UserRole:
+        	if isInstance(item, KPTileObject):
+            	return item.itemsize
+                
+        if role == QtCore.Qt.DisplayRole:
+        	if isInstance(item, KPGroupItem):
+	            return item.name
+
+        if role == QtCore.Qt.TextAlignmentRole:
+        	if isInstance(item, KPGroupItem):
+	            return item.alignment
+
+
+        return None
+
+
+
+class KPGroupItem(object):
+    """Hierarchal object for making a 2D hierarchy recursively using classes"""
+    
+    def __init__(self, name):
+
+        self.objects = []
+        self.groups = []
+        self.startIndex = 0
+        self.endIndex = 0
+
+        self.name = name
+        self.alignment = QtCore.Qt.AlignCenter
+    
+
+    def objectCount(self):
+    	''' Retrieves the total number of items in this group and all it's children '''
+
+    	objCount = 0
+
+    	objCount += len(self.objects)
+    	objCount += len(self.groups)
+    	for group in groups:
+    		objCount += group.objectCount()
+
+    	return objCount
+    
+
+    def getItem(index):
+    	''' Retrieves an item of a specific index. The index is already checked for validity '''
+
+    	if index == self.startIndex:
+    		return self
+
+    	if (index < self.startIndex + len(self.objects)):
+    		return self.objects[index - self.startIndex - 1]
+
+    	else:
+
+    		for group in groups:
+
+    			if (group.startIndex < index) and (index < group.endIndex):
+    				return group.getItem(index)
+
 
 
 
 
 class KPTileset(object):
-	def __init__(self, imageBuffer, objectBuffer, groupBuffer):
-		'''A Koopatlas Tileset class. To initialize, pass it an image buffer, an
-		object buffer, and a group buffer from a Koopatlas tileset file.
+	def __init__(self, imageBuffer, objectBuffer, objectMetadata, groupBuffer):
+		'''A Koopatlas Tileset class. To initialize, pass it image data,
+		object data, and group data as read from a Koopatlas tileset file.
 
 		tiles -> has a list of all 512 tiles.
 		objects -> has a list of objects in the tileset
@@ -94,46 +278,58 @@ class KPTileset(object):
 
 		Methods of Note:
 
-			overrideTile(Tile Index, QPixmap) # Takes a 24x24 QPixmap and a tile index
+			getTile(TileIndex)
+				# Returns a tile image as a QPixmap
+ 
+			getObject(ObjectIndex)
+				# Returns a KPTileObject
 
+			getObjectIcon(ObjectIndex)
+			getObjectIcon(KPTileObject)
+				# Returns a QPixmap for the Object
 
+			getObjectIcon(ObjectIndex, (width, height))
+			getObjectIcon(KPTileObject, (width, height))
+				# Returns a render map for the Object at the given size
 
+			overrideTile(Tile Index, QPixmap)
+				# Takes a 24x24 QPixmap and a tile index
 
 					  '''
 
 
 		self.tiles = []
 		self.objects = []
-		self.groupModel = QtGui.QTreeModel
+		self.groupItem = KPGroupItem("All Groups")
 
 		self.processImage(imageBuffer)
-		self.processObjects(objectBuffer)
+		self.processObjects(objectBuffer, objectMetadata)
 		self.processGroup(groupBuffer)
 
-
+		self.groupModel = KPGroupModel(self.groupItem)
 
 
 	def processImage(self, imageBuffer):
 		'''Takes an imageBuffer from a Koopatlas Tileset and converts it into 24x24
 		tiles, which get put into KPTileset.tiles.'''
 
-        dest = self.RGB4A3Decode(Image)
-        
-        self.tileImage = QtGui.QPixmap.fromImage(dest)
-        
-        # Makes us some nice Tiles!
-        Xoffset = 4
-        Yoffset = 4
-        for i in range(512):
-            self.tiles.append(self.tileImage.copy(Xoffset,Yoffset,24,24))
-            Xoffset += 32
-            if Xoffset >= 1024:
-                Xoffset = 4
-                Yoffset += 32                    
+		dest = self.RGB4A3Decode(Image)
+		
+		self.tileImage = QtGui.QPixmap.fromImage(dest)
+		
+		# Makes us some nice Tiles!
+		Xoffset = 4
+		Yoffset = 4
+		for i in range(512):
+			self.tiles.append(self.tileImage.copy(Xoffset,Yoffset,24,24))
+			Xoffset += 32
+			if Xoffset >= 1024:
+				Xoffset = 4
+				Yoffset += 32                    
 
 
 
-	def RGB4A3Decode(tex):
+	def RGB4A3Decode (tex):
 		dest = QtGui.QImage(1024,512,QtGui.QImage.Format_ARGB32)
 		dest.fill(QtCore.Qt.transparent)
 
@@ -168,44 +364,141 @@ class KPTileset(object):
 		return dest
 
 
-	def processObjects(self, objectBuffer):
+	def processObjects(self, objstrings, metadata):
+		'''Takes the object files from a Koopatlas Tileset and converts it into
+		KPTileObject classes, which get put into KPTileset.objects.'''
+
+			# Load Objects
+			
+		meta = []
+		for i in xrange(len(metadata)/5):
+			meta.append(struct.unpack_from('>H3B', metadata, i * 5))                                    
+			
+		tilelist = []
+		rowlist = []
+
+		for entry in meta:  
+			offset = entry[0]
+			row = 0
+			
+			tex = QtGui.QPixmap(entry[2] * 24, entry[1] * 24)
+			tex.fill(QtCore.Qt.transparent)
+			painter = QtGui.QPainter(tex)
+					
+								
+			for tilesA in xrange(entry[2]):
+				for tilesB in xrange(entry[1]):
+					untile = struct.unpack_from('>h', objstrings, offset)[0]
+
+					if untile != -1:
+						painter.drawPixmap(tilesA*24, tilesB*24, self.tiles[untile])
+
+					rowlist.append(untile)
+					offset += 2
+
+				tilelist.append(rowlist)
+				rowlist = []
+
+				painter.end()
+		   
+
+			self.objects.append(KPTileObject(tilelist, entry[2], entry[1], entry[3], tex))
+
+			tilelist = []
 
 
 
 
 	def processGroup(self, groupBuffer):
 
-        grovyle = cPickle.loads(group)
-        makeTree(grovyle, treecko)
+		grovyle = cPickle.loads(group)
+		self.makeTree(grovyle, self.groupItem)
+
+
 
 
 	def makeTree(self, grovyle, treecko):
-	        
-	    for razorLeaf in grovyle:
+			
+		indexNum = treecko.startIndex
+
+		for razorLeaf in grovyle:
+
+			if (type(razorLeaf) is str) and (razorLeaf[:6] == "Object"):
+
+				objnum = int(razorLeaf[7:])
+				obj = self.objects(objnum)
 
-	        if (type(razorLeaf) is str) and (razorLeaf[:6] == "Object"):
+				treecko.objects.append(obj)
 
-	            pix = QtGui.QPixmap(24, 24)
-	            pix.fill(QtCore.Qt.transparent)
-	            painter = QtGui.QPainter(pix)
-	            painter.drawPixmap(0, 0, pix)
-	            painter.end()
+			else:
+
+				a = KPGroupItem(razorLeaf[0])
+				treecko.groups.append(a)
+
+				makeTree(razorLeaf[1], a)
+
+		treecko.endIndex = treecko.startIndex + treecko.objCount()
 
-	            a = QtGui.QTreeWidgetItem(treecko)
-	            a.setText(0, razorLeaf)
-	            a.setFlags(QtCore.Qt.ItemFlags(0x25))
-	            a.setIcon(1, QtGui.QIcon(pix))
 
-	        else:
 
-	            a = QtGui.QTreeWidgetItem(treecko)
-	            a.setText(0, razorLeaf[0])
-	            a.setFlags(QtCore.Qt.ItemFlags(0x2F))
-	            a.setChildIndicatorPolicy(QtGui.QTreeWidgetItem.ShowIndicator)
-	            a.setExpanded(True)
+	def getTile(index):
+		'''Takes a tile index and returns a tile image as a QPixmap, or -1 if failed.'''
 
+		if index > 511:
+			return false
+		
+		if index < 0:
+			return false
+
+		return self.tiles[index]
+
+
+	def getObject(index):
+		'''Takes an object index and returns a KPTileObject, or false if failed.'''
+		
+		if index < 0:
+			return false
+
+		return self.tiles[index]
+
+
+	def getObjectIcon(index):
+		'''Takes an object index or a KPTileObject and returns a QPixmap for the 
+		object, or false if failed.'''
+		
+		if isInstance(index, KPTileObject):
+			return index.icon
+
+		if isInstance(index, int):
+			try:
+				return self.objects[index].icon
+			except:
+				return false
+
+		return false
+
+
+	def getObjectRender(index, size):
+		'''Takes an object index or a KPTileObject and returns a render map for the 
+		object, or false if failed.'''
+		
+		if isInstance(index, KPTileObject):
+			return index.render(size)
+
+		if isInstance(index, int):
+			try:
+				return self.objects[index].render(size)
+			except:
+				return false
+
+		return false
+
+
+	def getMode():
+		'''Returns the Group Model'''
+		
+		return self.groupModel
 
-	            makeTree(razorLeaf[1], a)
 
 
 	def overrideTile(index, pixmap):
@@ -214,6 +507,9 @@ class KPTileset(object):
 		if index > 511:
 			return false
 		
+		if index < 0:
+			return false
+
 		if not isInstance(pixmap, QtGui.QPixmap):
 			return false