from common import * import array import sys import math from ctypes import create_string_buffer # Useful Stuff u32 = struct.Struct('>I') u16 = struct.Struct('>H') zero32 = u32.pack(0) def RGB5A3Encode(tex): tex = tex.toImage() w, h = tex.width(), tex.height() padW = (w + 3) & ~3 padH = (h + 3) & ~3 destBuffer = create_string_buffer(padW * padH * 2) shortstruct = struct.Struct('>H') sspack = shortstruct.pack_into offset = 0 for ytile in xrange(0, padH, 4): for xtile in xrange(0, padW, 4): for ypixel in xrange(ytile, ytile + 4): for xpixel in xrange(xtile, xtile + 4): if xpixel >= w or ypixel >= h: rgbDAT = 0x7FFF else: pixel = tex.pixel(xpixel, ypixel) a = pixel >> 24 r = (pixel >> 16) & 0xFF g = (pixel >> 8) & 0xFF b = pixel & 0xFF if a < 245: #RGB4A3 alpha = a/32 red = r/16 green = g/16 blue = b/16 rgbDAT = (blue) | (green << 4) | (red << 8) | (alpha << 12) else: # RGB555 red = r/8 green = g/8 blue = b/8 rgbDAT = (blue) | (green << 5) | (red << 10) | (0x8000) # 0rrrrrgggggbbbbb sspack(destBuffer, offset, rgbDAT) offset += 2 return destBuffer.raw class KPMapExporter: class LayerExporter: def __init__(self, layer): self.layer = layer class TileLayerExporter(LayerExporter): def buildSectors(self, sectors, indices): # we'll use the cache held by the layer: why reinvent the wheel? layer = self.layer layer.updateCache() cache = layer.cache # first off, get all the info and figure out the sector bounds layerX, layerY = layer.cacheBasePos layerWidth, layerHeight = layer.cacheSize sectorLeft = layerX / 16 sectorTop = layerY / 16 sectorRight = (layerX + layerWidth - 1) / 16 sectorBottom = (layerY + layerHeight - 1) / 16 rawSectors = [] for i in xrange(sectorBottom - sectorTop + 1): rawSectors.append([None for j in xrange(sectorRight - sectorLeft + 1)]) tileset = KP.tileset(layer.tileset) optMappings = tileset.optMappings # copy every tile index over for srcY in xrange(layerHeight): srcRow = cache[srcY] worldY = srcY + layerY sectorY = worldY / 16 destY = worldY % 16 destRow = rawSectors[sectorY - sectorTop] for srcX in xrange(layerWidth): worldX = srcX + layerX sectorX = worldX / 16 destX = worldX % 16 tile = srcRow[srcX] if tile == -1: continue tile = optMappings[tile] if tile == -1: continue destSector = destRow[sectorX - sectorLeft] if destSector is None: destSector = [[-1 for j in xrange(16)] for i in xrange(16)] destRow[sectorX - sectorLeft] = destSector destSector[destY][destX] = tile # now add the created sectors to the data count = reduce(lambda x,y: x+len(y), rawSectors, 0) sectorMap = [0xFFFF for i in xrange(count)] destIdx = 0 for srcRow in rawSectors: for sector in srcRow: if sector is not None: # see if it's a duplicate or not sectorKey = '|'.join(map(lambda x: ','.join(map(str, x)), sector)) try: sectorMap[destIdx] = indices[sectorKey] except KeyError: indices[sectorKey] = len(sectors) sectorMap[destIdx] = len(sectors) sectors.append(sector) destIdx += 1 self.sectorBounds = (sectorLeft, sectorTop, sectorRight, sectorBottom) self.realBounds = (layerX, layerY, layerX+layerWidth-1, layerY+layerHeight-1) self.sectorMap = sectorMap class DoodadLayerExporter(LayerExporter): pass class PathLayerExporter(LayerExporter): pass def __init__(self, mapObj): self.map = mapObj self.tileAssociates = {} self.doodadAssociates = {} output = [] for layer in self.map.layers: if isinstance(layer, KPTileLayer) and len(layer.objects) > 0: output.append(KPMapExporter.TileLayerExporter(layer)) elif isinstance(layer, KPDoodadLayer) and len(layer.objects) > 0: output.append(KPMapExporter.DoodadLayerExporter(layer)) elif isinstance(layer, KPPathLayer): output.append(KPMapExporter.PathLayerExporter(layer)) for iLayer in self.map.associateLayers: if len(iLayer.objects) > 0: tl = KPMapExporter.TileLayerExporter(iLayer) self.tileAssociates[iLayer.associate] = tl output.append(tl) if len(iLayer.doodads) > 0: dl = KPMapExporter.DoodadLayerExporter(iLayer) self.doodadAssociates[iLayer.associate] = dl output.append(dl) self.layers = output def build(self): requiredFixUps = [] stringsToAdd = set() textures = set() texInfo = set() tilesets = set() offsets = {None: 0xFFFFFFFF} # first off, build the sectors sectors = [] sectorIndices = {} for layer in self.layers: if isinstance(layer, self.TileLayerExporter): layer.buildSectors(sectors, sectorIndices) sectorData = self._packSectorData(sectors) # now that we've got that, we can pack the first part of the file data = bytearray(struct.pack('>IIIII', len(self.layers), 20 + len(sectorData), 0, 0, 0)) requiredFixUps.append((16, 'UnlockBytecode')) # list of layer pointers goes here.. or will, later data += sectorData for layer in self.layers: requiredFixUps.append((len(data), layer)) data += zero32 # now build the layers for eLayer in self.layers: layer = eLayer.layer offsets[eLayer] = len(data) offsets[layer] = len(data) if isinstance(eLayer, self.TileLayerExporter): data += u32.pack(0) data += u32.pack(0xFF000000) # tileset name tileset = '/Maps/Texture/%s.bin' % layer.tileset tilesets.add(tileset) stringsToAdd.add(tileset) requiredFixUps.append((len(data), ('tileset', tileset))) data += zero32 # sector info data += struct.pack('>IIII', *eLayer.sectorBounds) data += struct.pack('>IIII', *eLayer.realBounds) data += ''.join(map(u16.pack, eLayer.sectorMap)) pad = (4 - (len(data) & 3)) % 4 data += ('\0' * pad) elif isinstance(eLayer, self.DoodadLayerExporter): data += u32.pack(1) data += u32.pack(0xFF000000) # doodad list try: doodadList = layer.doodads except AttributeError: doodadList = layer.objects data += u32.pack(len(doodadList)) for doodad in doodadList: requiredFixUps.append((len(data), doodad)) data += zero32 # now pack them ... for doodad in doodadList: offsets[doodad] = len(data) x, y = doodad.position w, h = doodad.size data += struct.pack('>fffffii', x, y, w, h, doodad.angle, 0, len(doodad.animations)) texInfo.add((doodad.source[0], doodad.source[1].height() * doodad.source[1].width() * 2)) texture = doodad.source[1] textures.add(texture) requiredFixUps.append((len(data) - 8, texture)) for anim in doodad.animations: rLoop, rCurve, rFrames, rType, rStart, rEnd, rDelay, rDelayOffset = anim loopid = self.ANIM_LOOPS.index(rLoop) curveid = self.ANIM_CURVES.index(rCurve) typeid = self.ANIM_TYPES.index(rType) data += struct.pack('>iiiiiiiiii', loopid, curveid, rFrames, typeid, rStart, rEnd, rDelay, rDelayOffset, 0, 0) elif isinstance(eLayer, self.PathLayerExporter): data += u32.pack(2) data += zero32 # before we do anything, build the list of secret levels # we'll need that levelsWithSecrets = set() for path in layer.paths: if hasattr(path, 'unlockSpec') and path.unlockSpec is not None: self._checkSpecForSecrets(path.unlockSpec, levelsWithSecrets) # lists current = len(data) nodeArray = current + 16 pathArray = nodeArray + (len(layer.nodes) * 4) data += struct.pack('>IIII', len(layer.nodes), nodeArray, len(layer.paths), pathArray) for node in layer.nodes: requiredFixUps.append((len(data), node)) data += zero32 for path in layer.paths: requiredFixUps.append((len(data), path)) data += zero32 # now do the actual structs for node in layer.nodes: offsets[node] = len(data) x, y = node.position current = len(data) data += struct.pack('>hhiiiiii', x+12, y+12, 0, 0, 0, 0, 0, 0) # figure out the exits by direction exits = [None, None, None, None] left, right, up, down = 0, 1, 2, 3 for exit in node.exits: start, end = exit._startNodeRef(), exit._endNodeRef() opposite = end if (start == node) else start oX, oY = opposite.position deltaX, deltaY = oX-x, oY-y angle = math.degrees(math.atan2(deltaX, deltaY)) % 360 print "Here: %d,%d Opposite %d,%d Delta: %d,%d Angle: %d" % (x,y,oX,oY,deltaX,deltaY,angle) # Left = 270, Right = 90, Up = 180, Down = 0 if angle >= 225 and angle <= 315: direction = left elif angle >= 45 and angle <= 135: direction = right elif angle > 135 and angle < 225: direction = up elif angle > 315 or angle < 45: direction = down if exits[direction]: print "Conflicting directions!" while exits[direction]: direction = (direction + 1) % 4 exits[direction] = exit requiredFixUps.append((current+4, exits[0])) requiredFixUps.append((current+8, exits[1])) requiredFixUps.append((current+12, exits[2])) requiredFixUps.append((current+16, exits[3])) if node in self.tileAssociates: requiredFixUps.append((current+20, self.tileAssociates[node])) if node in self.doodadAssociates: requiredFixUps.append((current+24, self.doodadAssociates[node])) if node.isStop(): if node.level: level1, level2 = node.level hasSecret = (1 if ((level1,level2) in levelsWithSecrets) else 0) # i i i b b b b: node type, isNew, Extra pointer, world, level, hasSecret, padding data += struct.pack('>iiibbbb', 2, 0, 0, level1, level2, hasSecret, 0) elif node.mapChange: data += u32.pack(3) # node type destMap = node.mapChange requiredFixUps.append((len(data)+8, destMap)) stringsToAdd.add(destMap) # i i i b b b b: isNew, Extra pointer, dest map, map ID, foreign ID, transition, padding data += struct.pack('>iiibbbb', 0, 0, 0, node.mapID, node.foreignID, node.transition, 0) else: data += u32.pack(1) # node type data += zero32 # isNew data += zero32 # Extra pointer else: data += zero32 # node type data += zero32 # isNew data += zero32 # Extra pointer pathIndices = {} for i, path in enumerate(layer.paths): pathIndices[path] = i offsets[path] = len(data) start = path._startNodeRef() end = path._endNodeRef() current = len(data) requiredFixUps.append((current, start)) requiredFixUps.append((current+4, end)) if path in self.tileAssociates: requiredFixUps.append((current+8, self.tileAssociates[path])) if path in self.doodadAssociates: requiredFixUps.append((current+12, self.doodadAssociates[path])) data += (zero32 * 4) available = 0 if (not hasattr(path, 'unlockSpec')) or path.unlockSpec is None: available = 3 data += struct.pack('>bbbbfi', available, 0, 0, 0, path.movementSpeed, path.animation) # now that we're almost done... pack the strings for string in stringsToAdd: offsets[string] = len(data) data += str(string) data += '\0' # textures texA = sorted(texInfo, key=lambda x: x[1]) s = 0 d = 0 for texItem in texA: print texItem[1]/1000, "kb:", texItem[0] s += texItem[1] d += 1 if d == 10: d = 0 print "So far:", s/1000, "kb" print "Total:", s/1000, "kb" texPadding = ((len(data) + 0x1F) & ~0x1F) - len(data) data += ('\0' * texPadding) texHeaderStartOffset = len(data) texDataStartOffset = texHeaderStartOffset + ((len(textures) + len(tilesets)) * 0x20) currentTexOffset = texDataStartOffset imageData = [] struct.pack_into('>ii', data, 8, len(tilesets), len(data)) for setname in tilesets: offsets[('tileset', setname)] = len(data) data += self._buildGXTexObjRGB5A3(896, 448, offsets[setname]) for tex in textures: offsets[tex] = len(data) data += self._buildGXTexObjRGB5A3(tex.width(), tex.height(), currentTexOffset) converted = RGB5A3Encode(tex) imageData.append(converted) currentTexOffset += len(converted) for piece in imageData: data += piece # at the end comes the unlock bytecode offsets['UnlockBytecode'] = len(data) # first off, build a map of unlocks unlockLists = {} from unlock import stringifyUnlockData for path in self.map.pathLayer.paths: if not hasattr(path, 'unlockSpec'): continue spec = path.unlockSpec if spec is None: continue # we stringify it first because the specs become lists when # imported from the kpmap (not tuples) and those can't be # used as dict keys spec = stringifyUnlockData(spec) try: lst = unlockLists[spec] except KeyError: lst = [] unlockLists[spec] = lst lst.append(path) # now produce the thing from unlock import parseUnlockText, packUnlockSpec for spec, lst in unlockLists.iteritems(): data += packUnlockSpec(parseUnlockText(spec)) data += chr(len(lst)) for p in lst: data += u16.pack(pathIndices[p]) data += chr(0) # to finish up, correct every offset for offset, target in requiredFixUps: u32.pack_into(data, offset, offsets[target]) return data ANIM_LOOPS = ['Contiguous', 'Loop', 'Reversible Loop'] ANIM_CURVES = ['Linear', 'Sinusoidial', 'Cosinoidial'] ANIM_TYPES = ['X Position', 'Y Position', 'Angle', 'X Scale', 'Y Scale', 'Opacity'] def _checkSpecForSecrets(self, spec, levelSet): kind = spec[0] if kind == 'level': k, one, two, secret = spec if secret: levelSet.add((one, two)) elif kind == 'and' or kind == 'or': for term in spec[1]: self._checkSpecForSecrets(term, levelSet) def _buildGXTexObjRGB5A3(self, width, height, imgOffset): # Format: RGB5A3 (5) # Wrap: CLAMP (0) return struct.pack('>IIIIIIIHH', 0x90, 0, (0x500000 | ((height - 1) << 10) | (width - 1)), 0x10000000 + imgOffset, # (imgptr >> 5) 0, 0, 0, (((width + 3) / 4) * ((height + 3) / 4)) & 0x7FFF, 0x0202 ) def _packSectorData(self, sectors): rowStruct = struct.Struct('>16h') output = [] for sector in sectors: for row in sector: output.append(rowStruct.pack(*row)) return ''.join(output)