def addToon(self, toon, tX, tY):
marker = NodePath('toon_marker-%i' % toon.doId)
marker.reparentTo(self)
self._getToonMarker(toon).copyTo(marker)
marker.setColor(toon.style.getHeadColor())
if toon.isLocal():
marker.setScale(0.07)
else:
marker.setScale(0.05)
marker.flattenStrong()
marker.setPos(*self.gui2pos(*self.tile2gui(tX, tY)))
self._toon2marker[toon] = marker
def addToon(self, toon, tX, tY):
marker = NodePath('toon_marker-%i' % toon.doId)
marker.reparentTo(self)
self._getToonMarker(toon).copyTo(marker)
marker.setColor(toon.style.getHeadColor())
if toon.isLocal():
marker.setScale(0.07)
else:
marker.setScale(0.05)
marker.flattenStrong()
marker.setPos(*self.gui2pos(*self.tile2gui(tX, tY)))
self._toon2marker[toon] = marker
def addToon(self, toon):
marker = NodePath('toon_marker-%i' % toon.doId)
marker.reparentTo(self)
self._getToonMarker(toon).copyTo(marker)
marker.setColor(toon.style.getHeadColor())
if toon.isLocal():
marker.setScale(Globals.Gui.LocalMarkerScale)
marker.setBin('fixed', 10)
else:
marker.setScale(Globals.Gui.MarkerScale)
marker.setBin('fixed', 5)
marker.flattenStrong()
self._toonMarkers[toon] = marker
def addToon(self, toon):
marker = NodePath('toon_marker-%i' % toon.doId)
marker.reparentTo(self)
self._getToonMarker(toon).copyTo(marker)
marker.setColor(toon.style.getHeadColor())
if toon.isLocal():
marker.setScale(Globals.Gui.LocalMarkerScale)
marker.setBin('fixed', 10)
else:
marker.setScale(Globals.Gui.MarkerScale)
marker.setBin('fixed', 5)
marker.flattenStrong()
self._toonMarkers[toon] = marker
def __init__(self, cameraPos, heightfield, plantModelDict, numberOfTiles, sizeOfTile, usingLod):
# storage for the nodepaths used by the plants
self.tileDict = dict()
self.plantClassNp = render.attachNewNode("plants-%i-%i" % (numberOfTiles, sizeOfTile))
self.usingLod = usingLod
# save camera position to create plants around it
self.cameraPos = cameraPos
# save a instance of the heightfield to access heightinformations of the ground
self.heightfield = heightfield
# dictionary with the models
self.plantModelDict = plantModelDict
# number of tiles around the camera
self.numberOfTiles = numberOfTiles
# size of one of these tiles
self.sizeOfTile = sizeOfTile
# sum up all distribution numbers of the plantmodelDict
self.plantmodelDistributionSum = reduce(
add, [self.plantModelDict[key][0] for key in self.plantModelDict.keys()]
)
# a dictionary to store the models which need to be faded in
self.fadingNodepaths = dict()
# convert the egg's to bam's
for name, [c, modelName, minS, maxS, distF] in self.plantModelDict.items():
try:
tempModelRoot = loader.loadModel(modelName + ".egg")
tempModelRoot.flattenStrong()
modelRoot = NodePath("modelRoot-%s" % name)
tempModelRoot.getChildren().reparentTo(modelRoot)
modelRoot.flattenStrong()
modelRoot.writeBamFile(modelName + ".bam")
modelRoot.removeNode()
# for models with different lod's
except:
for [maxLodDist, minLodDistance, modelName] in modelName:
tempModelRoot = loader.loadModel(modelName + ".egg")
tempModelRoot.flattenStrong()
modelRoot = NodePath("modelRoot-%s" % name)
tempModelRoot.getChildren().reparentTo(modelRoot)
modelRoot.flattenStrong()
modelRoot.writeBamFile(modelName + ".bam")
modelRoot.removeNode()
# task to create the plants
taskMgr.add(self.updatePlants, "updatePlants")
def setSky(directory, ext=".jpg"):
"""Sets up a skybox. 'directory' is the directory whitch contains 6
pictures with the names right.ext, left.ext and so on (see template).
ext is the extension the pictures have (with dot).
"""
#TODO: accept all supported image file extensions without the need for an
# extra argument
# remove the old sky first when loading a new one
# TODO: get this working...
#oldsky = render.find("*sky*")
#print oldsky
#for child in render.getChildren():
# child.remove()
sky = NodePath().attachNewNode("sky")
sides = {
"right": ( 1, 0, 0, -90, 0, 0),
"left": (-1, 0, 0, 90, 0, 0),
"top": ( 0, 0, 1, 0, 90, 0),
"bottom": ( 0, 0, -1, 180, -90, 0),
"front": ( 0, 1, 0, 0, 0, 0),
"back": ( 0, -1, 0, 180, 0, 0)
}
for name, poshpr in sides.iteritems():
c = CardMaker(name)
c.setFrame(-1, 1, -1, 1)
card = c.generate()
cardnode = sky.attachNewNode(card)
cardnode.setPosHpr(*poshpr)
tex = loader.loadTexture("skyboxes/" + directory + "/" + name + ext)
tex.setWrapV(tex.WMClamp)
tex.setMagfilter(tex.FTNearestMipmapNearest)
tex.setMinfilter(tex.FTNearestMipmapNearest)
cardnode.setTexture(tex)
sky.flattenStrong()
sky.setScale(10, 10, 10)
sky.setCompass()
sky.setBin('background', 0)
sky.setDepthTest(False)
sky.setDepthWrite(False)
sky.setLightOff()
sky.reparentTo(camera)
geom = sky.getChild(0).node()
geom.setName("cube")
def redraw(self):
if not self.dirty:
return # nothing has changed, no need to redraw
container = NodePath(PandaNode(self.name + "container"))
for i in range(TILE_GRP_SIZE):
for j in range(TILE_GRP_SIZE):
cur = self.textures[i][j]
if cur:
node = container.attachNewNode(CARD_MAKER.generate())
node.setTexture(cur)
node.setTwoSided(True)
node.setPos(i * TILE_SIZE, 0, j * TILE_SIZE)
container.flattenStrong()
for child in self.nodepath.getChildren():
child.removeNode()
container.reparentTo(self.nodepath)
self.dirty = False
class CogdoMazeFactory:
def __init__(self, randomNumGen, width, height, frameWallThickness = Globals.FrameWallThickness, cogdoMazeData = CogdoMazeData):
self._rng = RandomNumGen(randomNumGen)
self.width = width
self.height = height
self.frameWallThickness = frameWallThickness
self._cogdoMazeData = cogdoMazeData
self.quadrantSize = self._cogdoMazeData.QuadrantSize
self.cellWidth = self._cogdoMazeData.QuadrantCellWidth
def getMazeData(self):
if not hasattr(self, '_data'):
self._generateMazeData()
return self._data
def createCogdoMaze(self, flattenModel = True):
if not hasattr(self, '_maze'):
self._loadAndBuildMazeModel(flatten=flattenModel)
return CogdoMaze(self._model, self._data, self.cellWidth)
def _gatherQuadrantData(self):
self.openBarriers = []
barrierItems = range(Globals.TotalBarriers)
self._rng.shuffle(barrierItems)
for i in barrierItems[0:len(barrierItems) - Globals.NumBarriers]:
self.openBarriers.append(i)
self.quadrantData = []
quadrantKeys = self._cogdoMazeData.QuadrantCollisions.keys()
self._rng.shuffle(quadrantKeys)
i = 0
for y in range(self.height):
for x in range(self.width):
key = quadrantKeys[i]
collTable = self._cogdoMazeData.QuadrantCollisions[key]
angle = self._cogdoMazeData.QuadrantAngles[self._rng.randint(0, len(self._cogdoMazeData.QuadrantAngles) - 1)]
self.quadrantData.append((key, collTable[angle], angle))
i += 1
if x * y >= self._cogdoMazeData.NumQuadrants:
i = 0
def _generateBarrierData(self):
data = []
for y in range(self.height):
data.append([])
for x in range(self.width):
if x == self.width - 1:
ax = -1
else:
ax = 1
if y == self.height - 1:
ay = -1
else:
ay = 1
data[y].append([ax, ay])
dirUp = 0
dirDown = 1
dirLeft = 2
dirRight = 3
def getAvailableDirections(ax, ay, ignore = None):
dirs = []
if ax - 1 >= 0 and data[ay][ax - 1][BARRIER_DATA_RIGHT] == 1 and (ax, ay) != ignore:
dirs.append(dirLeft)
if ax + 1 < self.width and data[ay][ax][BARRIER_DATA_RIGHT] == 1 and (ax, ay) != ignore:
dirs.append(dirRight)
if ay - 1 >= 0 and data[ay - 1][ax][BARRIER_DATA_TOP] == 1 and (ax, ay) != ignore:
dirs.append(dirDown)
if ay + 1 < self.height and data[ay][ax][BARRIER_DATA_TOP] == 1 and (ax, ay) != ignore:
dirs.append(dirUp)
return dirs
visited = []
def tryVisitNeighbor(ax, ay, ad):
if ad == dirUp:
if data[ay][ax] in visited:
return None
visited.append(data[ay][ax])
data[ay][ax][BARRIER_DATA_TOP] = 0
ay += 1
elif ad == dirDown:
if data[ay - 1][ax] in visited:
return None
visited.append(data[ay - 1][ax])
data[ay - 1][ax][BARRIER_DATA_TOP] = 0
ay -= 1
elif ad == dirLeft:
if data[ay][ax - 1] in visited:
return None
visited.append(data[ay][ax - 1])
data[ay][ax - 1][BARRIER_DATA_RIGHT] = 0
ax -= 1
elif ad == dirRight:
if data[ay][ax] in visited:
return None
visited.append(data[ay][ax])
data[ay][ax][BARRIER_DATA_RIGHT] = 0
ax += 1
return ax, ay
def openBarriers(x, y):
dirs = getAvailableDirections(x, y)
for dir in dirs:
next = tryVisitNeighbor(x, y, dir)
if next is not None:
openBarriers(*next)
x = self._rng.randint(0, self.width - 1)
y = self._rng.randint(0, self.height - 1)
openBarriers(x, y)
self._barrierData = data
def _generateMazeData(self):
if not hasattr(self, 'quadrantData'):
self._gatherQuadrantData()
self._data = {'width': (self.width + 1) * self.frameWallThickness + self.width * self.quadrantSize,
'height': (self.height + 1) * self.frameWallThickness + self.height * self.quadrantSize}
self._data['originX'] = int(self._data['width'] / 2)
self._data['originY'] = int(self._data['height'] / 2)
collisionTable = []
horizontalWall = [ 1 for x in range(self._data['width']) ]
collisionTable.append(horizontalWall)
for i in range(0, len(self.quadrantData), self.width):
for y in range(self.quadrantSize):
row = [1]
for x in range(i, i + self.width):
if x == 1 and y < self.quadrantSize / 2 - 2:
newData = []
for j in self.quadrantData[x][1][y]:
if j == 0:
newData.append(2)
else:
newData.append(j + 0)
row += newData + [1]
else:
row += self.quadrantData[x][1][y] + [1]
collisionTable.append(row)
collisionTable.append(horizontalWall[:])
barriers = Globals.MazeBarriers
for i in range(len(barriers)):
for coords in barriers[i]:
collisionTable[coords[1]][coords[0]] = 0
y = self._data['originY']
for x in range(len(collisionTable[y])):
if collisionTable[y][x] == 0:
collisionTable[y][x] = 2
x = self._data['originX']
for y in range(len(collisionTable)):
if collisionTable[y][x] == 0:
collisionTable[y][x] = 2
self._data['collisionTable'] = collisionTable
def _loadAndBuildMazeModel(self, flatten = False):
self.getMazeData()
self._model = NodePath('CogdoMazeModel')
levelModel = CogdoUtil.loadMazeModel('level')
self.quadrants = []
quadrantUnitSize = int(self.quadrantSize * self.cellWidth)
frameActualSize = self.frameWallThickness * self.cellWidth
size = quadrantUnitSize + frameActualSize
halfWidth = int(self.width / 2)
halfHeight = int(self.height / 2)
i = 0
for y in range(self.height):
for x in range(self.width):
ax = (x - halfWidth) * size
ay = (y - halfHeight) * size
extension = ''
if hasattr(getBase(), 'air'):
extension = '.bam'
filepath = self.quadrantData[i][0] + extension
angle = self.quadrantData[i][2]
m = self._createQuadrant(filepath, i, angle, quadrantUnitSize)
m.setPos(ax, ay, 0)
m.reparentTo(self._model)
self.quadrants.append(m)
i += 1
quadrantHalfUnitSize = quadrantUnitSize * 0.5
barrierModel = CogdoUtil.loadMazeModel('grouping_blockerDivider').find('**/divider')
y = 3
for x in range(self.width):
if x == (self.width - 1) / 2:
continue
ax = (x - halfWidth) * size
ay = (y - halfHeight) * size - quadrantHalfUnitSize - (self.cellWidth - 0.5)
b = NodePath('barrier')
barrierModel.instanceTo(b)
b.setPos(ax, ay, 0)
b.reparentTo(self._model)
offset = self.cellWidth - 0.5
for x in (0, 3):
for y in range(self.height):
ax = (x - halfWidth) * size - quadrantHalfUnitSize - frameActualSize + offset
ay = (y - halfHeight) * size
b = NodePath('barrier')
barrierModel.instanceTo(b)
b.setPos(ax, ay, 0)
b.setH(90)
b.reparentTo(self._model)
offset -= 2.0
barrierModel.removeNode()
levelModel.getChildren().reparentTo(self._model)
for np in self._model.findAllMatches('**/*lightCone*'):
CogdoUtil.initializeLightCone(np, 'fixed', 3)
if flatten:
self._model.flattenStrong()
return self._model
def _createQuadrant(self, filepath, serialNum, angle, size):
root = NodePath('QuadrantRoot-%i' % serialNum)
quadrant = loader.loadModel(filepath)
quadrant.getChildren().reparentTo(root)
root.setH(angle)
return root
def generateHullCache(modelClass):
geom = loader.loadModel('models/shipparts/pir_m_shp_%s' %
HullDict[modelClass])
stripPrefix(geom, 'model:')
for node in geom.findAllMatches('**/omit'):
parent = node.getParent()
omit = parent.attachNewNode(ModelNode('omit'))
node.reparentTo(omit)
node.setName('geom')
preFlatten(geom)
logic = loader.loadModel('models/shipparts/pir_m_shp_%s_logic' %
HullDict[modelClass])
locators = logic.find('**/locators')
for side in ['left', 'right']:
bad = locators.find('**/location_ropeLadder_0_%s' % side)
if bad:
bad.setName('location_ropeLadder_%s_0' % side)
bad = locators.find('**/location_ropeLadder_1_%s' % side)
if bad:
bad.setName('location_ropeLadder_%s_1' % side)
bad = locators.find('**/location_ropeLadder_1_%s1' % side)
if bad:
bad.setName('location_ropeLadder_%s_2' % side)
collisions = logic.find('**/collisions')
badPanel = collisions.find('**/collision_panel_3')
if badPanel:
badPanel.setName('collision_panel_2')
collisions.find('**/collision_panel_0').setTag('Hull Code', '0')
collisions.find('**/collision_panel_1').setTag('Hull Code', '1')
collisions.find('**/collision_panel_2').setTag('Hull Code', '2')
walls = collisions.find('**/collision_walls')
if walls:
walls.setTag('Hull Code', '255')
else:
collisions.attachNewNode('collision_walls')
shipToShipCollide = collisions.find('**/collision_shiptoship')
shipToShipCollide.setCollideMask(PiratesGlobals.ShipCollideBitmask)
deck = collisions.find('**/collision_deck')
if not deck:
deck = collisions.attachNewNode('deck')
mask = deck.getCollideMask()
mask ^= PiratesGlobals.FloorBitmask
mask |= PiratesGlobals.ShipFloorBitmask
deck.setCollideMask(mask)
floors = collisions.find('**/collision_floors')
if not floors:
floors = collisions.find('**/collision_floor')
mask = floors.getCollideMask()
mask ^= PiratesGlobals.FloorBitmask
mask |= PiratesGlobals.ShipFloorBitmask
floors.setCollideMask(mask)
floors.setTag('Hull Code', str(255))
geomHigh = geom.find('**/lod_high')
geomMed = geom.find('**/lod_medium')
if not geomMed:
geomMed = geom.find('**/low_medium')
if not geomMed:
geomMed = geomHigh.copyTo(NodePath())
geomLow = geom.find('**/lod_low')
if not geomLow:
geomLow = geomMed.copyTo(NodePath())
geomSuperLow = geom.find('**/lod_superlow')
if not geomSuperLow:
geomSuperLow = geomLow.copyTo(NodePath())
geomHigh.setName('high')
geomMed.setName('med')
geomLow.setName('low')
geomSuperLow.setName('superlow')
if modelClass in [21, 22, 23]:
spike = loader.loadModel('models/shipparts/pir_m_shp_ram_spike')
spikeTrans = locators.find('**/location_ram').getTransform(locators)
spike.setTransform(spikeTrans)
spike.flattenLight()
spikeHi = spike.find('**/lod_high')
spikeMed = spike.find('**/lod_medium')
spikeLow = spike.find('**/lod_low')
spikeHi.copyTo(geomHigh)
spikeMed.copyTo(geomMed)
spikeLow.copyTo(geomLow)
spikeLow.copyTo(geomSuperLow)
flipRoot = NodePath('root')
collisions.reparentTo(flipRoot)
locators.reparentTo(flipRoot)
geomHigh.reparentTo(flipRoot)
geomMed.reparentTo(flipRoot)
geomLow.reparentTo(flipRoot)
geomSuperLow.reparentTo(flipRoot)
flipRoot.setH(180)
flipRoot.flattenLight()
omits = flipRoot.findAllMatches('**/omit')
for node in omits:
node.flattenStrong()
for group in [
'static', 'transparent', 'ropeLadder_*', 'stripeA', 'stripeB',
'pattern'
]:
for node in flipRoot.findAllMatches('**/%s' % group):
name = node.getName()
for subNode in node.findAllMatches('**/*'):
subNode.setName(name)
node.flattenStrong()
node.setName(name)
geomHigh.detachNode()
geomMed.detachNode()
geomLow.detachNode()
geomSuperLow.detachNode()
locators.detachNode()
collisions.detachNode()
genericGeoms = [geomHigh, geomMed, geomLow, geomSuperLow]
customGeoms = [x.copyTo(NodePath()) for x in genericGeoms]
for np in genericGeoms:
trans = np.find('**/transparent')
if trans:
trans.stash()
np.flattenLight()
sails = np.findAllMatches('**/sails')
sails.stash()
omits = np.findAllMatches('**/omit')
omits.stash()
for node in omits:
node.node().setPreserveTransform(node.node().PTDropNode)
generic = NodePath('generic')
np.findAllMatches('**/+GeomNode').wrtReparentTo(generic)
np.findAllMatches('*').detach()
generic.flattenStrong()
generic.reparentTo(np)
stripAttribs(generic, TextureAttrib)
stripAttribs(generic, TransparencyAttrib)
stripAttribs(generic, CullBinAttrib)
generic.setBin('ground', 1)
collapse(generic)
sails.unstash()
sails.reparentTo(np)
for node in sails:
node.node().setPreserveTransform(node.node().PTDropNode)
if trans:
trans.unstash()
trans.flattenStrong()
if trans.node().isOfType(ModelNode.getClassType()):
trans.node().setPreserveTransform(ModelNode.PTDropNode)
deck = np.find('**/=cam=shground')
if deck:
deck.setName('deck')
omits.unstash()
for np in customGeoms:
collapse(np.find('**/static'))
data = HullCache()
data.root = NodePath('hull')
data.genericGeoms = genericGeoms
data.customGeoms = customGeoms
data.collisions = collisions
data.locators = locators
return data
class CogdoMazeFactory:
def __init__(self,
randomNumGen,
width,
height,
frameWallThickness=Globals.FrameWallThickness,
cogdoMazeData=CogdoMazeData):
self._rng = RandomNumGen(randomNumGen)
self.width = width
self.height = height
self.frameWallThickness = frameWallThickness
self._cogdoMazeData = cogdoMazeData
self.quadrantSize = self._cogdoMazeData.QuadrantSize
self.cellWidth = self._cogdoMazeData.QuadrantCellWidth
def getMazeData(self):
if not hasattr(self, '_data'):
self._generateMazeData()
return self._data
def createCogdoMaze(self, flattenModel=True):
if not hasattr(self, '_maze'):
self._loadAndBuildMazeModel(flatten=flattenModel)
return CogdoMaze(self._model, self._data, self.cellWidth)
def _gatherQuadrantData(self):
self.openBarriers = []
barrierItems = range(Globals.TotalBarriers)
self._rng.shuffle(barrierItems)
for i in barrierItems[0:len(barrierItems) - Globals.NumBarriers]:
self.openBarriers.append(i)
self.quadrantData = []
quadrantKeys = self._cogdoMazeData.QuadrantCollisions.keys()
self._rng.shuffle(quadrantKeys)
i = 0
for y in xrange(self.height):
for x in xrange(self.width):
key = quadrantKeys[i]
collTable = self._cogdoMazeData.QuadrantCollisions[key]
angle = self._cogdoMazeData.QuadrantAngles[self._rng.randint(
0,
len(self._cogdoMazeData.QuadrantAngles) - 1)]
self.quadrantData.append((key, collTable[angle], angle))
i += 1
if x * y >= self._cogdoMazeData.NumQuadrants:
i = 0
def _generateBarrierData(self):
data = []
for y in xrange(self.height):
data.append([])
for x in xrange(self.width):
if x == self.width - 1:
ax = -1
else:
ax = 1
if y == self.height - 1:
ay = -1
else:
ay = 1
data[y].append([ax, ay])
dirUp = 0
dirDown = 1
dirLeft = 2
dirRight = 3
def getAvailableDirections(ax, ay, ignore=None):
dirs = []
if ax - 1 >= 0 and data[ay][ax - 1][BARRIER_DATA_RIGHT] == 1 and (
ax, ay) != ignore:
dirs.append(dirLeft)
if ax + 1 < self.width and data[ay][ax][
BARRIER_DATA_RIGHT] == 1 and (ax, ay) != ignore:
dirs.append(dirRight)
if ay - 1 >= 0 and data[ay - 1][ax][BARRIER_DATA_TOP] == 1 and (
ax, ay) != ignore:
dirs.append(dirDown)
if ay + 1 < self.height and data[ay][ax][
BARRIER_DATA_TOP] == 1 and (ax, ay) != ignore:
dirs.append(dirUp)
return dirs
visited = []
def tryVisitNeighbor(ax, ay, ad):
if ad == dirUp:
if data[ay][ax] in visited:
return None
visited.append(data[ay][ax])
data[ay][ax][BARRIER_DATA_TOP] = 0
ay += 1
elif ad == dirDown:
if data[ay - 1][ax] in visited:
return None
visited.append(data[ay - 1][ax])
data[ay - 1][ax][BARRIER_DATA_TOP] = 0
ay -= 1
elif ad == dirLeft:
if data[ay][ax - 1] in visited:
return None
visited.append(data[ay][ax - 1])
data[ay][ax - 1][BARRIER_DATA_RIGHT] = 0
ax -= 1
elif ad == dirRight:
if data[ay][ax] in visited:
return None
visited.append(data[ay][ax])
data[ay][ax][BARRIER_DATA_RIGHT] = 0
ax += 1
return (ax, ay)
def openBarriers(x, y):
dirs = getAvailableDirections(x, y)
for dir in dirs:
next = tryVisitNeighbor(x, y, dir)
if next is not None:
openBarriers(*next)
return
x = self._rng.randint(0, self.width - 1)
y = self._rng.randint(0, self.height - 1)
openBarriers(x, y)
self._barrierData = data
def _generateMazeData(self):
if not hasattr(self, 'quadrantData'):
self._gatherQuadrantData()
self._data = {}
self._data['width'] = (
self.width +
1) * self.frameWallThickness + self.width * self.quadrantSize
self._data['height'] = (
self.height +
1) * self.frameWallThickness + self.height * self.quadrantSize
self._data['originX'] = int(self._data['width'] / 2)
self._data['originY'] = int(self._data['height'] / 2)
collisionTable = []
horizontalWall = [1 for x in xrange(self._data['width'])]
collisionTable.append(horizontalWall)
for i in xrange(0, len(self.quadrantData), self.width):
for y in xrange(self.quadrantSize):
row = [1]
for x in xrange(i, i + self.width):
if x == 1 and y < self.quadrantSize / 2 - 2:
newData = []
for j in self.quadrantData[x][1][y]:
if j == 0:
newData.append(2)
else:
newData.append(j + 0)
row += newData + [1]
else:
row += self.quadrantData[x][1][y] + [1]
collisionTable.append(row)
collisionTable.append(horizontalWall[:])
barriers = Globals.MazeBarriers
for i in xrange(len(barriers)):
for coords in barriers[i]:
collisionTable[coords[1]][coords[0]] = 0
y = self._data['originY']
for x in xrange(len(collisionTable[y])):
if collisionTable[y][x] == 0:
collisionTable[y][x] = 2
x = self._data['originX']
for y in xrange(len(collisionTable)):
if collisionTable[y][x] == 0:
collisionTable[y][x] = 2
self._data['collisionTable'] = collisionTable
def _loadAndBuildMazeModel(self, flatten=False):
self.getMazeData()
self._model = NodePath('CogdoMazeModel')
levelModel = CogdoUtil.loadMazeModel('level')
self.quadrants = []
quadrantUnitSize = int(self.quadrantSize * self.cellWidth)
frameActualSize = self.frameWallThickness * self.cellWidth
size = quadrantUnitSize + frameActualSize
halfWidth = int(self.width / 2)
halfHeight = int(self.height / 2)
i = 0
for y in xrange(self.height):
for x in xrange(self.width):
ax = (x - halfWidth) * size
ay = (y - halfHeight) * size
extension = ''
if hasattr(getBase(), 'air'):
extension = '.bam'
filepath = self.quadrantData[i][0] + extension
angle = self.quadrantData[i][2]
m = self._createQuadrant(filepath, i, angle, quadrantUnitSize)
m.setPos(ax, ay, 0)
m.reparentTo(self._model)
self.quadrants.append(m)
i += 1
quadrantHalfUnitSize = quadrantUnitSize * 0.5
barrierModel = CogdoUtil.loadMazeModel('grouping_blockerDivider').find(
'**/divider')
y = 3
for x in xrange(self.width):
if x == (self.width - 1) / 2:
continue
ax = (x - halfWidth) * size
ay = (y - halfHeight) * size - quadrantHalfUnitSize - (
self.cellWidth - 0.5)
b = NodePath('barrier')
barrierModel.instanceTo(b)
b.setPos(ax, ay, 0)
b.reparentTo(self._model)
offset = self.cellWidth - 0.5
for x in (0, 3):
for y in xrange(self.height):
ax = (
x - halfWidth
) * size - quadrantHalfUnitSize - frameActualSize + offset
ay = (y - halfHeight) * size
b = NodePath('barrier')
barrierModel.instanceTo(b)
b.setPos(ax, ay, 0)
b.setH(90)
b.reparentTo(self._model)
offset -= 2.0
barrierModel.removeNode()
levelModel.getChildren().reparentTo(self._model)
for np in self._model.findAllMatches('**/*lightCone*'):
CogdoUtil.initializeLightCone(np, 'fixed', 3)
if flatten:
self._model.flattenStrong()
return self._model
def _createQuadrant(self, filepath, serialNum, angle, size):
root = NodePath('QuadrantRoot-%i' % serialNum)
quadrant = loader.loadModel(filepath)
quadrant.getChildren().reparentTo(root)
root.setH(angle)
return root
def generateHullCache(modelClass):
geom = loader.loadModel("models/shipparts/pir_m_shp_%s" % HullDict[modelClass])
stripPrefix(geom, "model:")
for node in geom.findAllMatches("**/omit"):
parent = node.getParent()
omit = parent.attachNewNode(ModelNode("omit"))
node.reparentTo(omit)
node.setName("geom")
preFlatten(geom)
logic = loader.loadModel("models/shipparts/pir_m_shp_%s_logic" % HullDict[modelClass])
locators = logic.find("**/locators")
for side in ["left", "right"]:
bad = locators.find("**/location_ropeLadder_0_%s" % side)
if bad:
bad.setName("location_ropeLadder_%s_0" % side)
bad = locators.find("**/location_ropeLadder_1_%s" % side)
if bad:
bad.setName("location_ropeLadder_%s_1" % side)
bad = locators.find("**/location_ropeLadder_1_%s1" % side)
if bad:
bad.setName("location_ropeLadder_%s_2" % side)
continue
collisions = logic.find("**/collisions")
badPanel = collisions.find("**/collision_panel_3")
if badPanel:
badPanel.setName("collision_panel_2")
collisions.find("**/collision_panel_0").setTag("Hull Code", "0")
collisions.find("**/collision_panel_1").setTag("Hull Code", "1")
collisions.find("**/collision_panel_2").setTag("Hull Code", "2")
walls = collisions.find("**/collision_walls")
if walls:
walls.setTag("Hull Code", "255")
else:
collisions.attachNewNode("collision_walls")
shipToShipCollide = collisions.find("**/collision_shiptoship")
shipToShipCollide.setCollideMask(PiratesGlobals.ShipCollideBitmask)
deck = collisions.find("**/collision_deck")
if not deck:
deck = collisions.attachNewNode("deck")
mask = deck.getCollideMask()
mask ^= PiratesGlobals.FloorBitmask
mask |= PiratesGlobals.ShipFloorBitmask
deck.setCollideMask(mask)
floors = collisions.find("**/collision_floors")
if not floors:
floors = collisions.find("**/collision_floor")
mask = floors.getCollideMask()
mask ^= PiratesGlobals.FloorBitmask
mask |= PiratesGlobals.ShipFloorBitmask
floors.setCollideMask(mask)
floors.setTag("Hull Code", str(255))
geomHigh = geom.find("**/lod_high")
geomMed = geom.find("**/lod_medium")
if not geomMed:
geomMed = geom.find("**/low_medium")
if not geomMed:
geomMed = geomHigh.copyTo(NodePath())
geomLow = geom.find("**/lod_low")
if not geomLow:
geomLow = geomMed.copyTo(NodePath())
geomSuperLow = geom.find("**/lod_superlow")
if not geomSuperLow:
geomSuperLow = geomLow.copyTo(NodePath())
geomHigh.setName("high")
geomMed.setName("med")
geomLow.setName("low")
geomSuperLow.setName("superlow")
if modelClass in [21, 22, 23]:
spike = loader.loadModel("models/shipparts/pir_m_shp_ram_spike")
spikeTrans = locators.find("**/location_ram").getTransform(locators)
spike.setTransform(spikeTrans)
spike.flattenLight()
spikeHi = spike.find("**/lod_high")
spikeMed = spike.find("**/lod_medium")
spikeLow = spike.find("**/lod_low")
spikeHi.copyTo(geomHigh)
spikeMed.copyTo(geomMed)
spikeLow.copyTo(geomLow)
spikeLow.copyTo(geomSuperLow)
flipRoot = NodePath("root")
collisions.reparentTo(flipRoot)
locators.reparentTo(flipRoot)
geomHigh.reparentTo(flipRoot)
geomMed.reparentTo(flipRoot)
geomLow.reparentTo(flipRoot)
geomSuperLow.reparentTo(flipRoot)
flipRoot.setH(180)
flipRoot.flattenLight()
omits = flipRoot.findAllMatches("**/omit")
for node in omits:
node.flattenStrong()
for group in ["static", "transparent", "ropeLadder_*", "stripeA", "stripeB", "pattern"]:
for node in flipRoot.findAllMatches("**/%s" % group):
name = node.getName()
for subNode in node.findAllMatches("**/*"):
subNode.setName(name)
node.flattenStrong()
node.setName(name)
geomHigh.detachNode()
geomMed.detachNode()
geomLow.detachNode()
geomSuperLow.detachNode()
locators.detachNode()
collisions.detachNode()
genericGeoms = [geomHigh, geomMed, geomLow, geomSuperLow]
customGeoms = [x.copyTo(NodePath()) for x in genericGeoms]
for np in genericGeoms:
trans = np.find("**/transparent")
if trans:
trans.stash()
np.flattenLight()
sails = np.findAllMatches("**/sails")
sails.stash()
omits = np.findAllMatches("**/omit")
omits.stash()
for node in omits:
node.node().setPreserveTransform(node.node().PTDropNode)
generic = NodePath("generic")
np.findAllMatches("**/+GeomNode").wrtReparentTo(generic)
np.findAllMatches("*").detach()
generic.flattenStrong()
generic.reparentTo(np)
stripAttribs(generic, TextureAttrib)
stripAttribs(generic, TransparencyAttrib)
stripAttribs(generic, CullBinAttrib)
generic.setBin("ground", 1)
collapse(generic)
sails.unstash()
sails.reparentTo(np)
for node in sails:
node.node().setPreserveTransform(node.node().PTDropNode)
if trans:
trans.unstash()
trans.flattenStrong()
if trans.node().isOfType(ModelNode.getClassType()):
trans.node().setPreserveTransform(ModelNode.PTDropNode)
deck = np.find("**/=cam=shground")
if deck:
deck.setName("deck")
omits.unstash()
for np in customGeoms:
collapse(np.find("**/static"))
data = HullCache()
data.root = NodePath("hull")
data.genericGeoms = genericGeoms
data.customGeoms = customGeoms
data.collisions = collisions
data.locators = locators
return data
class ForestNode(NodePath):
def __init__(self, config, world):
NodePath.__init__(self, 'ForestNode')
self.config = config
self.world = world
self.added = []
self.trees = {}
self.trees_in_node = 10
self.mutex = self.world.mutex_repaint
self.flatten_node = NodePath('flatten_nodes')
def add_trees(self, chunk):
# level
if chunk not in self.added:
self.added.append(chunk)
else:
return
size2 = chunk[1] / 2
x = chunk[0][0]
y = chunk[0][1]
sx = x - size2
sy = y - size2
ex = x + size2
ey = y + size2
t = time.time()
trees = self.world.treeland[sx, sy, ex, ey]
for tree in trees:
if not self.trees.has_key(tree):
self.trees[tree] = []
self.trees[tree] = self.trees[tree] + trees[tree]
def clear(self):
self.flatten_node.detachNode()
self.flatten_node.removeNode()
self.flatten_node = NodePath('flatten_nodes')
def show_forest(self, DX, DY, char_far, far, charpos, Force=False):
"""Set to new X
center X - self.size/2 - DX
"""
tmp_node = NodePath('tmp')
self.flatten_node.copyTo(tmp_node)
self.mutex.acquire()
tmp_node.reparentTo(self)
self.flatten_node.removeNode()
self.mutex.release()
self.tree_nodes = []
self.flatten_node = NodePath('flatten_nodes')
t = time.time()
count_trees = 0
for tree_n in self.trees:
# create or attach
for coord in self.trees[tree_n]:
#length_cam_2d = VBase2.length(Vec2(coord[0], coord[1]) - Vec2(charpos[0], charpos[1]))
length_cam_3d = VBase3.length(Vec3(coord) - Vec3(charpos))
if char_far >= length_cam_3d <= far:
tree = self.world.trees[tree_n]
self.tree_nodes.append(NodePath('TreeNode'))
tree.copyTo(self.tree_nodes[count_trees])
x, y, z = coord
self.tree_nodes[count_trees].setPos(x - DX, y - DY, z - 1)
count_trees += 1
print 'Attach detach loop: ', time.time() - t
if count_trees == 0:
self.mutex.acquire()
tmp_node.removeNode()
self.mutex.release()
return
t = time.time()
self.count_f_nodes = (count_trees / self.trees_in_node) + 1
self.flatten_nodes = [
NodePath('flatten_node') for i in xrange(self.count_f_nodes)
]
s = 0
e = self.trees_in_node
added = 0
for node in self.flatten_nodes:
t_nodes = self.tree_nodes[s:e]
s += self.trees_in_node
e += self.trees_in_node
for t_node in t_nodes:
t_node.reparentTo(node)
added += 1
node.flattenStrong()
if not Force:
time.sleep(self.config.tree_sleep)
node.reparentTo(self.flatten_node)
if added == count_trees:
break
print 'Added: ', added, time.time() - t
t = time.time()
self.flatten_node.flattenStrong()
self.mutex.acquire()
self.flatten_node.reparentTo(self)
tmp_node.removeNode()
self.mutex.release()
print 'flatten all trees: ', time.time() - t
def generateHullCache(modelClass):
geom = loader.loadModel('models/shipparts/pir_m_shp_%s' % HullDict[modelClass])
stripPrefix(geom, 'model:')
for node in geom.findAllMatches('**/omit'):
parent = node.getParent()
omit = parent.attachNewNode(ModelNode('omit'))
node.reparentTo(omit)
node.setName('geom')
preFlatten(geom)
logic = loader.loadModel('models/shipparts/pir_m_shp_%s_logic' % HullDict[modelClass])
locators = logic.find('**/locators')
for side in [
'left',
'right']:
bad = locators.find('**/location_ropeLadder_0_%s' % side)
if bad:
bad.setName('location_ropeLadder_%s_0' % side)
bad = locators.find('**/location_ropeLadder_1_%s' % side)
if bad:
bad.setName('location_ropeLadder_%s_1' % side)
bad = locators.find('**/location_ropeLadder_1_%s1' % side)
if bad:
bad.setName('location_ropeLadder_%s_2' % side)
continue
collisions = logic.find('**/collisions')
badPanel = collisions.find('**/collision_panel_3')
if badPanel:
badPanel.setName('collision_panel_2')
collisions.find('**/collision_panel_0').setTag('Hull Code', '0')
collisions.find('**/collision_panel_1').setTag('Hull Code', '1')
collisions.find('**/collision_panel_2').setTag('Hull Code', '2')
walls = collisions.find('**/collision_walls')
if walls:
walls.setTag('Hull Code', '255')
else:
collisions.attachNewNode('collision_walls')
shipToShipCollide = collisions.find('**/collision_shiptoship')
shipToShipCollide.setCollideMask(PiratesGlobals.ShipCollideBitmask)
deck = collisions.find('**/collision_deck')
if not deck:
deck = collisions.attachNewNode('deck')
mask = deck.getCollideMask()
mask ^= PiratesGlobals.FloorBitmask
mask |= PiratesGlobals.ShipFloorBitmask
deck.setCollideMask(mask)
floors = collisions.find('**/collision_floors')
if not floors:
floors = collisions.find('**/collision_floor')
mask = floors.getCollideMask()
mask ^= PiratesGlobals.FloorBitmask
mask |= PiratesGlobals.ShipFloorBitmask
floors.setCollideMask(mask)
floors.setTag('Hull Code', str(255))
geomHigh = geom.find('**/lod_high')
geomMed = geom.find('**/lod_medium')
if not geomMed:
geomMed = geom.find('**/low_medium')
if not geomMed:
geomMed = geomHigh.copyTo(NodePath())
geomLow = geom.find('**/lod_low')
if not geomLow:
geomLow = geomMed.copyTo(NodePath())
geomSuperLow = geom.find('**/lod_superlow')
if not geomSuperLow:
geomSuperLow = geomLow.copyTo(NodePath())
geomHigh.setName('high')
geomMed.setName('med')
geomLow.setName('low')
geomSuperLow.setName('superlow')
if modelClass in [
21,
22,
23]:
spike = loader.loadModel('models/shipparts/pir_m_shp_ram_spike')
spikeTrans = locators.find('**/location_ram').getTransform(locators)
spike.setTransform(spikeTrans)
spike.flattenLight()
spikeHi = spike.find('**/lod_high')
spikeMed = spike.find('**/lod_medium')
spikeLow = spike.find('**/lod_low')
spikeHi.copyTo(geomHigh)
spikeMed.copyTo(geomMed)
spikeLow.copyTo(geomLow)
spikeLow.copyTo(geomSuperLow)
flipRoot = NodePath('root')
collisions.reparentTo(flipRoot)
locators.reparentTo(flipRoot)
geomHigh.reparentTo(flipRoot)
geomMed.reparentTo(flipRoot)
geomLow.reparentTo(flipRoot)
geomSuperLow.reparentTo(flipRoot)
flipRoot.setH(180)
flipRoot.flattenLight()
omits = flipRoot.findAllMatches('**/omit')
for node in omits:
node.flattenStrong()
for group in [
'static',
'transparent',
'ropeLadder_*',
'stripeA',
'stripeB',
'pattern']:
for node in flipRoot.findAllMatches('**/%s' % group):
name = node.getName()
for subNode in node.findAllMatches('**/*'):
subNode.setName(name)
node.flattenStrong()
node.setName(name)
geomHigh.detachNode()
geomMed.detachNode()
geomLow.detachNode()
geomSuperLow.detachNode()
locators.detachNode()
collisions.detachNode()
genericGeoms = [
geomHigh,
geomMed,
geomLow,
geomSuperLow]
customGeoms = [ x.copyTo(NodePath()) for x in genericGeoms ]
for np in genericGeoms:
trans = np.find('**/transparent')
if trans:
trans.stash()
np.flattenLight()
sails = np.findAllMatches('**/sails')
sails.stash()
omits = np.findAllMatches('**/omit')
omits.stash()
for node in omits:
node.node().setPreserveTransform(node.node().PTDropNode)
generic = NodePath('generic')
np.findAllMatches('**/+GeomNode').wrtReparentTo(generic)
np.findAllMatches('*').detach()
generic.flattenStrong()
generic.reparentTo(np)
stripAttribs(generic, TextureAttrib)
collapse(generic)
sails.unstash()
sails.reparentTo(np)
for node in sails:
node.node().setPreserveTransform(node.node().PTDropNode)
if trans:
trans.unstash()
trans.flattenStrong()
if trans.node().isOfType(ModelNode.getClassType()):
trans.node().setPreserveTransform(ModelNode.PTDropNode)
deck = np.find('**/=cam=shground')
if deck:
deck.setName('deck')
omits.unstash()
for np in customGeoms:
collapse(np.find('**/static'))
data = HullCache()
data.root = NodePath('hull')
data.genericGeoms = genericGeoms
data.customGeoms = customGeoms
data.collisions = collisions
data.locators = locators
return data
class Grid(object):
'''The grid object draws a bunch of lines and flattens them into a single
object.'''
def __init__(self, parent, boardRad, gridInt):
Event.Dispatcher().register(self, 'E_Key_GridUp', self.gridMove)
Event.Dispatcher().register(self, 'E_Key_GridDown', self.gridMove)
self.currZ = 0
self.gridInt = gridInt
self.boardRad = boardRad
if((boardRad*2) % gridInt is not 0):
print("ERROR: gridInt can not fit in universeRadius")
Event.Dispatcher().broadcast(Event.Event('E_ExitGame', src=self))
self.gridNP = NodePath("Grid Node Parent")
self.squareNP = NodePath("Squares Node Parent")
'''
#Since we are using collision detection to do picking, we set it up like
#any other collision detection system with a traverser and a handler
self.picker = CollisionTraverser() #Make a traverser
self.pq = CollisionHandlerQueue() #Make a handler
#Make a collision node for our picker ray
self.pickerNode = CollisionNode('mouseRay')
#Attach that node to the camera since the ray will need to be positioned
#relative to it
self.pickerNP = camera.attachNewNode(self.pickerNode)
#Everything to be picked will use bit 1. This way if we were doing other
#collision we could seperate it
self.pickerNode.setFromCollideMask(BitMask32.bit(1))
self.pickerRay = CollisionRay() #Make our ray
self.pickerNode.addSolid(self.pickerRay) #Add it to the collision node
#Register the ray as something that can cause collisions
self.picker.addCollider(self.pickerNP, self.pq)
#self.picker.showCollisions(render)
'''
# Draw centered lines
self.drawLine(self.gridNP, Vec3(0, -boardRad, self.currZ), Vec3(0, boardRad, self.currZ))
self.drawLine(self.gridNP, Vec3(-boardRad, 0, self.currZ), Vec3(boardRad, 0, self.currZ))
# Draw lines in y-axis direction
for x in frange(gridInt, (boardRad + gridInt), gridInt):
self.drawLine(self.gridNP, Vec3(x, -boardRad, self.currZ), Vec3(x, boardRad, self.currZ))
self.drawLine(self.gridNP, Vec3(-x, -boardRad, self.currZ), Vec3(-x, boardRad, self.currZ))
# Draw lines in x-axis direction
for y in frange(gridInt, (boardRad + gridInt), gridInt):
self.drawLine(self.gridNP, Vec3(-boardRad, y, self.currZ), Vec3(boardRad, y, self.currZ))
self.drawLine(self.gridNP, Vec3(-boardRad, -y, self.currZ), Vec3(boardRad, -y, self.currZ))
self.gridNP.flattenStrong()
# Start with grids turned off
#self.gridNP.hide()
self.gridNP.reparentTo(parent)
# drawLine
# Draws a line from source to target and parents to parent
def drawLine(self, parent, source, target):
line = LineSegs()
line.setThickness(LINETHICKNESS)
line.reset()
line.setColor(*GRIDCOLOR)
line.moveTo(source)
line.drawTo(target)
node = line.create()
lineSegNP = NodePath(node).reparentTo(parent)
# drawSquare
# Draws a square from ll (x1, y2, z1) to ur (x2, y2, z2) returns a node path
def drawSquare(self, x1,y1,z1, x2,y2,z2):
format=GeomVertexFormat.getV3n3cpt2()
vdata=GeomVertexData('square', format, Geom.UHStatic)
vertex=GeomVertexWriter(vdata, 'vertex')
normal=GeomVertexWriter(vdata, 'normal')
color=GeomVertexWriter(vdata, 'color')
texcoord=GeomVertexWriter(vdata, 'texcoord')
#make sure we draw the sqaure in the right plane
#if x1!=x2:
vertex.addData3f(x1, y1, z1)
vertex.addData3f(x2, y1, z1)
vertex.addData3f(x2, y2, z2)
vertex.addData3f(x1, y2, z2)
normal.addData3f(self.myNormalize(Vec3(2*x1-1, 2*y1-1, 2*z1-1)))
normal.addData3f(self.myNormalize(Vec3(2*x2-1, 2*y1-1, 2*z1-1)))
normal.addData3f(self.myNormalize(Vec3(2*x2-1, 2*y2-1, 2*z2-1)))
normal.addData3f(self.myNormalize(Vec3(2*x1-1, 2*y2-1, 2*z2-1)))
#adding different colors to the vertex for visibility
color.addData4f(0.0,0.5,0.0,0.5)
color.addData4f(0.0,0.5,0.0,0.5)
color.addData4f(0.0,0.5,0.0,0.5)
color.addData4f(0.0,0.5,0.0,0.5)
texcoord.addData2f(0.0, 1.0)
texcoord.addData2f(0.0, 0.0)
texcoord.addData2f(1.0, 0.0)
texcoord.addData2f(1.0, 1.0)
#quads arent directly supported by the Geom interface
#you might be interested in the CardMaker class if you are
#interested in rectangle though
tri1=GeomTriangles(Geom.UHStatic)
tri2=GeomTriangles(Geom.UHStatic)
tri1.addVertex(0)
tri1.addVertex(1)
tri1.addVertex(3)
tri2.addConsecutiveVertices(1,3)
tri1.closePrimitive()
tri2.closePrimitive()
square=Geom(vdata)
square.addPrimitive(tri1)
square.addPrimitive(tri2)
#square.setIntoCollideMask(BitMask32.bit(1))
squareNP = NodePath(GeomNode('square gnode'))
squareNP.node().addGeom(square)
squareNP.setTransparency(1)
squareNP.setAlphaScale(.5)
squareNP.setTwoSided(True)
squareNP.setCollideMask(BitMask32.bit(1))
return squareNP
# myNormalize
# Calculates a normal (How?)
def myNormalize(self, myVec):
myVec.normalize()
return myVec
def gridMove(self, event):
print("moving grid")
if event.type == 'E_Key_GridUp':
self.gridNP.setPos(self.gridNP.getX(), self.gridNP.getY(), self.currZ + self.gridInt)
if event.type == 'E_Key_GridDown':
self.gridNP.setPos(self.gridNP.getX(), self.gridNP.getY(), self.currZ - self.gridInt)
# toggleState
# Toggles between grid layers and grid off
def toggleState(self):
if (S.currLayer == 0):
S.currLayer = 1
self.gridNPList[0].show()
elif(S.currLayer == universeLayers):
self.gridNPList[S.currLayer-1].hide()
S.currLayer = 0
else:
self.gridNPList[S.currLayer-1].hide()
S.currLayer = S.currLayer + 1
self.gridNPList[S.currLayer-1].show()
