def generate(self, helperInfo):
color = self.mapObject.getPropertyValue("_light",
default=Vec4(
255, 255, 255, 255))
color = CIGlobals.colorFromRGBScalar255(color)
color = CIGlobals.vec3GammaToLinear(color)
constant = float(
self.mapObject.getPropertyValue("_constant_attn", default="0.0"))
linear = float(
self.mapObject.getPropertyValue("_linear_attn", default="0.0"))
quadratic = float(
self.mapObject.getPropertyValue("_quadratic_attn", default="1.0"))
# Scale intensity for unit 100 distance
ratio = (constant + 100 * linear + 100 * 100 * quadratic)
if ratio > 0:
color *= ratio
pl = Spotlight("lightHelper-light_spot")
pl.setColor(Vec4(color[0], color[1], color[2], 1.0))
pl.setAttenuation(Vec3(constant, linear, quadratic))
pl.setExponent(self.mapObject.getPropertyValue("_exponent"))
pl.setMaxDistance(self.mapObject.getPropertyValue("_distance"))
pl.getLens().setFov(self.mapObject.getPropertyValue("_cone"))
pl.getLens().setViewHpr(0, -90, 0)
self.light = self.mapObject.helperRoot.attachNewNode(pl)
if self.mapObject.doc.numlights < 64:
self.mapObject.doc.render.setLight(self.light)
self.mapObject.doc.numlights += 1
self.hasLight = True
def __init__(self):
loadPrcFile('config.prc')
ShowBase.__init__(self)
base.disableMouse()
self.render.setShaderAuto()
self.accept("escape", sys.exit)
# Model
model = self.loader.loadModel("twisted")
model.reparent_to(self.render)
self.model = model # For reference in the rotation task
# Light
light = Spotlight('light')
light_np = self.render.attachNewNode(light)
light_np.set_pos(25, 25, 25)
light_np.look_at(0, 0, 0)
# Model-light interaction
light.setShadowCaster(True)
light.getLens().setNearFar(1, 50)
self.render.setLight(light_np)
# Camera
self.camera.set_pos(0, -60, 30)
self.camera.look_at(0, 0, 0)
# Rotating the object
self.taskMgr.add(self.rotate_object, 'rotate object')
self.render.setAntialias(AntialiasAttrib.MMultisample)
def set_spotlight(self, col, exp, cutoff, pos, look_at):
lgt = Spotlight('spotlight')
lgt.setColor(col)
lgt.setExponent(exp)
lgt.getLens().setFov(cutoff, cutoff)
self.__set_lgt(lgt)
self.lights[-1].setPos(*pos)
self.lights[-1].lookAt(*look_at)
def __init__(self):
# Basics
ShowBase.__init__(self)
base.disableMouse()
self.render.setShaderAuto()
self.accept("escape", sys.exit)
# Model
model = self.loader.loadModel("twisted")
model.reparent_to(self.render)
self.model = model # For reference in the rotation task
# Light
light = Spotlight('light')
light_np = self.render.attachNewNode(light)
light_np.set_pos(50, 50, 50)
light_np.look_at(0, 0, 0)
# Model-light interaction
light.setShadowCaster(True)
light.getLens().setNearFar(1, 100)
self.render.setLight(light_np)
# Camera
self.camera.set_pos(0, -60, 30)
self.camera.look_at(0, 0, 0)
# Rotating the object
self.taskMgr.add(self.rotate_object, 'rotate object')
class Map:
def __init__(self,filename):
self.height = 0
self.width = 0
self.waterheight = 0
self.countries = []
self.tileList = []
self.tileReference = {}
self.node = render.attachNewNode('BaseMap')
self.snow = loader.loadModel("data/models/snow.bam")
self.ice = loader.loadModel("data/models/ice.bam")
self.plains = loader.loadModel("data/models/plains.bam")
self.forest = loader.loadModel("data/models/forest.bam")
self.jaggedrocks = loader.loadModel("data/models/jaggedrocks.bam")
self.mountain = loader.loadModel("data/models/mountains.bam")
self.desert = loader.loadModel("data/models/desert.bam")
self.hills = loader.loadModel("data/models/hills.bam")
self.water = loader.loadModel("data/models/water.bam")
self.water.setTransparency(TransparencyAttrib.MAlpha)
self.watertop = loader.loadModel("data/models/watertop.bam")
self.waterbottom = loader.loadModel("data/models/waterbottom.bam")
render.setShaderAuto()
self.spot = Spotlight('World spot')
self.spot.setColor((.7,.7,.7,1))
self.spot.getLens().setFov(180)
self.spot.getLens().setNearFar(1,10000000)
self.spotNode = render.attachNewNode(self.spot)
self.spotNode.setPos(2000,2000,5000)
self.spotNode.lookAt(self.node)
render.setLight(self.spotNode)
self.createMap(filename)
self.watertop.reparentTo(self.node)
self.watertop.setScale(9,9,9)
self.watertop.setPos((self.width*60)/2,-(self.height*17)/2,5)
self.waterbottom.reparentTo(self.node)
self.waterbottom.setScale(9,9,9)
self.waterbottom.setPos((self.width*60)/2,-(self.height*17)/2,1)
def getCountry(self,countryNum):
return self.countries[countryNum]
def drawMap(self):
pass
def createMap(self,filename):
filein = open(filename,"rb")
countryCounter = 0
tileCounter = 0
countryTiles = []
countryIncome = 0
for line in filein:
words = line.split()
if len(words) > 0:
if words[0] == "<map>":
pass
elif words[0] == "<height>":
self.height = eval(words[1])
elif words[0] == "<width>":
self.width = eval(words[1])
elif words[0] == "<waterheight>":
self.waterheight = eval(words[1])
elif words[0] == "<tile>":
terrainType = eval(words[1])
newNode = self.node.attachNewNode('terrain'+str(tileCounter))
newNode.setTag('tile',str(tileCounter))
if terrainType == TERRAIN_WATER:
self.water.instanceTo(newNode)
elif terrainType == TERRAIN_SNOW:
self.snow.instanceTo(newNode)
elif terrainType == TERRAIN_ICE:
self.ice.instanceTo(newNode)
elif terrainType == TERRAIN_PLAINS:
self.plains.instanceTo(newNode)
elif terrainType == TERRAIN_FOREST:
self.forest.instanceTo(newNode)
elif terrainType == TERRAIN_JAGGEDROCKS:
self.jaggedrocks.instanceTo(newNode)
elif terrainType == TERRAIN_MOUNTAIN:
self.mountain.instanceTo(newNode)
elif terrainType == TERRAIN_DESERT:
self.desert.instanceTo(newNode)
elif terrainType == TERRAIN_HILLS:
self.hills.instanceTo(newNode)
x = (tileCounter % self.width)
y = (tileCounter / self.width)
if y % 2 == 0:
newNode.setPos(x*60,-y*17,0)
else:
newNode.setPos(x*60+30,-y*17,0)
newTile = Tile(terrainType,newNode,x,y,tileCounter)
self.tileList.append(newTile)
tileCounter += 1
elif words[0] == "<income>":
countryIncome = eval(words[1])
elif words[0] == "<tileNum>":
countryTiles.append(self.tileList[eval(words[1])])
elif words[0] == "</country>":
newCountry = Country(countryTiles,countryIncome)
self.countries.append(newCountry)
countryCounter += 1
countryTiles = []
countryIncome = 0
else:
pass
#end loop
for country in range(len(self.countries)):
for tile in self.countries[country].getTiles():
x = tile.getX()
y = tile.getY()
self.tileReference[(x,y)]=country
filein.close()
#end init
def getTile(self,x,y):
#get the tile from the country it is in from spectile
return self.countries[self.tileReference[(x,y)]].getSpecTile(x,y)
def getPlayerCountries(self,playerNum):
#return the list of countries that belong to that player
playerCountries = []
for country in self.countries:
if country.getOwner() == playerNum:
playerCountries.append(country)
return playerCountries
