class MyApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
# Turn Auto Shaders and Antialiasing
self.render.setShaderAuto()
self.render.setAntialias(AntialiasAttrib.MAuto)
# Setup Bloom and Blur Filters
self.filters = CommonFilters(base.win, base.cam)
self.filters.setBloom(blend=(1,0,0,1), desat=-0.5, intensity=6.0, size=2)
#self.filters.setBlurSharpen(amount=0.5)
# Create Ambient Lighting
alight = AmbientLight('alight')
alight.setColor(VBase4(1, 1, 1, 1))
alnp = render.attachNewNode(alight)
self.render.setLight(alnp)
# Load Model and Add it to Scene
self.environ = self.loader.loadModel("untitled.egg")
self.environ.reparentTo(self.render)
self.environ.setTransparency(TransparencyAttrib.MAlpha)
class MyApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
# Turn Auto Shaders and Antialiasing
self.render.setShaderAuto()
self.render.setAntialias(AntialiasAttrib.MAuto)
# Setup Bloom and Blur Filters
self.filters = CommonFilters(base.win, base.cam)
self.filters.setBloom(blend=(1, 0, 0, 1),
desat=-0.5,
intensity=6.0,
size=2)
#self.filters.setBlurSharpen(amount=0.5)
# Create Ambient Lighting
alight = AmbientLight('alight')
alight.setColor(VBase4(1, 1, 1, 1))
alnp = render.attachNewNode(alight)
self.render.setLight(alnp)
# Load Model and Add it to Scene
self.environ = self.loader.loadModel("untitled.egg")
self.environ.reparentTo(self.render)
self.environ.setTransparency(TransparencyAttrib.MAlpha)
class GlowDemo(ShowBase):
def __init__(self):
ShowBase.__init__(self)
base.setBackgroundColor(0, 0, 0)
# render.setShaderAuto()
# Load the Lights
ambilight = AmbientLight('ambilight')
ambilight.setColor(VBase4(1, 1, 1, 1))
render.setLight(render.attachNewNode(ambilight))
self.filters = CommonFilters(base.win, base.cam)
self.filters.setBloom(blend=(0, 0, 0, 1),
desat=-0.8,
intensity=4.0,
size="big")
# self.glowSize=4
# ts = TextureStage('ts')
# ts.setMode(TextureStage.MGlow)
self.tron = loader.loadModel("data/models/vehicles/vehicle01")
self.tron.reparentTo(render)
self.tron2 = loader.loadModel("data/models/vehicles/vehicle02")
self.tron2.reparentTo(render)
self.tron2.setX(5)
self.tron3 = loader.loadModel("data/models/vehicles/vehicle03")
self.tron3.reparentTo(render)
self.tron3.setX(-5)
class BurdenOfProof(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.useAdvancedVisualEffects = ConfigVariableBool(
"use-advanced-visual-effects", True)
self.game = Game()
self.setupFilters()
self.setupModels()
self.setupKeyboardControl()
self.motionController = MotionController(self)
self.camera.setPos(0.0, 0.0, 1.7)
def setupKeyboardControl(self):
self.accept("escape", sys.exit)
def setupFilters(self):
if (self.useAdvancedVisualEffects):
self.filters = CommonFilters(self.win, self.cam)
self.filters.setBloom()
def setupModels(self):
self.cityModel = self.loader.loadModel("data/models/city")
self.cityModel.reparentTo(self.render)
self.cityModel.setP(-90.0)
self.pandaActor = Actor("models/panda-model",
{"walk": "models/panda-walk4"})
self.pandaActor.setScale(0.005, 0.005, 0.005)
self.pandaActor.loop("walk")
population = self.game.getPopulation()
self.characterInstances = []
for i in range(1, population.getCharacterCount()):
instance = self.render.attachNewNode("characterInstance")
instance.setPos(
population.getCharacter(i).getPosition(self.game.getTime()))
self.pandaActor.instanceTo(instance)
self.characterInstances.append(instance)
self.taskMgr.add(self.update, "updateTask")
def update(self, task):
self.game.update(oneMinute) # TODO(?) compute actual milliseconds
population = self.game.getPopulation()
for i in range(1, population.getCharacterCount()):
self.characterInstances[i - 1].setPos(
population.getCharacter(i).getPosition(self.game.getTime()))
return Task.cont
class BurdenOfProof(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.useAdvancedVisualEffects = ConfigVariableBool(
"use-advanced-visual-effects", True)
self.game = Game()
self.setupFilters()
self.setupModels()
self.setupKeyboardControl()
self.motionController = MotionController(self)
self.camera.setPos(0.0, 0.0, 1.7)
def setupKeyboardControl(self):
self.accept("escape", sys.exit)
def setupFilters(self):
if (self.useAdvancedVisualEffects):
self.filters = CommonFilters(self.win, self.cam)
self.filters.setBloom()
def setupModels(self):
self.cityModel = self.loader.loadModel("data/models/city")
self.cityModel.reparentTo(self.render)
self.cityModel.setP(-90.0)
self.pandaActor = Actor("models/panda-model",
{"walk": "models/panda-walk4"})
self.pandaActor.setScale(0.005, 0.005, 0.005)
self.pandaActor.loop("walk")
population = self.game.getPopulation()
self.characterInstances = []
for i in range(1, population.getCharacterCount()):
instance = self.render.attachNewNode("characterInstance")
instance.setPos(
population.getCharacter(i).getPosition(self.game.getTime()))
self.pandaActor.instanceTo(instance)
self.characterInstances.append(instance)
self.taskMgr.add(self.update, "updateTask")
def update(self, task):
self.game.update(oneMinute) # TODO(?) compute actual milliseconds
population = self.game.getPopulation()
for i in range(1, population.getCharacterCount()):
self.characterInstances[i - 1].setPos(
population.getCharacter(i).getPosition(self.game.getTime()))
return Task.cont
def postProcessingChanged():
global filters
if enablePostProcessing:
if filters == None:
filters = CommonFilters(base.win, base.cam)
render.setAttrib(LightRampAttrib.makeHdr1())
filters.setBloom(intensity = 1, size = 2)
else:
if filters != None:
filters.delBloom()
saveConfigFile()
def __init__(self):
ShowBase.__init__(self)
# Gui
#gui = GUI(self)
render.setShaderAuto()
self.game = Game(self)
filters = CommonFilters(base.win, base.cam)
filters.setBloom()
filters.setCartoonInk()
def __init__(self):
super().__init__(self)
self.var1 = 0
self.scene = loader.loadModel("models/world")
playerTexture = loader.loadTexture("models/starfoxShip.jpg")
self.player = self.scene.find("player")
self.player.setTexture(playerTexture)
base.setBackgroundColor(0.1, 0.1, 0.1, 1)
enemyTexture = loader.loadTexture("models/enemyShip.jpg")
self.enemy = self.scene.find("enemy1")
self.enemy.setTexture(enemyTexture)
self.basePlane = self.scene.find("basePlane")
self.scene.reparentTo(self.render)
self.player.setPos(50, 50, 3)
self.enemy.setPos(50, 55, 0)
self.ambient = AmbientLight("ambient")
self.ambient.color = (0.1, 0.1, 0.1, 1)
self.ambientPath = self.render.attachNewNode(self.ambient)
render.setLight(self.ambientPath)
self.dirLight = DirectionalLight("dir light")
self.dirLight.color = (1, 1, 1, 1)
self.dirLightPath = self.render.attachNewNode(self.dirLight)
self.dirLightPath.setHpr(0, -90, 0)
self.dirLight.setShadowCaster(True, 512, 512)
render.setLight(self.dirLightPath)
self.pointLight = PointLight("point light")
self.pointLight.color = (1, 1, 1, 1)
self.pointLightPath = self.render.attachNewNode(self.pointLight)
self.pointLightPath.setPos(50, 52.5, 4)
self.pointLight.attenuation = (.5, 0, 0)
self.pointLight.setShadowCaster(True, 1024, 1024)
self.render.setLight(self.pointLightPath)
self.fog = Fog("fog")
self.fog.setColor(0.1, 0.1, 0.1)
self.fog.setExpDensity(.3)
self.fog.setLinearRange(150, 300)
self.fog.setLinearFallback(45, 160, 320)
self.render.setFog(self.fog)
self.render.setShaderAuto()
self.render.setAntialias(AntialiasAttrib.MAuto)
filters = CommonFilters(base.win, base.cam)
filters.setBloom(size="large")
filters.setAmbientOcclusion(strength=0.6, falloff=0.0005, radius=0.1)
filters.setCartoonInk(separation=2, color=(0, 0, 0, 1))
self.taskMgr.add(self.update, "update")
def postProcessingChanged():
global filters
if enablePostProcessing:
if filters == None:
filters = CommonFilters(base.win, base.cam)
render.setAttrib(LightRampAttrib.makeHdr1())
filters.setBloom(intensity=1, size=2)
else:
if filters != None:
filters.delBloom()
saveConfigFile()
def _loadFilters(self):
self.terrain.setShaderInput('waterlevel', self._water_level)
# load default shaders
cf = CommonFilters(base.win, base.cam)
# bloomSize
cf.setBloom(size='small', desat=0.7, intensity=1.5, mintrigger=0.6, maxtrigger=0.95)
# hdrtype:
render.setAttrib(LightRampAttrib.makeHdr1())
# perpixel:
render.setShaderAuto()
def _loadFilters(self):
self.terrain.setShaderInput('waterlevel', self._water_level)
# load default shaders
cf = CommonFilters(base.win, base.cam)
#bloomSize
cf.setBloom(size='small', desat=0.7, intensity=1.5, mintrigger=0.6, maxtrigger=0.95)
#hdrtype:
render.setAttrib(LightRampAttrib.makeHdr1())
#perpixel:
render.setShaderAuto()
class Filters:
"""Class handles postprocessing filters and effects"""
def __init__(self,manager,xml):
self.cf = CommonFilters(base.win,base.cam)
self.reload(manager,xml)
def reload(self,manager,xml):
hdr = xml.find('hdr')
if hdr!=None:
self.hdrtype = hdr.get('type')
assert self.hdrtype in ['0', '1', '2']
else:
self.hdrtype = None
self.perpixel = xml.find('perpixel')!=None
bloom = xml.find('bloom')
if bloom!=None:
self.bloomSize = bloom.get('size', 'medium')
else:
self.bloomSize = None
self.showbuffers = xml.find('showbuffers')!=None
def start(self):
if self.hdrtype!=None:
render.setAttrib(getattr(LightRampAttrib, "makeHdr" + self.hdrtype)())
if self.perpixel:
render.setShaderAuto()
if self.bloomSize!=None:
self.cf.setBloom(size=self.bloomSize)
if self.showbuffers:
base.bufferViewer.toggleEnable()
def stop(self):
if self.hdrtype!=None:
render.clearAttrib(LightRampAttrib.getClassType())
if self.perpixel:
render.setShaderOff()
if self.bloomSize!=None:
self.cf.delBloom()
if self.showbuffers:
base.bufferViewer.toggleEnable()
class ShaderManager():
def __init__(self):
#needed for physics and particle system
base.enableParticles()
render.setShaderAuto()
def setBloomed(self):
#setupfilters and shaders
self.filters = CommonFilters(base.win, base.cam)
#self.filters.setCartoonInk(separation=1.0)
self.filters.setBloom(size="small")
#self.filters.setVolumetricLighting(myCamera.cameraLightNode)
render.setAttrib(LightRampAttrib.makeHdr0())
pass
def __init__(self):
base.enableParticles() # noqa: F821
render.setShaderAuto() # noqa: F821
self._explosion_lights = self._set_explosion_lights()
self._transition = Transitions(loader) # noqa: F821
self._transition.setFadeColor(0, 0, 0)
self.stench_effect = Stench()
self.love_fog = LoveFog()
filters = CommonFilters(base.win, base.cam) # noqa: F821
filters.setBloom(size="large", mintrigger=0.8, intensity=2.1)
def __init__(self):
super().__init__()
self.set_background_color(0, 0, 0, 1)
self.cam.setPos(0, -12, 0)
self.trees = NodePath("trees")
self.tree1 = self.loader.loadModel('my-models/christmas_tree')
self.tree1.setPos(0, 0, -2.5)
self.tree1.reparentTo(self.trees)
self.tree2 = self.loader.loadModel('my-models/christmas_tree')
self.tree2.setPos(4, 5, -2.5)
self.tree2.reparentTo(self.trees)
self.tree3 = self.loader.loadModel('my-models/christmas_tree')
self.tree3.setPos(-4, 7, -2.5)
self.tree3.reparentTo(self.trees)
self.trees.reparentTo(self.render)
self.floor = self.loader.loadModel('my-models/floor')
self.floor.setPos(0, 0, -2.5)
self.floor.reparentTo(self.render)
self.light_model = self.loader.loadModel('models/misc/sphere')
self.light_model.setScale(0.2, 0.2, 0.2)
# self.light_model.setPos(4, -4, 0)
self.light_model.reparentTo(self.render)
plight = PointLight("plight")
plight.setShadowCaster(True, 1024, 1024)
self.render.setShaderAuto()
plnp = self.light_model.attachNewNode(plight)
# plight.setAttenuation((1, 0, 0)) # constant, linear, and quadratic.
self.trees.setLight(plnp)
alight = AmbientLight("alight")
alight.setColor((0.04, 0.04, 0.04, 1))
alnp = self.render.attachNewNode(alight)
self.trees.setLight(alnp)
self.floor.setLight(plnp)
self.floor.setLight(alnp)
filters = CommonFilters(self.win, self.cam)
filters.setBloom(size="large")
self.taskMgr.add(self.move_light, "move-light")
class World:
def __init__(self):
base.disableMouse()
# Turns off the default mouse-camera controls in Panda3D.
base.setBackgroundColor(0, 0, 0)
# Sets the background to black.
self.inputManager = InputManager()
# Creates an InputManager to handle all of the user input in the game.
self.track = Track()
# Creates the track the cycles will race on.
self.cycle1 = Cycle(self.inputManager, self.track, 1, "Bert", ai=False)
self.cycle2 = Cycle(self.inputManager, self.track, 2, "Ernie")
# Creates one uncontrolled cycle, and one player controlled cycle.
taskMgr.doMethodLater(10, self.debugTask, "Debug Task")
# Tells the debugTask to run once every ten seconds. The debug task is a good
# place to put various data print outs about the game to help with debugging.
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setBloom(blend=(0, 0, 0, 1),
desat=-0.5,
intensity=3.0,
size=2)
render.setShaderAuto()
# Turns on Panda3D's automatic shader generation.
def debugTask(self, task):
print(taskMgr)
# prints all of the tasks in the task manager.
return task.again
class World:
def __init__(self):
base.disableMouse()
# Turns off the default mouse-camera controls in Panda3D.
base.setBackgroundColor(0, 0, 0)
# Sets the background to black.
self.inputManager = InputManager()
# Creates an InputManager to handle all of the user input in the game.
taskMgr.doMethodLater(10, self.debugTask, "Debug Task")
# Tells the debugTask to run once every ten seconds. The debug task is a good
# place to put various data print outs about the game to help with debugging.
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setBloom(blend=(0, 0, 0, 1),
desat=-0.5,
intensity=3.0,
size=2)
render.setShaderAuto()
# Turns on Panda3D's automatic shader generation.
self.menuGraphics = loader.loadModel("../Models/MenuGraphics.egg")
self.fonts = {
"silver": loader.loadFont("../Fonts/LuconSilver.egg"),
"blue": loader.loadFont("../Fonts/LuconBlue.egg"),
"orange": loader.loadFont("../Fonts/LuconOrange.egg")
}
self.race = Race(self.inputManager)
self.race.createDemoRace()
self.createStartMenu()
def createStartMenu(self):
menu = Menu(self.menuGraphics, self.fonts, self.inputManager)
menu.initMenu([
0, None, ["New Game", "Quit Game"],
[[self.race.createRace, self.createReadyDialogue],
[base.userExit]], [[None, None], [None]]
])
def createReadyDialogue(self):
menu = Menu(self.menuGraphics, self.fonts, self.inputManager)
menu.initMenu([
3, "Are you ready?", ["Yes", "Exit"],
[[self.race.startRace], [self.race.createDemoRace]], [[3], [None]]
])
def debugTask(self, task):
print(taskMgr)
# prints all of the tasks in the task manager.
return task.again
class Filters():
def __init__(self):
self.filters = CommonFilters(base.win, base.cam)
self.glowShader = loader.loadShader("./shaders/glowShader.sha")
def enableFilters(self, player):
#self.filters.setBloom(mintrigger=.35)
self.filters.setBloom(blend=(1, 0, .2, 1), desat=-1, intensity=10, size="small")
#self.filters.setCartoonInk(separation=-5)
self.filters.setAmbientOcclusion(numsamples = 2, radius = 0.0025, amount = 2, strength = 0.001, falloff = 0.01)
player.setShader(self.glowShader)
player.setShaderInput("scale",4,4)
path = render.find("renderDummy")
path.setShader(self.glowShader)
path.setShaderInput("scale",1,1,1)
def __init__(self, app_object):
self.app = app_object
self.n = 0
cmnd = ""
self.commandBox = ""
self.store = ["","","",""]
ShowBase.__init__(self)
self.title1 = self.AddTitle(-0.65, "Type your commands here:")
self.title2 = self.AddTitle(0.90, "You have entered:")
self.instArea = self.AddInstructions(0.82, cmnd)
self.cmndArea = self.AddArea()
base.setFrameRateMeter(True)
base.setBackgroundColor(0,0,0)
self.cube = loader.loadModel("models/cube")
self.cube.setPos(0, 0, 0)
self.cube.reparentTo(self.render)
self.cube.setScale((cx), 3, 1)
# cam
self.cam.setPos(60, -80, 22)
light = PointLight('light')
self.render.setLight(self.cam.attachNewNode(light))
self.cam.lookAt(self.cube)
self.i = 1
self.sy = 1
self.sx = 1
self.sz = 1
self.addx =1
self.addy =1
self.addz =1
#self.negy = -7
#self.posy = 7
#CENTER
#setting up the bloom effect
filters = CommonFilters(base.win, base.cam)
filters.setBloom(blend=(0.0,0.0,0.0,1.0), mintrigger = 0.9, desat=-0.5, intensity=8.0, size="small")
rootDir = os.path.abspath(os.path.dirname(sys.argv[0]))
loadPrcFile(os.path.join(rootDir, "config.prc"))
def __init__(self):
super().__init__()
self.set_background_color(0, 0, 0, 1)
self.cam.setPos(0, -80, 0)
self.sphere = self.loader.loadModel('models/misc/sphere')
self.sphere.setScale(0.5)
self.sphere.reparentTo(self.render)
my_curve = Mopath.Mopath()
my_curve.loadFile("my-models/curvey")
my_interval = MopathInterval(my_curve, self.sphere, name="my-path", duration=8)
# my_interval.start()
my_interval.loop()
filters = CommonFilters(self.win, self.cam)
filters.setBloom(size="medium")
print(my_curve.xyzNurbsCurve.getNumKnots())
print(my_curve.xyzNurbsCurve.getOrder())
print(my_curve.xyzNurbsCurve.getNumCvs())
print(my_curve.xyzNurbsCurve.getKnots())
def runConfiguration():
#Grundeinstellungen
base.setFrameRateMeter(True)
base.setBackgroundColor(0, 0, 0)
#Bloom Filter
CFilters = CommonFilters(base.win, base.cam)
filterok = CFilters.setBloom(blend=(0, 0, 0, 1),
desat=-0.1,
mintrigger=0.0,
intensity=6.0,
size="small")
if filterok == 0:
print "Deine Grafikkarte unterstuetzt kein Bloom Filter: Shader Error"
class World:
def __init__(self):
base.disableMouse()
base.setBackgroundColor(0.52, 0.80, 0.99)
self.inputManager = InputManager()
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size=2)
render.setShaderAuto()
self.menuGraphics = loader.loadModel("Models/MenuGraphics.egg")
self.fonts = {
"silver": loader.loadFont("Fonts/LuconSilver.egg"),
"blue": loader.loadFont("Fonts/LuconBlue.egg"),
"orange": loader.loadFont("Fonts/LuconOrange.egg")
}
gui = Gui(self.fonts)
self.race = Race(self.inputManager, gui)
self.race.createDemoRace()
self.createStartMenu()
musicMgr = base.musicManager
self.music = musicMgr.getSound("Sound/music_1.wav")
self.music.setLoop(True)
self.music.setVolume(.5)
self.music.play()
def createStartMenu(self):
menu = Menu(self.menuGraphics, self.fonts, self.inputManager)
menu.initMenu([0, None, ["New Game", "Quit Game"], [[self.race.createRace, self.createReadyDialogue], [base.userExit]], [[None, None], [None]]])
def createReadyDialogue(self):
menu = Menu(self.menuGraphics, self.fonts, self.inputManager)
menu.initMenu([3, "Ready?", ["Yes", "Exit"], [[self.race.startRace], [self.race.createDemoRace]], [[3], [None]]])
def debugTask(self, task):
print(taskMgr)
return task.again
class World(ShowBase): # CONDISER: change to DirectObject/FSM
def __init__(self):
ShowBase.__init__(self)
self.createLoadScreen('./LEGameAssets/Textures/title_screen.png')
base.graphicsEngine.renderFrame()
#== Environment and Rendering Settings ==
base.setFrameRateMeter(FLAG_SHOW_FRAMES_PER_SECOND)
if FLAG_USE_AUTOSHADER:
render.setShaderAuto()
self.filters = CommonFilters(base.win, self.cam) # NEW
if FLAG_SHOW_GLOW:
bloomSize = 4#'small'
filterok = self.filters.setBloom(blend=(0,0,0,1), desat=-0.5, intensity=3.0, size=bloomSize)
if (filterok == False):
print 'WARNING:Video card not powerful enough to do image postprocessing'
#tex = loader.loadTexture("./LEGameAssets/Textures/loadbar_tray.png")
self.loadBar = DirectWaitBar(text = "", value = 0, scale =(.35,.5,.5), pos = (0.006,.83,.83))
#self.loadBar['barRelief'] = DirectWaitBar.GROOVE
#self.loadBar['scale'] = 0.05
#self.loadBar['barTexture'] = tex
self.loadBar['barColor'] = (6.0/255.0, 11.0/255, 28.0/255.0, 1)
self.loadBar.reparentTo(render2d)
self.loadBar.hide()
base.graphicsEngine.renderFrame()
self.setBackgroundColor(166.0/255.0,207.0/255.0,240.0/255.0,1)
self.skybox = self.loader.loadModel("LEGameAssets/Models/skybox_final.egg")
self.skybox.setScale(50)
self.skybox.reparentTo(render)
#== Load the level and the managers ==
self.assets, self.objects, self.gameObjects, self.sounds, self.sequences= loadWorld(SCENE_FILE, LIBRARY_INDEX)
self.loadBar['value'] += 5
base.graphicsEngine.renderFrame()
self.conversations = loadConversations(SCENE_FILE, LIBRARY_INDEX)
self.scenes = {}
self.loadScenes()
self.loadBar['value'] += 5
base.graphicsEngine.renderFrame()
self.journalMgr = JournalMgr(self)
self.loadJournal(self.journalMgr,JOURNAL_FILE)
self.conversationMgr = ConversationMgr(self, self.conversations)
self.scriptMgr = ScriptMgr(self)
self.scriptMgr.loadScripts(SCRIPTS_LIST)
self.scriptInterface = ScriptInterface(self)
self.inventoryMgr = InventoryMgr(self)
loadInventory(self.inventoryMgr,INVENTORY_FILE)
self.loadBar['value'] += 5
base.graphicsEngine.renderFrame()
self.ranSequences = []
#== Main Character ==
self.hero = None
for name, gameObj in self.gameObjects.iteritems():
if gameObj.getNP().hasTag('LE-mainChar'):
self.hero = gameObj
break
else:
# make a default hero
defaultHeroNP = loader.loadModel("panda")
self.hero = GameObject(defaultHeroNP)
self.hero.reparentTo(render)
self.hero.setPos(0, 0, 0)
self.hero.setTag('LE-mainChar', '180')
self.gameObjects[self.hero.getName()] = self.hero
self.setCollideMasks(self.gameObjects)
# remove the hero from the objects dict so it cannot be clicked by player
if self.hero.getName() in self.objects:
del self.objects[self.hero.getName()]
#== Camera ==
camHeightFactor = CAMERA_HEIGHT
camTrailFactor = -CAMERA_TRAIL # careful of +/- distinction
self.heroHeight = self.getModelHeight(self.hero)
self.heroHeadingOffset = float(self.hero.getTag('LE-mainChar'))
self.lastHeroH = self.hero.getH(render) + self.heroHeadingOffset
# setup the camera pivot, which will follow the main character model and anchor the camera
self.camPivot = NodePath('camPivot')
self.camPivot.reparentTo(render)
self.camHeight = camHeightFactor*self.heroHeight
self.camTrail = camTrailFactor*self.heroHeight
self.cam.setPos(self.camPivot.getPos() + (0, self.camTrail, self.camHeight))
self.cam.wrtReparentTo(self.camPivot)
self.placeCamera(self.hero) # match X and Y to main character
self.alignCamera(self.hero) # match heading to main character
#self.camPivot.setH(render, self.hero.getH(render) + self.heroHeadingOffset)
self.gameCam = self.cam
#== Collisions ==
self.setupCollisions()
#== Controls ==
self.disableMouse()
self.keyMap = { 'w':False, 'a':False, 's':False, 'd':False }
self.enableMovement(self.hero)
self.accept("mouse1", self.onClickin3D)
self.accept('escape', sys.exit)
self.accept('z', render.place)
#== UI and Combat ==
self.gameplayUI = GameplayUI(self)
self.gameplayUI.hideAll()
# for health bars and on screen UI
self.overlayAmbientLight = AmbientLight('overlayAmbientLight')
self.overlayAmbientLight.setColor(VBase4(1.0, 1.0, 1.0, 1.0))
self.overlayAmbientLightNP = render.attachNewNode(self.overlayAmbientLight)
# initialize the combat manager (which includes AI) now that a main character and gameplayUI instance and overlay light is established
self.combatMgr = CombatMgr(self)
# initialize player's spells
self.heroSpells = []
for properties in PLAYER_SPELLS:
spell = Spell(self.hero, properties)
self.heroSpells.append(spell)
#== Start Tasks
taskMgr.add(self.moveHeroTask, 'moveHeroTask', appendTask=True)
taskMgr.add(self.cameraFollowTask, 'cameraFollowTask', appendTask=True)
taskMgr.add(self.processHeroCollisions, 'processHeroCollisions')
taskMgr.add(self.updateHeroHeight, 'updateHeroHeight')
self.combatMgr.startTasks()
self.accept('enter', self.destroyLoadScreen)
self.destroyLoadScreen()
##== Utility and World Initialization functions =============================##
def loadJournal(self,journalMgr,journalFile):
f = open(Filename(journalFile).toOsSpecific())
doc = xml.dom.minidom.parse(f)
root = doc.childNodes[0]
for n in root.childNodes:
if n.localName == "journalEntries":
journalMgr.decode(n)
f.close()
def getModelHeight(self, model):
min, max = Point3(), Point3()
model.calcTightBounds(min, max)
return max.getZ() - min.getZ()
def createLoadScreen(self, imageFile='./LEGameAssets/Textures/load_screen.png'):
self.loadScreen = OnscreenImage(image=imageFile)
aspect2d.hide()
self.loadScreen.reparentTo(render2d)
if(hasattr(self, "gameplayUI")):
self.gameplayUI.hideAll()
def destroyLoadScreen(self):
self.loadBar.hide()
self.loadScreen.detachNode()
self.loadScreen.destroy()
aspect2d.show()
self.ignore('enter')
self.gameplayUI.showAll()
for name, gameObj in self.gameObjects.iteritems():
gameObj.callTrigger(self, 'LE-trigger-onScene')
def startLoadBar(self, range=100):
self.loadBar.show()
self.loadBar['range'] = range
self.loadBar['value'] = 0
base.graphicsEngine.renderFrame()
def increaseLoadBar(self, value):
self.loadBar['value'] += value
base.graphicsEngine.renderFrame()
##== Collisions =============================================================##
def setupCollisions(self):
self.cTrav = CollisionTraverser('mainTraverser')
self.cTrav.setRespectPrevTransform(True)
# Line collider for setting hero height based on ground geometry
heroLine = CollisionNode('heroLine')
heroLine.addSolid(CollisionRay(Point3(0,0,self.heroHeight), Vec3(0,0,-1)))
heroLine.setFromCollideMask(BITMASK_GROUND)
heroLine.setIntoCollideMask(BitMask32.allOff())
self.heroGroundCollide = render.attachNewNode(heroLine)
self.heroGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroGroundCollide, self.heroGroundHandler)
# cameraSphere = CollisionNode('cameraSphere')
# cameraSphere.addSolid(CollisionSphere(0,0,0,10))
# cameraSphere.setFromCollideMask(BITMASK_CAMERA)
# cameraSphere.setIntoCollideMask(BitMask32.allOff())
# self.cameraSphereCollide = self.cam.attachNewNode(cameraSphere)
# self.cameraSphereQueue = CollisionHandlerQueue()
# self.cTrav.addCollider(self.cameraSphereCollide, self.cameraSphereQueue)
self.herowallcollision = False
self.heroWallCollideX = render.attachNewNode("heroWallX")
self.heroWallCollideY = render.attachNewNode("heroWallY")
self.heroWallCollideZ = render.attachNewNode("heroWallZ")
# Line collider for running into obstacles and walls in X direction
heroLineX = CollisionNode('heroLineX')
heroLineX.addSolid(CollisionRay(Point3(0,0,0), Vec3(0,0,1)))
self.heroWallCollideLineX = self.heroWallCollideX.attachNewNode(heroLineX)
self.heroWallCollideLineX.node().setFromCollideMask(BITMASK_WALL_TERRAIN)
self.heroWallCollideLineX.node().setIntoCollideMask(BitMask32.allOff())
self.heroWallQueueX = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroWallCollideLineX, self.heroWallQueueX)
# Line collider for running into obstacles and walls in Y direction
heroLineY = CollisionNode('heroLineY')
heroLineY.addSolid(CollisionRay(Point3(0,0,0), Vec3(0,0,1)))
self.heroWallCollideLineY = self.heroWallCollideY.attachNewNode(heroLineY)
self.heroWallCollideLineY.node().setFromCollideMask(BITMASK_WALL_TERRAIN)
self.heroWallCollideLineY.node().setIntoCollideMask(BitMask32.allOff())
self.heroWallQueueY = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroWallCollideLineY, self.heroWallQueueY)
# Line collider for running into obstacles and walls in Z direction
heroLineZ = CollisionNode('heroLineZ')
heroLineZ.addSolid(CollisionRay(Point3(0,0,0), Vec3(0,0,1)))
self.heroWallCollideLineZ = self.heroWallCollideZ.attachNewNode(heroLineZ)
self.heroWallCollideLineZ.node().setFromCollideMask(BITMASK_WALL_TERRAIN)
self.heroWallCollideLineZ.node().setIntoCollideMask(BitMask32.allOff())
self.heroWallQueueZ = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroWallCollideLineZ, self.heroWallQueueZ)
# # Sphere collider for running into obstacles and walls
# heroSphere = CollisionNode('heroSphere')
# heroSphere.addSolid(CollisionSphere(0,0,0,7))
# self.heroWallCollide = render.attachNewNode(heroSphere)
# self.heroWallCollide.node().setFromCollideMask(BITMASK_WALL)
# self.heroWallCollide.node().setIntoCollideMask(BitMask32.allOff())
# self.heroWallQueue = CollisionHandlerQueue()
# self.cTrav.addCollider(self.heroWallCollide, self.heroWallQueue)
# self.herowallcollision = False
# Sphere collider for running into obstacles and walls in X direction
heroSphereX = CollisionNode('heroSphereX')
heroSphereX.addSolid(CollisionSphere(0,0,0,7))
self.heroWallCollideSphereX = self.heroWallCollideX.attachNewNode(heroSphereX)
self.heroWallCollideSphereX.node().setFromCollideMask(BITMASK_WALL)
self.heroWallCollideSphereX.node().setIntoCollideMask(BitMask32.allOff())
#self.heroWallQueueX = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroWallCollideSphereX, self.heroWallQueueX)
self.herowallcollision = False
# Sphere collider for running into obstacles and walls in Y direction
heroSphereY = CollisionNode('heroSphereY')
heroSphereY.addSolid(CollisionSphere(0,0,0,7))
self.heroWallCollideSphereY = self.heroWallCollideY.attachNewNode(heroSphereY)
self.heroWallCollideSphereY.node().setFromCollideMask(BITMASK_WALL)
self.heroWallCollideSphereY.node().setIntoCollideMask(BitMask32.allOff())
#self.heroWallQueueY = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroWallCollideSphereY, self.heroWallQueueY)
# Sphere collider for running into obstacles and walls in Z direction
heroSphereZ = CollisionNode('heroSphereZ')
heroSphereZ.addSolid(CollisionSphere(0,0,0,7))
self.heroWallCollideSphereZ = self.heroWallCollideZ.attachNewNode(heroSphereZ)
self.heroWallCollideSphereZ.node().setFromCollideMask(BITMASK_WALL)
self.heroWallCollideSphereZ.node().setIntoCollideMask(BitMask32.allOff())
#self.heroWallQueueZ = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroWallCollideSphereZ, self.heroWallQueueZ)
# Ray collider for clicking on objects in the game
self.pickerCollisionQueue = CollisionHandlerQueue()
self.pickerCN = CollisionNode('pickerRayCN')
self.pickerCNP = self.cam.attachNewNode(self.pickerCN)
self.pickerCN.setFromCollideMask(BITMASK_CLICK)
self.pickerCN.setIntoCollideMask(BitMask32.allOff())
self.pickerRay = CollisionRay()
self.pickerCN.addSolid(self.pickerRay)
self.cTrav.addCollider(self.pickerCNP, self.pickerCollisionQueue)
# Sphere collider for triggering scripts
self.heroCN = CollisionNode('heroCN')
self.heroCN.addSolid(CollisionSphere(0, 0, 0, 5)) # TODO: find good radius
self.heroCNP = self.hero.attachNewNode(self.heroCN)
self.heroCN.setFromCollideMask(BITMASK_HERO_COLLIDE)
self.heroCN.setIntoCollideMask(BitMask32.allOff())
self.heroCollisionQueue = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroCNP, self.heroCollisionQueue)
# Line collider for transparency
self.cameraEntriesPre = []
radius = self.getModelHeight(self.hero)*CAMERA_TRAIL/2
self.cameraCollisionQueue = CollisionHandlerQueue()
self.cameraHero = CollisionNode('cameraHero')
self.cameraHeroLine = CollisionSegment(self.hero.getPos(render), self.cam.getPos(render))
self.cameraHero.addSolid(self.cameraHeroLine)
self.cameraHero.setFromCollideMask(BITMASK_CAMERA)
self.cameraHero.setIntoCollideMask(BitMask32.allOff())
self.cameraHeroP = self.render.attachNewNode(self.cameraHero)
self.cTrav.addCollider(self.cameraHeroP, self.cameraCollisionQueue)
#self.cameraHeroP.show()
if FLAG_SHOW_COLLISIONS:
self.cTrav.showCollisions(render)
# TODO: show specific collision nodepaths
def setCollideMasks(self, gameObjDict):
for name, obj in gameObjDict.iteritems():
bitmask = obj.getCollideMask()
if obj.hasTag('LE-ground'):
bitmask |= BITMASK_GROUND
#obj.getNP().setCollideMask(bitmask) # TODO: remove
if obj.hasTag('LE-attackable'):
bitmask |= BITMASK_CLICK
if obj.hasTag('LE-wall'):
if(isinstance(obj.getNP(), GeoMipTerrain)):
bitmask |= BITMASK_TERRAIN
else:
bitmask |= BITMASK_WALL
if obj.scripts.has_key('LE-trigger-onClick'):
bitmask |=BITMASK_CLICK
if obj.scripts.has_key('LE-trigger-onCollision'):
bitmask |=BITMASK_HERO_COLLIDE
if obj.hasTag('OBJRoot'):
if obj.hasTag('LE-ground') or obj.hasTag('LE-mainChar'):
pass
else:
bitmask |= BITMASK_CAMERA
obj.setCollideMask(bitmask)
def onClickin3D(self):
pickedObj = None
if self.conversationMgr.isConversationOpen():
return
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
else:
return
self.cTrav.addCollider(self.pickerCNP, self.pickerCollisionQueue)
self.pickerRay.setFromLens(self.cam.node(), mpos.getX(), mpos.getY())
self.cTrav.traverse(render)
if(self.pickerCollisionQueue.getNumEntries() > 0):
self.pickerCollisionQueue.sortEntries()
for i in range(self.pickerCollisionQueue.getNumEntries()):
parent = self.pickerCollisionQueue.getEntry(i).getIntoNodePath().getParent()
while not self.objects.has_key(parent.getName()):
if(parent.getName() == "render"):
return
parent = parent.getParent()
pickedObj = parent
if(pickedObj == None):
continue
else:
break
#if pickedObj.hasTag("LE-trigger-onClick"): # TODO: needed, or is having key in self.objects enough?
if (pickedObj == None):
return
self.pickerCollisionQueue.clearEntries()
self.cTrav.removeCollider(self.pickerCNP)
gameObj = self.gameObjects[pickedObj.getName()]
distToTarget = self.hero.getDistance(gameObj)
if self.combatMgr.checkCanAttack(self.hero, gameObj):
if distToTarget <= self.heroSpells[self.curSpellIndex].getAttackRange():
self.combatMgr.queueAttack(self.hero, self.heroSpells[self.curSpellIndex], gameObj)
else:
textObject = OnscreenText(text = 'The target is out of range!',fg =(1,0,0,1), pos = (0, 0), scale = 0.09, align = TextNode.ACenter )
def destroyWarning1():
textObject.destroy()
sequence =Sequence(Wait(2), Func(destroyWarning1))
sequence.start()
return
elif(distToTarget > CLICK_RANGE):
textObject = OnscreenText(text = 'The target is out of range!',fg =(1,0,0,1), pos = (0, 0), scale = 0.09, align = TextNode.ACenter )
def destroyWarning2():
textObject.destroy()
sequence =Sequence(Wait(2), Func(destroyWarning2))
sequence.start()
return
gameObj.callTrigger(self, 'LE-trigger-onClick')
# Task for processing hero's collisions with GameObjects, triggering OnCollision scripts
def processHeroCollisions(self, task):
#self.cTrav.traverse(render)
debug("processHeroCollisions")
# CONSIDER: may not be necessary to sort
if(self.heroCollisionQueue.getNumEntries() > 0):
self.heroCollisionQueue.sortEntries()
debug("queue size: "+str(self.heroCollisionQueue.getNumEntries()))
for i in range(self.heroCollisionQueue.getNumEntries()):
# CONSIDER: if entry.hasInto(): for efficiency
debug("i: "+str(i))
# TODO: check if GameObject is passable, and react accordingly (store old position, revert to it)
if(self.heroCollisionQueue.getNumEntries() <= 0):
return
entry = self.heroCollisionQueue.getEntry(i)
debug("entry: "+str(entry))
if(entry):
intoNP = entry.getIntoNodePath()
else:
continue
if (intoNP != None) or (not intoNP.isEmpty()):
while not self.objects.has_key(intoNP.getName()):
if(intoNP.getName() == "render"):
return task.cont
intoNP = intoNP.getParent()
pickedObj = intoNP
if pickedObj == None:
continue
gameObj = self.gameObjects[pickedObj.getName()]
gameObj.callTrigger(self, 'LE-trigger-onCollision')
return task.cont
##== Camera Movement ========================================================##
# places the camera pivot to match the position of the node path parameter
# used to have the camera pivot match the main character's position as he moves
def placeCamera(self, np):
self.camPivot.setX(render, np.getX(render))
self.camPivot.setY(render, np.getY(render))
def alignCamera(self, np):
self.camPivot.setH(render, self.hero.getH(render) + self.heroHeadingOffset)
self.cam.setP(CAMERA_PITCH)
def cameraFollowTask(self, task):
heroH = self.hero.getH(render) + self.heroHeadingOffset
camPivotH = self.camPivot.getH(render)
# normalizes the headings to avoid jumps in the difference
# which could come from passing 360 and going back to 0, for example
# TODO: stress test, esp. with different values of self.heroHeadingOffset
while heroH + 180 < camPivotH:
heroH += 360
while camPivotH + 180 < heroH:
camPivotH += 360
self.lastHeroH = heroH
rotateLeft = (heroH >= camPivotH)
rotateRight = not rotateLeft
diff = math.fabs(heroH - camPivotH)
if diff > CAMERA_TURN_THRESHOLD:
if rotateLeft:
self.camPivot.setH(self.camPivot.getH() + CAMERA_TURN_SPEED)
elif rotateRight:
self.camPivot.setH(self.camPivot.getH() - CAMERA_TURN_SPEED)
# if(len(self.cameraEntriesPre)>0):
# #print self.cameraEntriesPre
# if(self.hero.getDistance(self.cam) > 5):
# moveAmount = min(globalClock.getDt()*200,5.0)
# pos = self.cam.getQuat().getForward()*moveAmount
# newpos = self.cam.getPos() + pos
# self.oldCameraEntriesPre = []
# for e in self.cameraEntriesPre:
# self.oldCameraEntriesPre.append(e)
# self.cam.setFluidPos(newpos)
#
# else:
# if(self.hero.getDistance(self.cam) < 100):
# moveAmount = min(globalClock.getDt()*200,5.0)
# pos = self.cam.getQuat().getForward()*(-moveAmount)
# oldpos = self.cam.getPos()
# newpos = self.cam.getPos() + pos
# self.cam.setFluidPos(newpos)
# for e in self.oldCameraEntriesPre:
# #print e.getIntoNodePath()
# self.cTrav.traverse(e.getIntoNodePath())
# #self.cTrav.traverse(render)
# if(len(self.cameraSphereQueue.getEntries())>0):
# self.cam.setFluidPos(oldpos)
return task.cont
def runCamera(self, cameraName, sequence, isLoop = False):
debug("Running the camera")
#debug(str(self.sequences))
self.oldCamera = self.cam
self.dr = self.win.makeDisplayRegion()
dr2 = self.cam.node().getDisplayRegion(0)#
self.objects[cameraName].node().setLens(base.camLens)
parent = self.cam.getParent()
self.cam.detachNode()
self.dr.setCamera(self.objects[cameraName])
def temp():
dr2.setCamera(self.oldCamera)
self.oldCamera.reparentTo(parent)
self.dr.setActive(False)
del self.dr
self.dr = None
self.accept("mouse1", self.onClickin3D)
debug("Ran")
if(isLoop):
newSequence = Sequence(sequence)
self.addSequence(newSequence)
def stopCameraFromLoop():
newSequence.finish()
temp()
self.accept("mouse1", stopCameraFromLoop)
self.addSequence(newSequence)
newSequence.loop()
else:
newSequence = Sequence(sequence,Func(temp))
def stopCamera():
newSequence.finish()
self.accept("mouse1", stopCamera)
self.addSequence(newSequence)
newSequence.start()
##== Character Movement =====================================================##
def moveHeroTo(self, destinationObj):
pos = destinationObj.getPos(render)
hpr = destinationObj.getHpr(render)
self.hero.setPosHpr(render, pos, hpr)
self.placeCamera(self.hero)
self.alignCamera(self.hero)
def updateHeroHeight(self, task=None):
groundEntries = []
#move the collision line to the hero position
self.heroGroundCollide.setPos(self.hero.getPos(render))
#loop through every collision entry for the line
for e in self.heroGroundHandler.getEntries():
if e.getIntoNodePath().hasNetTag('OBJRoot'):
#find the actual root of the object
np = e.getIntoNodePath().findNetTag('OBJRoot')
#only react to objects that are tagged as the ground
if np.hasTag('LE-ground'):
groundEntries.append(e)
if groundEntries:
#sort the collision entries based on height
groundEntries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(),\
x.getSurfacePoint(render).getZ()))
#set hero height and pivot height
self.hero.setZ(groundEntries[0].getSurfacePoint(render).getZ() + MAIN_CHAR_GROUND_OFFSET)
self.camPivot.setZ(groundEntries[0].getSurfacePoint(render).getZ() + MAIN_CHAR_GROUND_OFFSET)
# TODO: unlink these from being in the same task in case we want pivot to not be linked to hero (ex. cutscene)
self.heroGroundHandler.clearEntries()
return task.cont
def updateHeroPos(self, queue, stepSize):
wallEntries = []
for w in queue.getEntries():
np = w.getIntoNodePath().findNetTag('OBJRoot')
if np.hasTag('LE-wall'):
if self.isInObstacleRange(self.hero, w, stepSize):
wallEntries.append(w)
if len(wallEntries) > 0:
self.herowallcollision = True
#self.collisionsurfaceP = wallEntries[0].getSurfacePoint(render)
else:
self.herowallcollision = False
def updateCameraCollision(self):
self.cameraHeroLine.setPointA(self.cam.getPos(render))
self.cameraHeroLine.setPointB(self.hero.getPos(render))
if(self.cameraEntriesPre):
for i in self.cameraEntriesPre:
i.getIntoNodePath().setTransparency(TransparencyAttrib.MAlpha)
i.getIntoNodePath().setAlphaScale(1.0)
del self.cameraEntriesPre[:]
for i in self.cameraCollisionQueue.getEntries():
i.getIntoNodePath().setAlphaScale(0.5)
self.cameraEntriesPre.append(i)
def moveHero(self,direction, dt):
temp = render.attachNewNode("Dummy")#NodePath()
moveStep = MAIN_CHAR_MOVE_SPEED*dt
if moveStep > MAIN_CHAR_MAX_STEP:
moveStep = MAIN_CHAR_MAX_STEP
temp.setPos(self.camPivot, 0,direction*moveStep, 0)
#oldPos = self.heroWallCollideX.getPos()
self.heroWallCollideX.setX(temp.getX())
self.heroWallCollideY.setY(temp.getY())
self.heroWallCollideZ.setZ(temp.getZ())#+10)
self.cTrav.traverse(render)
#check on X direction
self.updateHeroPos(self.heroWallQueueX, moveStep)
self.moveHeroToWallCollide(Point3(temp.getX(),self.hero.getY(),self.hero.getZ()))
#check on Y direction
self.updateHeroPos(self.heroWallQueueY, moveStep)
self.moveHeroToWallCollide(Point3(self.hero.getX(),temp.getY(),self.hero.getZ()))
#check on Z direction
self.updateHeroPos(self.heroWallQueueZ, moveStep)
self.moveHeroToWallCollide(Point3(self.hero.getX(),self.hero.getY(),temp.getZ()))
self.heroWallCollideX.setPos(self.hero.getPos())
self.heroWallCollideY.setPos(self.hero.getPos())
self.heroWallCollideZ.setPos(self.hero.getPos())
self.placeCamera(self.hero)
self.updateCameraCollision()
temp.detachNode()
def moveHeroToWallCollide(self,pos):
if self.herowallcollision==False:
self.hero.setPos(pos)#self.camPivot, 0, MAIN_CHAR_MOVE_SPEED, 0)
def isInObstacleRange(self, mover, colEntry, stepSize):
colPoint = colEntry.getSurfacePoint(render)
if colPoint[2] >= mover.getZ(render):
dist = findDistance3D(mover.getX(), mover.getY(), mover.getZ(), colPoint[0], colPoint[1], colPoint[2])
obstacleThreshold = self.heroHeight*self.heroHeight + stepSize*stepSize
if dist*dist <= obstacleThreshold:
return True
return False
def turnHeroLeft(self):
up = render.getRelativeVector(base.cam, Vec3(0, 0, 1))
up.normalize()
curHeroQuat = self.hero.getQuat()
newHeroQuat = Quat()
newHeroQuat.setFromAxisAngle(MAIN_CHAR_ROTATE_SPEED, up)
self.hero.setQuat(curHeroQuat*newHeroQuat)
self.hero.setR(0)
self.hero.setP(0)
self.updateCameraCollision()
def turnHeroRight(self):
up = render.getRelativeVector(base.cam, Vec3(0, 0, 1))
up.normalize()
curHeroQuat = self.hero.getQuat()
newHeroQuat = Quat()
newHeroQuat.setFromAxisAngle(-MAIN_CHAR_ROTATE_SPEED, up)
self.hero.setQuat(curHeroQuat*newHeroQuat)
self.hero.setR(0)
self.hero.setP(0)
self.updateCameraCollision()
def disableMovement(self, gameObj):
if gameObj.getName() == self.hero.getName():
self.ignore('w')
self.ignore('w-up')
self.ignore('a')
self.ignore('a-up')
self.ignore('s')
self.ignore('s-up')
self.ignore('d')
self.ignore('d-up')
else:
if gameObj.getAIBehaviorsHandle().behaviorStatus('pursue') != -1:
gameObj.getAIBehaviorsHandle().pauseAi('pursue')
def enableMovement(self, gameObj):
if gameObj.getName() == self.hero.getName():
self.accept('w', self.setKeyStatus, extraArgs=['w', True])
self.accept('w-up', self.setKeyStatus, extraArgs=['w', False])
self.accept('a', self.setKeyStatus, extraArgs=['a', True])
self.accept('a-up', self.setKeyStatus, extraArgs=['a', False])
self.accept('s', self.setKeyStatus, extraArgs=['s', True])
self.accept('s-up', self.setKeyStatus, extraArgs=['s', False])
self.accept('d', self.setKeyStatus, extraArgs=['d', True])
self.accept('d-up', self.setKeyStatus, extraArgs=['d', False])
else:
if gameObj.getAIBehaviorsHandle().behaviorStatus('pursue') == 'paused':
gameObj.getAIBehaviorsHandle().resumeAi('pursue')
def setKeyStatus(self, key, isDown):
self.keyMap[key] = isDown
print self.hero.getName()
######################################################################
## # ZJC - 07/29/2011: THIS CODE WAS COMMENTED OUT BECAUSE A MORE EFFICIENT WAY WAS FOUND
##
## prefixList = []
## #NEXT LINE- ZJC - 07/29/2011: This line is used to mark where to import the array used to deal with import flags.
## #LoaderFlagImportArray
## name = self.hero.getName().split('_')[0] # ZJC - 07/29/2011: name is assumed to be formatted NAME_otherstuff
## name2 = self.hero.getName().split('_')[1] # ZJC - 07/29/2011: name2 is assumed to be PREFIX_NAME_otherstuff
## if name in prefixList: # ZJC - 07/29/2011: Checks if the name is in the array, if it is name is not formatted as assumed
## name = name2 # ZJC - 07/29/2011: Use the second format if the first name is in the list
## print name
######################################################################
name = self.hero.getName().split('_')[0] # ZJC - 07/29/2011: Assumes format is Name_mod:#
## print name
for i in range(len(self.here.getName().split('_'))): # ZJC - 07/29/2011: Loop will check every possibility in the name string for any level of merges/imports
name2 = self.hero.getName().split('_')[i] # ZJC - 07/29/2011: name2 holds the current piece of the name string
if ("mod:" in name2) and (name != name2): # ZJC - 07/29/2011: This means the name format is Prefix(es)_Name_mod:#
name = self.hero.getName().split('_')[i-1] # ZJC - 07/29/2011: Assigns correct model name, the one just before mod:#
if isDown:
if key == 'w':
if self.hero.getActorHandle() != None:
self.hero.getActorHandle().stop(name + '_ani_idle') # ZJC - 07/26/2011: Stop the 'name' specific idle animation
self.hero.getActorHandle().setPlayRate(1.0, name + '_ani_run') # ZJC - 07/26/2011: Set play rate for the 'name' specific run animation
self.hero.getActorHandle().loop(name + '_ani_run') # ZJC - 07/26/2011: Run the 'name' specific run animation
self.keyMap['s'] = False
elif key == 's':
if self.hero.getActorHandle() != None:
self.hero.getActorHandle().stop(name + '_ani_idle') # ZJC - 07/26/2011: Stop the 'name' specific idle animation
self.hero.getActorHandle().setPlayRate(-0.7, name + '_ani_run') # ZJC - 07/26/2011: Set play rate for the 'name' specific run animation
self.hero.getActorHandle().loop(name + '_ani_run') # ZJC - 07/26/2011: Run the 'name' specific run animation
self.keyMap['w'] = False
elif key == 'a':
self.keyMap['d'] = False
elif key == 'd':
self.keyMap['a'] = False
elif not isDown:
if key == 'w':
if not self.keyMap['s']:
if self.hero.getActorHandle() != None:
self.hero.getActorHandle().stop(name + '_ani_run') # ZJC - 07/26/2011: Stop the 'name' specific run animation
self.hero.getActorHandle().loop(name + '_ani_idle') # ZJC - 07/26/2011: Run the 'name' specific idle animation
elif key == 's':
if not self.keyMap['w']:
if self.hero.getActorHandle() != None:
self.hero.getActorHandle().stop(name + '_ani_run') # ZJC - 07/26/2011: Stop the 'name' specific run animation
self.hero.getActorHandle().loop(name + '_ani_idle') # ZJC - 07/26/2011: Run the 'name' specific idle animation
elif key == 'a':
pass
elif key == 'd':
pass
## ZJC - 07/26/2011: This was the previous version of the code, it has been commented out and left as
## a reference. The changes made are defined in the comments above.
## if isDown:
## if key == 'w':
## if self.hero.getActorHandle() != None:
## self.hero.getActorHandle().stop('anim_idleFemale') # TODO: make a constant / set in LE
## self.hero.getActorHandle().setPlayRate(1.0, 'anim_jogFemale')
## self.hero.getActorHandle().loop('anim_jogFemale')
## self.keyMap['s'] = False
## elif key == 's':
## if self.hero.getActorHandle() != None:
## self.hero.getActorHandle().stop('anim_idleFemale') # TODO: make a constant / set in LE
## self.hero.getActorHandle().setPlayRate(-0.7, 'anim_jogFemale')
## self.hero.getActorHandle().loop('anim_jogFemale')
## self.keyMap['w'] = False
## elif key == 'a':
## self.keyMap['d'] = False
## elif key == 'd':
## self.keyMap['a'] = False
## elif not isDown:
## if key == 'w':
## if not self.keyMap['s']:
## if self.hero.getActorHandle() != None:
## self.hero.getActorHandle().stop('anim_jogFemale')
## self.hero.getActorHandle().loop('anim_idleFemale')
## elif key == 's':
## if not self.keyMap['w']:
## if self.hero.getActorHandle() != None:
## self.hero.getActorHandle().stop('anim_jogFemale')
## self.hero.getActorHandle().loop('anim_idleFemale')
## elif key == 'a':
## pass
## elif key == 'd':
## pass
def moveHeroTask(self, task):
dt = globalClock.getDt()
direction = int(self.keyMap['w'])-int(self.keyMap['s'])
self.moveHero(direction, dt)
if self.keyMap['a']:
self.turnHeroLeft()
elif self.keyMap['d']:
self.turnHeroRight()
return task.cont
##== Scene Handling =========================================================##
def loadScenes(self):
# NOTE: Do not remove! This function is populated by StandaloneExporter
pass
def addSequence(self, sequence):
self.ranSequences.append(sequence)
#this is for changing scenes
def resetAllSequences(self):
for seq in self.ranSequences:
seq.finish()
dr = self.cam.node().getDisplayRegion(0)
dr.setCamera(self.gameCam)
self.ranSequences = []
def openScene(self, sceneName):
if (self.scenes.has_key(sceneName)==False):
print "ERROR:There is no scene under the name ", sceneName,"."
return
self.startLoadBar(12)
self.createLoadScreen()
#Part2:Clear all of the collision lists
self.cTrav.removeCollider(self.heroCNP)
self.heroGroundHandler.clearEntries()
self.heroCollisionQueue.clearEntries()
self.resetAllSequences()
self.increaseLoadBar(1)
#Part3: stop all of the tasks
taskMgr.remove('processHeroCollisions')
taskMgr.remove('updateHeroHeight')
taskMgr.remove('moveHeroTask')
taskMgr.remove('cameraFollowTask')
taskMgr.remove("updateShaders") # ?
self.combatMgr.stopTasks()
self.gameplayUI.stop()
self.gameplayUI.removeAllHealthBars()
self.increaseLoadBar(1)
#Part1.1: Stop currently running parts like conversations or camera
if(self.conversationMgr.isConversationOpen()):
self.conversationMgr.closeConversation()
#Part 1.2: stop the camera
self.increaseLoadBar(1)
#Part4: Turn-Off all of the player controls
self.ignore("mouse1")
self.increaseLoadBar(1)
#Part5: Remove all of the game elements that are related with the current scene
del self.combatMgr
self.increaseLoadBar(1)
#Part6: Remove all of the children and the lights from the render
render.getChildren().detach()
render.clearLight()
self.increaseLoadBar(1)
#Part7:Add the camera and hero or any game element that should be exist in any scene back
self.camPivot.reparentTo(render)
self.hero.reparentTo(render)
#self.heroWallCollide.reparentTo(render)
self.heroWallCollideX.reparentTo(render)
self.heroWallCollideY.reparentTo(render)
self.heroWallCollideZ.reparentTo(render)
self.heroGroundCollide.reparentTo(render)
self.cameraHeroP.reparentTo(render)
self.overlayAmbientLightNP.reparentTo(render)
self.increaseLoadBar(1)
#Part8:Add the new objects from the new scene
self.assets, self.objects, self.gameObjects, self.sounds, self.sequences = loadWorld(self.scenes[sceneName], LIBRARY_INDEX)
self.increaseLoadBar(1)
#Part9:Add the hero to the new gameObject list and remove the duplicates of the hero
self.gameObjects[self.hero.getName()] = self.hero
if(self.objects.has_key(self.hero.getName())):
object = self.objects[self.hero.getName()]
if(object.hasTag('LE-mainChar')):
object.detachNode()
del self.objects[self.hero.getName()]
for name, gameObj in self.gameObjects.iteritems():
if gameObj.getNP().hasTag('LE-ground'):
#debug("is Ground")
bitmask = gameObj.getNP().getCollideMask()
bitmask |= BITMASK_GROUND
gameObj.getNP().setCollideMask(bitmask)
self.increaseLoadBar(1)
#Part10:Restart the tasks.
self.combatMgr = CombatMgr(self)
taskMgr.add(self.processHeroCollisions, 'processHeroCollisions')
taskMgr.add(self.updateHeroHeight, 'updateHeroHeight')
taskMgr.add(self.moveHeroTask, 'moveHeroTask')
taskMgr.add(self.cameraFollowTask, 'cameraFollowTask')
self.combatMgr.startTasks()
self.gameplayUI.start()
self.increaseLoadBar(1)
self.setCollideMasks(self.gameObjects)
self.increaseLoadBar(1)
#Part11: Change the color of the sky
if(sceneName.startswith("interior") or sceneName.startswith("Interior")):
self.setBackgroundColor(BGC_DARK_GREY)
else:
self.skybox.reparentTo(render)
self.setBackgroundColor(BGC_LIGHT_BLUE)
self.increaseLoadBar(1)
#Part12: Restart the player controls
self.accept("mouse1", self.onClickin3D)
self.increaseLoadBar(1)
self.accept("enter",self.destroyLoadScreen)
debug("After open Scene: "+str(self.heroCollisionQueue.getNumEntries()))
self.heroCollisionQueue.clearEntries()
self.cTrav.addCollider(self.heroCNP, self.heroCollisionQueue)
self.destroyLoadScreen()
def __init__(self):
super().__init__(self)
self.scene = loader.loadModel("models/world")
self.player = self.scene.find("player")
self.basePlane = self.scene.find("basePlane")
self.player.reparentTo(self.render)
self.basePlane.reparentTo(self.render)
self.scene.remove_node()
self.taskMgr.add(self.update, "update")
self.camera.setPos(self.render, 0, -100, 70)
base.setBackgroundColor(0.1, 0.1, 0.1, 1)
self.dirLight = DirectionalLight("dir light")
self.dirLight.setShadowCaster(True, 512, 512)
self.dirLight.color = (1, 0, 1, 1)
self.dirLightPath = self.render.attachNewNode(self.dirLight)
self.dirLightPath.setHpr(45, -60, 0)
render.setLight(self.dirLightPath)
self.angleTime = 0.0
self.totalAngleTime = 10.0
self.hAngle = 0
self.ambientLight = AmbientLight("ambient")
self.ambientLight.color = (0.1, 0.1, 0.1, 1)
self.ambLightPath = self.render.attachNewNode(self.ambientLight)
render.setLight(self.ambLightPath)
self.pointLight = PointLight("point")
self.pointLight.color = (1, 1, 1, 1)
self.pointLightPath = self.render.attachNewNode(self.pointLight)
self.pointLightPath.setPos(0, 5, 5)
self.pointLight.setShadowCaster(True, 512, 512)
self.render.setLight(self.pointLightPath)
self.fog = Fog("fog")
self.fog.setColor(.1, .1, .1)
self.fog.setExpDensity(.3)
self.fog.setLinearRange(150, 200)
self.fog.setLinearFallback(45, 160, 320)
render.setFog(self.fog)
self.render.setShaderAuto()
self.p = self.render.attachNewNode("particles")
base.enableParticles()
p = ParticleEffect()
p.loadConfig('./mysmoke.ptf')
p.start(parent=self.p, renderParent=render)
self.p.setPos(self.player, 0, 0, 2)
self.font = loader.loadFont('./fonts/Magenta.ttf')
self.sceneName = DirectLabel(text="Starfox visual test",
parent=self.aspect2d,
scale=0.07,
pos=(-1.2, 0, 0.85),
text_font=self.font,
relief=None,
text_fg=(1, 1, 1, 1),
textMayChange=True,
text_align=TextNode.ALeft)
self.foxy = OnscreenImage(image='./UI/fox-icon-png-8.png',
pos=(1.2, 9, 0.85),
scale=0.1)
self.foxy.setTransparency(True)
self.controlsPanel = DirectDialog(frameSize=(-1.1, 1.1, -0.9, -0.7),
relief=DGG.FLAT)
btn = DirectButton(text="Rotate",
command=self.doRotate,
image='./UI/fox-icon-png-8.png',
pos=(-0.9, 0, -0.8),
parent=self.controlsPanel,
scale=0.07,
relief=None)
btn2 = DirectButton(text="Anin Light",
command=self.doLight,
image='./UI/fox-icon-png-8.png',
pos=(-0.7, 0, -0.8),
parent=self.controlsPanel,
scale=0.07,
relief=None)
self.camera.lookAt(self.player)
self.makeRotation = False
self.rotateAngles = 0
self.animLight = False
filter = CommonFilters(base.win, base.cam)
filter.setBloom(size="large", intensity=2)
#filter.setAmbientOcclusion(strength = 5, radius = 3)
filter.setCartoonInk(separation=4)
class Game(State):
mapOffset = {"up": (0,1), "down": (0,-1), "left": (-1,0), "right": (1,0)}
def __init__(self, stage, characters, player, player2):
State.__init__(self)
# how to know the players that will be in game? a ChoosePlayer screen before the constructor?
self.characters = characters
self.player = player
self.player2 = player2
self.stage = stage
self.room = self.stage.start
self.isOver = False
self.players = []
#print(self.players)
self.startMap()
self.status = {}
posi = 0
for c in self.characters:
# initialize character status string
self.status[c] = (OnscreenText(mayChange= True ,
style=2, fg=(1,1,1,1),
pos=(1.4*posi - 0.8,-0.83), scale = .07)
)
posi += 1
self.transitions = Transitions(GameLoader.loader)
self.clock = ClockObject()
self.lastTime = 0
GameLoader.music.addSfx('barrel_breaks')
GameLoader.music.addSfx('stone','aif')
def spawnObject(self, ob):
ob.setMap(self.currentMap())
ob.getNode().reparentTo(NodePath(self.currentMap().getNode()))
x,y = self.currentMap().posToGrid(ob.getPos())
if ob.symbol == 'i':
GameLoader.music.addSfx(ob.sfx)
try:
self.currentMap().tiles[Map.COLLISION][y][x] = ob.symbol
except IndexError as e:
print('Index error: ' , ob.id, e )
def currentMap(self):
return self.stage.maps[self.room]
def exitMap(self):
for i in range(self.currentMap().width):
for j in range(self.currentMap().height):
atype = self.currentMap().tileType(1,(i,j))
if atype == 'block' or atype == 'liftable':
self.currentMap().tiles[1][j][i] = ' '
for b in self.currentMap().blocks:
b.setPos(b.originalPos)
x,y = self.currentMap().posToGrid(b.getPos())
self.currentMap().tiles[Map.COLLISION][y][x] = 'b'
b.getNode().reparentTo(NodePath(self.currentMap().getNode()))
for b in self.currentMap().liftables:
b.setPos(b.originalPos)
x,y = self.currentMap().posToGrid(b.getPos())
self.currentMap().tiles[Map.COLLISION][y][x] = 'l'
b.getNode().reparentTo(NodePath(self.currentMap().getNode()))
for d in self.currentMap().doors:
if d.permanent:
x,y = self.currentMap().posToGrid(d.getPos())
self.currentMap().tiles[Map.COLLISION][y][x] = 'd'
d.getNode().reparentTo(NodePath(self.currentMap().getNode()))
for char in [self.characters[self.player], self.characters[self.player2]]:
char.lifting = None
NodePath(self.currentMap().getNode()).detachNode()
def startMap(self):
if not self.currentMap().started:
for obstacle in self.currentMap().obstacles:
self.spawnObject(obstacle)
for item in self.currentMap().items:
self.spawnObject(item)
for block in self.currentMap().blocks:
self.spawnObject(block)
for liftable in self.currentMap().liftables:
self.spawnObject(liftable)
for switch in self.currentMap().switches:
switch.getNode().reparentTo(NodePath(self.currentMap().getNode()))
for door in self.currentMap().doors:
self.spawnObject(door)
self.currentMap().started = True
for e in self.currentMap().enemies:
self.spawnObject(e)
self.characters[self.player].setMap(self.currentMap())
self.characters[self.player2].setMap(self.currentMap())
def changeMap(self,direction,char):
self.transitions.fadeOut(1)
self.transitions.fadeIn(2)
#TODO modularize for more characters
self.exitMap()
self.room = self.stage.doors[self.room][direction]
NodePath(self.currentMap().getNode()).reparentTo(self.node)
map = self.stage.maps[self.room]
x, y = self.currentMap().posToGrid(char.getPos())
if direction == "right": x = 1
elif direction == "left": x = map.width-2
elif direction == "down": y = 1
elif direction == "up": y = map.height-2
pos = self.currentMap().gridToPos((x,y))
self.characters[self.player].setPos(pos)
self.characters[self.player2].setPos(pos)
self.characters[self.player2].setDirection(self.characters[self.player].direction)
self.startMap()
def register(self, render, camera, keys, render2d):
State.register(self, render, camera, keys, render2d)
self.node.attachNewNode(self.stage.maps[self.room].getNode())
for c in self.characters:
self.status[c].reparentTo(self.node2d)
for char in self.characters.values():
char.getNode().reparentTo(self.node)
char.stunRender = self.node
for l in self.stage.getLights():
render.setLight(l)
# COWABUNGA test!!!
self.hearts = {}
numChar=0
self.heartsNode = NodePath(PandaNode('hearts'))
self.heartsNode.reparentTo(self.node2d)
for char in self.characters:
self.hearts[char] = []
for i in range(Character.maxHearts):
self.hearts[char].append(Sprite("heart.png", 0.05, 0.05))
self.hearts[char][i].setPos(-0.8 + 1.4*numChar + (i%3)*0.055 , -0.9 - int(i/3)*0.055)
self.hearts[char][i].getNode().reparentTo(self.heartsNode)
numChar += 1
#COWABUNGA comment this to stop the madness
render.setAttrib(LightRampAttrib.makeSingleThreshold(0.1, 1))
# THE TRUE CARTOON SHADER :P
# self.separation = 1 # Pixels
self.filters = CommonFilters(base.win, self.camera.camera)
# cell shading
# filterok = self.filters.setCartoonInk(separation=self.separation)
# glow
filterok = self.filters.setBloom(blend=(0.5,0.5,0.5,1), desat=-0.5, intensity=0.5, size="small")
self.camera.setPos(0, -2.5, -2.5)
self.camera.lookAt(0, 0, 0)
def iterate(self):
State.iterate(self)
self.camera.look()
self.moveObjects()
self.doCharActions()
self.moveChars()
self.buryDeadPeople()
self.activateSwitches()
self.updateHUD()
for c in self.characters:
self.characters[c].tryToRecover()
if self.isOver:
return "GameOver"
elif self.keys['start']:
return "Paused"
def updateHUD(self):
for c in self.characters:
self.status[c].setText(self.characters[c].getStatus())
if self.characters[c].healthChanged:
for heart in self.hearts[c]:
heart.getNode().detachNode()
for i in range(self.characters[c].hearts):
self.hearts[c][i].getNode().reparentTo(self.heartsNode)
self.characters[c].healthChanged = False
def moveObjects(self):
# BLOCK MOVEMENT ACTION
for block in self.currentMap().blocks:
if block.isMoving:
block.move(block.direction)
p1, p2 = block.getCollisionPos(block.direction)
x1, y1 = self.currentMap().posToGrid(p1)
x2, y2 = self.currentMap().posToGrid(p2)
try:
for x,y in [(x1,y1), (x2,y2)]:
if self.stage.maps[self.room].tileType(1, (x,y)) == 'enemy':
for enemy in self.currentMap().enemies:
lPos = self.currentMap().posToGrid(enemy.getPos())
if tuple(lPos) == (x,y):
self.collision(block, enemy)
else:
for char in self.characters:
if (x,y) == self.currentMap().posToGrid(self.characters[char].getPos()):
bx,by = self.currentMap().posToGrid(block.getPos())
self.currentMap().tiles[Map.COLLISION][by][bx] = ' '
self.characters[char].stun()
block.stop()
block.getNode().detachNode()
except IndexError:
block.stop()
# LIFTABLE MOVEMENT ACTION
for liftable in self.currentMap().liftables:
if liftable.isMoving:
liftable.move(liftable.direction)
p1, p2 = liftable.getCollisionPos(liftable.direction)
x1, y1 = self.currentMap().posToGrid(p1)
x2, y2 = self.currentMap().posToGrid(p2)
try:
for x,y in [(x1,y1), (x2,y2)]:
if self.stage.maps[self.room].tileType(1, (x,y)) == 'enemy':
for enemy in self.currentMap().enemies:
lPos = self.currentMap().posToGrid(enemy.getPos())
if tuple(lPos) == (x,y):
self.collision(liftable, enemy)
elif self.stage.maps[self.room].tileType(1, (x,y)) != 'free':
liftable.stop()
liftable.getNode().detachNode()
else:
for char in self.characters:
if (x,y) == self.currentMap().posToGrid(self.characters[char].getPos()):
print "Stun nele!"
self.characters[char].stun()
liftable.stop()
liftable.getNode().detachNode()
except IndexError:
# to do, create a liftable.destroy(), which animates the liftable and do these two actions:
liftable.stop()
liftable.getNode().detachNode()
def doCharActions(self):
for char in [self.characters[self.player], self.characters[self.player2]]:
add = "1"
if char == self.characters[self.player]:
add = ""
if self.keys['attack'+add]:
self.keys['attack'+add] = False
print('Using %s' % (char.currentItem()) )
p1, p2 = char.getCollisionPos(char.direction)
x1, y1 = self.currentMap().posToGrid(p1)
x2, y2 = self.currentMap().posToGrid(p2)
for x,y in [(x1,y1), (x2,y2)]:
if self.stage.maps[self.room].tileType(Map.COLLISION, (x,y)) == 'door':
for d in self.currentMap().doors:
if tuple(self.currentMap().posToGrid(d.getPos())) == (x,y):
opened = d.open(char.currentItem())
if opened:
self.currentMap().tiles[Map.COLLISION][y][x] = ' '
char.destroyCurrentItem()
if self.keys['cancel'+add]:
self.keys['cancel'+add] = False
print('Changing slot')
char.changeSlot()
if self.keys['action'+add]:
self.keys['action'+add] = False
if char.lifting:
char.lifting.setHeight(0)
char.lifting.move(char.direction)
char.lifting = None
else:
p1, p2 = char.getCollisionPos(char.direction)
x1, y1 = self.currentMap().posToGrid(p1)
x2, y2 = self.currentMap().posToGrid(p2)
for x,y in [(x1,y1), (x2,y2)]:
if self.stage.maps[self.room].tileType(Map.COLLISION, (x,y)) == 'block':
for block in self.currentMap().blocks:
if tuple(self.currentMap().posToGrid(block.getPos())) == (x,y):
GameLoader.music.playSfx('stone')
block.move(char.direction)
elif self.stage.maps[self.room].tileType(Map.COLLISION, (x,y)) == 'item':
for item in self.currentMap().items:
if tuple(self.currentMap().posToGrid(item.getPos())) == (x,y):
self.collision(char, item)
elif self.currentMap().tileType(Map.COLLISION, (x,y)) == 'liftable':
for liftable in self.currentMap().liftables:
lPos = self.currentMap().posToGrid(liftable.getPos())
if tuple(lPos) == (x,y):
char.pick(liftable)
self.currentMap().tiles[1][y][x] = ' '
def moveChars(self):
for char in [self.characters[self.player], self.characters[self.player2]]:
add = "1"
if char == self.characters[self.player]:
add = ""
directions = [key for key in ["up","down","left","right"] if self.keys[key+add]]
if len(directions) == 0:
char.stop()
for dir in directions:
#TODO to be re-refactored
p1, p2 = char.getCollisionPos(dir)
if self.currentMap().futPosAreFree(p1, p2):
char.move(dir)
if char.lifting:
char.lifting.setPos(char.getPos())
ex = self.stage.maps[self.room].getExit(self.currentMap().posToGrid(p1))
if ex and (ex in self.stage.doors[self.room].keys()):
self.changeMap(ex,char)
else:
char.setDirection(dir)
for enemy in self.currentMap().enemies:
#TODO actually enemies are still present in the map
x,y = self.currentMap().posToGrid(enemy.getPos())
self.currentMap().tiles[Map.COLLISION][y][x] = ' '
# COWABUNGA
# se botarmos aqui uma funcao que define como o inimigo anda
# vai dar tudo certo
# por exemplo ele pode as vezes andar em direcao a um heroi e
# as vezes ser random
# por enquanto e so random
# - OK, agreed
dir = ['up','down','left','right'][random.randint(0,3)]
p1, p2 = enemy.getCollisionPos(dir)
if self.currentMap().futPosAreFree(p1, p2):
enemy.enemy_move(dir)
else:
enemy.setDirection(dir)
x,y = self.currentMap().posToGrid(enemy.getPos())
self.currentMap().tiles[Map.COLLISION][y][x] = 'e'
p1, p2 = char.getCollisionPos(char.direction)
x1, y1 = self.currentMap().posToGrid(p1)
x2, y2 = self.currentMap().posToGrid(p2)
for x,y in [(x1,y1), (x2,y2)]:
collisionTiles = ["enemy"]
collisionElements = {"enemy": self.currentMap().enemies}
for t in collisionTiles:
if self.stage.maps[self.room].tileType(Map.COLLISION, (x,y)) == t:
for e in collisionElements[t]:
lPos = self.currentMap().posToGrid(e.getPos())
if tuple(lPos) == (x,y):
self.collision(char, e)
def activateSwitches(self):
mp = self.currentMap()
for s in mp.switches:
x,y = mp.posToGrid(s.getPos())
charPos = [self.currentMap().posToGrid(self.characters[char].getPos()) for char in self.characters]
if mp.tiles[Map.COLLISION][y][x] != ' ' or ((x,y) in charPos):
#print 'activated!'
mp.tiles[Map.GROUND][y][x] = 'S'
s.activate()
else:
#print 'deactivated!'
mp.tiles[Map.GROUND][y][x] = 's'
s.deactivate()
for d in mp.doors:
openDoor = True
if d.openWith == "switches":
for ds in d.switches:
for ms in mp.switches:
if (ds == ms.name) and (not ms.active):
openDoor = False
break
if openDoor:
d.open("switches")
x,y = mp.posToGrid(d.getPos())
mp.tiles[Map.COLLISION][y][x] = ' '
def collision(self, a, b):
print "Collision: TYPE A:", a.getType(), "TYPE B:", b.getType()
if b.getType() == 'item':
for i in range(len(self.currentMap().items)):
if i < len(self.currentMap().items): #we need this because the size of the list may change if we remove an item
if tuple(self.currentMap().items[i].getPos()) == tuple(b.getPos()):
# removes the item
self.currentMap().items.pop(i)
x, y = self.currentMap().posToGrid((NodePath(b.getNode()).getX(), NodePath(b.getNode()).getZ()))
# it's not drawed anymore
self.currentMap().tiles[Map.COLLISION][y][x] = ' '
NodePath(b.getNode()).detachNode()
#it's picked
oldItem = a.pickItem(b)
if oldItem != None:
print oldItem.name
oldItem.setPos(self.currentMap().gridToPos((x,y)))
oldItem.originalPos = oldItem.getPos()
self.spawnObject(oldItem)
self.currentMap().items.append(oldItem)
if a.getType() == 'liftable' or b.getType() == 'liftable':
GameLoader.music.playSfx('barrel_breaks')
if a.getType() == 'liftable' and b.getType() == 'enemy':
a.stop()
a.getNode().detachNode()
x,y = self.currentMap().posToGrid(a.getPos()) #nao precisaria
self.currentMap().tiles[Map.COLLISION][y][x] = ' '
b.takeDamage(10000)
if not b.isAlive():
x, y = self.currentMap().posToGrid(b.getPos())
self.currentMap().tiles[Map.COLLISION][y][x] = ' '
NodePath(b.getNode()).removeNode()
self.currentMap().enemies.remove(b)
if a.getType() == 'block' and b.getType() == 'enemy':
a.stop()
a.getNode().detachNode()
x,y = self.currentMap().posToGrid(a.getPos())
self.currentMap().tiles[Map.COLLISION][y][x] = ' '
b.takeDamage(10000)
if not b.isAlive():
x, y = self.currentMap().posToGrid(b.getPos())
self.currentMap().tiles[Map.COLLISION][y][x] = ' '
NodePath(b.getNode()).removeNode()
self.currentMap().enemies.remove(b)
if a.getType() == 'Character':
print("Character collided with", b.getType())
if b.getType() == 'enemy':
a.takeDamage(1)
def buryDeadPeople(self):
# commented while fixing the bugs
for enemy in self.currentMap().enemies:
if not enemy.isAlive():
x, y = self.currentMap().posToGrid(enemy.getPos())
self.currentMap().tiles[Map.COLLISION][y][x] = ' '
NodePath(enemy.getNode()).removeNode()
self.currentMap().enemies.remove(enemy)
#if not self.player.isAlive() : #tratar isso corretamente!
for char in self.characters:
if not self.characters[char].isAlive():
self.isOver = True
def enter(self):
State.enter(self)
self.stage.playMusic()
def exit(self):
# self.transitions.fadeOut(2)
# self.transitions.fadeIn(3)
# self.transitions.noFade()
self.stage.stopMusic()
# self.heartsNode.removeNode()
# for c in self.characters:
# NodePath(self.characters[c].getNode()).removeNode()
# self.status[c].removeNode()
# NodePath(self.currentMap().getNode()).removeNode()
State.exit(self)
class MyApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.useAdvancedVisualEffects =\
ConfigVariableBool("use-advanced-visual-effects", True) and\
base.win.getGsg().getSupportsBasicShaders() and\
base.win.getGsg().getSupportsGlsl() and\
base.win.getGsg().getSupportsDepthTexture()
self.debug = DirectNotify().newCategory("Debug")
self.phoneState = PhoneState(self)
self.setupFilters()
self.setupModels()
self.setupKeyboardControl()
self.camera.setPos(0, 0, 2)
self.setupMouseControl()
self.phoneState.request("Hidden")
def setupFilters(self):
if (self.useAdvancedVisualEffects):
self.filters = CommonFilters(self.win, self.cam)
self.filters.setBloom()
def setupKeyboardControl(self):
self.accept("escape", sys.exit)
def setupMouseControl(self):
self.disableMouse()
self.mousex = 0
self.mousey = 0
self.last = 0
self.mousebtn = [0,0,0]
self.accept("mouse1", self.setMouseBtn, [0, 1])
self.accept("mouse1-up", self.setMouseBtn, [0, 0])
self.taskMgr.add(self.controlCamera, "cameraTask")
def setupModels(self):
self.setupLights()
self.loadSky()
self.loadTerrain()
self.setupBuildings()
self.phoneState.setupPhone()
def setupLights(self):
self.sunLight = self.render.attachNewNode(DirectionalLight("sunLight"))
self.sunLight.setColor(Vec4(0.8, 0.8, 0.8, 1))
self.sunLight.node().getLens().setFilmSize(128, 64)
self.sunLight.node().getLens().setNearFar(20,2000)
self.sunLight.setPos(60, 30, 50)
self.sunLight.lookAt(0, 0, 0)
self.render.setLight(self.sunLight)
# self.sunLight.node().showFrustum()
if self.useAdvancedVisualEffects:
self.sunLight.node().setShadowCaster(True, 256, 256)
self.render.setShaderAuto()
self.ambientLight = self.render.attachNewNode(AmbientLight("ambientLight"))
self.ambientLight.node().setColor(Vec4(0.2, 0.2, 0.2, 1))
self.render.setLight(self.ambientLight)
def loadSky(self):
self.sky = self.loader.loadModel("models/sky")
self.sky.reparentTo(self.camera)
self.sky.setScale(base.camLens.getNear() * 1.1)
self.sky.setBin("background", 0)
self.sky.setDepthWrite(False)
self.sky.setCompass()
self.sky.setLightOff()
def loadTerrain(self):
self.terrain = self.loader.loadModel("models/terrain")
self.terrain.reparentTo(self.render)
self.teapot = self.loader.loadModel("teapot")
def setupBuildings(self):
# Load building prototypes
self.buildingPadPrototype = self.loader.loadModel("models/building_pad")
self.policeBuildingPrototype = self.loader.loadModel("models/police_building")
self.tribunalPrototype = self.loader.loadModel("models/tribunal")
self.officeBuildingPrototype = self.loader.loadModel("models/office_building")
self.housePrototype = self.loader.loadModel("models/House/CasaSimples")
self.housePrototype.setPos(5, 5, 2.1)
self.buildCity()
def buildCity(self):
# Define city blueprint
city = [
"PSOSHS_",
"SSSSSSS",
"OSHHHHH",
"_SSSSSS",
"_SHHHHH",
"_SSSSSS",
"_SHHHHH",
"_SSSSSS",
"_SHHHHH"
]
blockSize = 10
cityWESize = len(city[0]) * blockSize
cityNSSize = len(city) * blockSize
self.maxX = cityWESize / 2.0
self.maxY = cityNSSize / 2.0
buildingOutline = LineSegs("building")
buildingSize = 8
buildingPadding = 1
buildingOutline.setColor(0, 0, 0, 1)
buildingOutline.moveTo(buildingPadding, buildingPadding, 0)
buildingOutline.drawTo(buildingPadding + buildingSize, buildingPadding, 0)
buildingOutline.drawTo(buildingPadding + buildingSize, buildingPadding + buildingSize, 0)
buildingOutline.drawTo(buildingPadding, buildingPadding + buildingSize, 0)
buildingOutline.drawTo(buildingPadding, buildingPadding, 0)
buildingOutlinePrototype = NodePath(buildingOutline.create())
# Create buildings from city blueprint
for rowIndex, row in enumerate(city):
for columnIndex, buildingType in enumerate(row):
# Get building data from city blueprint
buildingInstanceName, buildingPrototype = self.buildingInstanceNameAndPrototypeFromType(buildingType)
if (not (buildingInstanceName is None or buildingPrototype is None)):
# Compute building position
buildingX, buildingY, buildingZ = columnIndex * blockSize - cityWESize / 2, cityNSSize / 2 - (rowIndex + 1) * blockSize, 0
# Create building pad
buildingPadInstance = self.render.attachNewNode("buildingPadInstance")
buildingPadInstance.setPos(buildingX, buildingY, buildingZ)
self.buildingPadPrototype.instanceTo(buildingPadInstance)
# Create building
buildingInstance = self.render.attachNewNode(buildingInstanceName)
buildingInstance.setPos(buildingX, buildingY, buildingZ)
buildingPrototype.instanceTo(buildingInstance)
# Create building outline in minimap
buildingOutlineInstance = self.phoneState.minimap.attachNewNode("buildingOutline")
buildingOutlineInstance.setPos(buildingX, buildingY, buildingZ)
buildingOutlinePrototype.instanceTo(buildingOutlineInstance)
def setMouseBtn(self, btn, value):
self.mousebtn[btn] = value
if (btn == 0 and value == 1 and self.phoneState.state == "Center"):
phoneDisplayRegionCenterX = self.win.getXSize() * (self.phoneState.phoneDisplayRegion.getLeft() + self.phoneState.phoneDisplayRegion.getRight()) / 2.0
phoneDisplayRegionCenterY = self.win.getYSize() * (1.0 - (self.phoneState.phoneDisplayRegion.getBottom() + self.phoneState.phoneDisplayRegion.getTop()) / 2.0)
mouse = self.win.getPointer(0)
s = 2 ** self.phoneState.minimapZoom
x = clamp(self.camera.getX() + (mouse.getX() - phoneDisplayRegionCenterX) / s, -self.maxX, self.maxX)
y = clamp(self.camera.getY() + (phoneDisplayRegionCenterY - mouse.getY()) / s, -self.maxY, self.maxY)
previousHeading = self.camera.getH() % 360.0
heading = (rad2Deg(atan2(y - self.camera.getY(), x - camera.getX())) - 90.0) % 360.0
if (180.0 < abs(heading - previousHeading)):
if (previousHeading < heading):
heading -= 360.0
else:
heading += 360.0
self.camera.setH(previousHeading)
self.phoneState.orientationTriangle.setH(previousHeading)
Parallel(
self.camera.posInterval(0.5, Vec3(x, y, self.camera.getZ())),
self.phoneState.minimapCamera.posInterval(0.5, Vec3(x, y, self.phoneState.minimapCamera.getZ())),
self.phoneState.orientationTriangle.posInterval(0.5, Vec3(x, y, self.phoneState.orientationTriangle.getZ())),
self.camera.hprInterval(0.5, Vec3(heading, self.camera.getP(), self.camera.getR())),
self.phoneState.orientationTriangle.hprInterval(0.5, Vec3(heading, self.phoneState.orientationTriangle.getP(), self.phoneState.orientationTriangle.getR()))
).start()
def buildingInstanceNameAndPrototypeFromType(self, buildingType):
return {
'S' : ( None, None ),
'P' : ( "policeBuildingInstance", self.policeBuildingPrototype ),
'T' : ( "tribunalInstance", self.tribunalPrototype ),
'O' : ( "officeBuildingInstance", self.officeBuildingPrototype ),
'H' : ( "houseInstance", self.housePrototype ),
}.get(buildingType, ( None, None ))
def setBlurSharpen(self, amount):
if (not self.useAdvancedVisualEffects):
return
if (amount == 1.0):
self.filters.delBlurSharpen()
else:
self.filters.setBlurSharpen(amount=amount)
def controlCamera(self, task):
if (self.phoneState.state == "Center"):
return Task.cont
# figure out how much the mouse has moved (in pixels)
mouse = self.win.getPointer(0)
x = mouse.getX()
y = mouse.getY()
windowCenterX = self.win.getXSize() / 2
windowCenterY = self.win.getYSize() / 2
heading = self.camera.getH()
pitch = self.camera.getP()
if self.win.movePointer(0, windowCenterX, windowCenterY):
heading -= (x - windowCenterX) * 0.2
pitch = clamp(pitch - (y - windowCenterY) * 0.2, -45, 45)
self.camera.setHpr(heading, pitch, 0)
elapsed = task.time - self.last
if (self.last == 0):
elapsed = 0
if (self.mousebtn[0]):
direction = self.camera.getMat().getRow3(1)
self.camera.setPos(self.camera.getPos() + direction * elapsed*30)
clampX(self.camera, -self.maxX, self.maxX)
clampY(self.camera, -self.maxY, self.maxY)
self.camera.setZ(2)
self.phoneState.minimapCamera.setX(self.camera.getX())
self.phoneState.minimapCamera.setY(self.camera.getY())
self.phoneState.orientationTriangle.setX(self.camera.getX())
self.phoneState.orientationTriangle.setY(self.camera.getY())
self.phoneState.orientationTriangle.setHpr(heading, -90, 0)
self.last = task.time
return Task.cont
base.disableMouse()
base.setFrameRateMeter(True)
color = (0,0,0,1)
#color = (1,1,1,1)
expfog = Fog("Scene-wide exponential Fog object")
expfog.setColor(color)
expfog.setExpDensity(0.02)
#render.setFog(expfog)
base.setBackgroundColor(color)
#render.setAntialias(AntialiasAttrib.MMultisample)
#render.setAntialias(AntialiasAttrib.MAuto)
#render.setAttrib(LightRampAttrib.makeHdr0())
#render.setAttrib(LightRampAttrib.makeHdr1())
#render.setAttrib(LightRampAttrib.makeHdr2())
#render.setAttrib(LightRampAttrib.makeSingleThreshold(0.5, 0.5))
#render.setAttrib(LightRampAttrib.makeDoubleThreshold(0.5, 0.5, 0.5, 0.5))
filters = CommonFilters(base.win, base.cam)
#filters.setCartoonInk(separation=0.5)
#filters.setViewGlow()
#filters.setVolumetricLighting(caster=game.mapManager.player.model)
filters.setBloom()
#PStatClient.connect()
#loadPrcFileData('setup', 'dump-generated-shaders #t')
run()
class World:
def __init__(self):
base.disableMouse()
# Turns off the default mouse-camera controls in Panda3D.
base.setBackgroundColor(0, 0, 0)
# Sets the background to black.
self.inputManager = InputManager()
# Creates an InputManager to handle all of the user input in the game.
#taskMgr.doMethodLater(10, self.debugTask, "Debug Task")
# Tells the debugTask to run once every ten seconds. The debug task is a good
# place to put various data print outs about the game to help with debugging.
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setBloom(blend=(0, 0, 0, 1),
desat=-0.5,
intensity=3.0,
size=2)
render.setShaderAuto()
# Turns on Panda3D's automatic shader generation.
self.menuGraphics = loader.loadModel("../Models/MenuGraphics.egg")
# Loads the egg that contains all the menu graphics.
self.fonts = {
"silver": loader.loadFont("../Fonts/LuconSilver.egg"),
"blue": loader.loadFont("../Fonts/LuconBlue.egg"),
"orange": loader.loadFont("../Fonts/LuconOrange.egg")
}
# Loads the three custom fonts our game will use.
hud = HUD(self.fonts)
# Creates the HUD.
self.race = Race(self.inputManager, hud)
self.race.createDemoRace()
# creates an instance of the race class and tells it to
# start a demo race.
self.createStartMenu()
# creates the start menu.
musicMgr = base.musicManager
self.music = musicMgr.getSound(
"../Sound/Loveshadow-Takin_Yo_Time_(The_Wingman_Mix).wav")
self.music.setLoop(True)
self.music.play()
def createStartMenu(self):
menu = Menu(self.menuGraphics, self.fonts, self.inputManager)
menu.initMenu([
0, None, ["New Game", "Quit Game"],
[[self.race.createRace, self.createReadyDialogue],
[base.userExit]], [[None, None], [None]]
])
def createReadyDialogue(self):
menu = Menu(self.menuGraphics, self.fonts, self.inputManager)
menu.initMenu([
3, "Are you ready?", ["Yes", "Exit"],
[[self.race.startRace], [self.race.createDemoRace]], [[3], [None]]
])
def debugTask(self, task):
print(taskMgr)
# prints all of the tasks in the task manager.
return task.again
def __init__(self):
ShowBase.__init__(self)
self.cfg = cfgdict("data/default_config.cfg")
globalClock.setMode(ClockObject.MLimited)
globalClock.setFrameRate(int(self.cfg["general"]["framerate"]))
#base.setFrameRateMeter(int(self.cfg["general"]["debug"]))
self.props = WindowProperties()
self.props.setSize(tuple(self.cfg["general"]["resolution"]))
self.props.setFullscreen(int(self.cfg["general"]["fullscreen"]))
self.props.setCursorHidden(True)
self.fullscreen = int(self.cfg["general"]["fullscreen"])
#props.setMouseMode(WindowProperties.M_relative)
base.win.requestProperties(self.props)
base.disableMouse()
base.win.setClearColor((0, 0, 0, 0))
self.inputs = Inputs(self.cfg["key"])
#cats=["mainmenu", "parts", "enemies", "items"]
#for cat in cats: makeWireframe(cat)
self.hud = HUD(self)
self.transition = Transitions(loader)
self.parts_models = getParts("data/models/egg/parts/parts")
self.enemy_models = getParts("data/models/egg/enemies/enemies")
self.item_models = getParts("data/models/egg/items/items")
sounds = [
"break",
"error",
"explosion",
"hit_a",
"hit_b",
"hit_c",
"scare",
"select_a",
"select_b",
"splurt_a",
"splurt_b",
"swallow",
"step_enemy_a",
"step_enemy_b",
"step_enemy_c",
"step_player",
"turn",
"projectile_a",
"projectile_b",
"projectile_c",
]
self.sounds = {}
for sound in sounds:
self.sounds[sound] = loader.loadSfx("data/sound/" + sound + ".wav")
self.sounds["step_player"].setVolume(0.3)
self.act = False
if self.cfg["general"]["fx"] == 1:
render.setShaderAuto()
aspect2d.setShaderAuto()
filters = CommonFilters(base.win, base.cam)
filters.setBloom(blend=(0.1, 0.1, 0.1, 0.0),
mintrigger=0.0,
maxtrigger=0.1,
desat=0.0,
intensity=0.6,
size="small")
class Engine(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
props = WindowProperties()
props.setTitle('Test')
self.win.requestProperties(props)
# self.render.setAntiAlias(AntialiasAttrib.MAuto)
self.transitions = Transitions(self.loader)
self.transitions.setFadeColor(0, 0, 0)
self.filters = CommonFilters(self.win, self.cam)
# self.filters.setCartoonInk()
self.filters.setBlurSharpen(1)
# self.filters.setVolumetricLighting(self.render)
# self.buffer = self.win.makeTextureBuffer("Post-processing buffer", self.win.getXSize(), self.win.getXSize())
# print self.buffer.getYSize()
# self.texture = self.buffer.getTexture()
# self.buffer.setSort(-100)
#
# self.originalCamera = self.camera
# self.offScreenCamera = self.makeCamera(self.buffer)
# self.camera = self.offScreenCamera
#
# self.img = OnscreenImage(image=self.texture, pos=(0, 0, 0.5))
self.scene = None
self.channel = Channel()
def set_scene(self, scene_module):
# self.transitions.fadeOut(0.2)
args = []
if self.scene:
args.append(
Parallel(Func(self.fade_out),
LerpFunc(self.blur_out, duration=0.2)))
args.append(Wait(0.2))
args.append(Func(self._set_scene, scene_module))
args.append(
Parallel(Func(self.fade_in), LerpFunc(self.blur_in, duration=0.4)))
Sequence(*args).start()
def blur_out(self, t):
# index = int(t)
# self.filters.delBlurSharpen()
self.filters.setBlurSharpen(1 - t)
self.filters.setBloom(intensity=t)
def blur_in(self, t):
# index = int(t)
# self.filters.delBlurSharpen()
self.filters.setBlurSharpen(t)
self.filters.setBloom(intensity=-t)
def fade_out(self):
self.transitions.fadeOut(0.2)
def fade_in(self):
self.transitions.fadeIn(0.2)
def _set_scene(self, scene_module):
group, class_ = scene_module.split('.')
module = importlib.import_module('game.scenes.{}'.format(group))
scene_class = getattr(module, class_)
if self.scene:
self.scene.destroy()
del self.scene
self.scene = scene_class(self)
# self.transitions.fadeIn(0.2)
def start(self):
self.channel = Channel()
self.channel.connect()
self.set_scene('auth.AuthScene')
while True:
self.taskMgr.step()
if self.channel.can_read():
for packet in self.channel.read_packets():
self.scene.on_packet(packet)
class Universe(DirectObject, EoAUniverse):
"""Universe
-----------
Out main class, the Universe"""
def __init__(self):
"""Initialize our world
Our game loop looks a little different than the standard
-do logic
-render
because Panda3d's tasks are being used. The basic idea still carries
over though, and we'll try to follow the same logic by storing states
in our Universe class then calling a task to render everything (this
is a TODO)
Set up environment
Set up lighting
Set up physics
Set up actors
Set up collisions
Run tasks
"""
"""------------INIT---------------------------------------"""
"""Set up input"""
self.init_controls()
"""Set up environment"""
self.init_environment()
"""Set up lights"""
self.init_lights()
"""Set up physics"""
self.init_physics()
"""Set up collisions"""
self.init_collisions()
"""Set up actors"""
self.init_actors()
"""Set up camera"""
self.init_camera()
"""Set up GUI"""
self.init_gui()
"""------------TASKS---------------------------------------"""
self.elapsed = 0.0
self.prev_time = 0.0
"""Set up tasks"""
#Set up lighting updates
base.taskMgr.add(self.update_lighting, 'update_lighting')
#Set up movement updates
base.taskMgr.add(self.update_movement, 'update_movement')
#Set up camera updates
base.taskMgr.add(self.update_camera, 'update_camera')
#Keep track of entities, update animation if they are moving
base.taskMgr.add(self.update_entity_animations,
'update_entity_animations')
#Setup mouse collision test
base.taskMgr.add(self.update_mouse_collisions,
'update_mouse_collisions')
"""Set up skydome"""
#self.init_skydome()
#Skydome task
#base.taskMgr.add(self.cameraUpdated, "camupdate")
"""--------------------------------------------------------"""
"""------------------initial setup functions-------------------------------
INITIAL SETUP FUNCTIONS
--------------------------------------------------------------------"""
"""=======Controls============================================="""
def init_controls(self):
"""Set up controls. Use direct input and keymaps
TODO
-Allow user to control keys from config settings
"""
# Now, assign some controls to the events that the GravityWalker will
#watch for
#Create a dictionary to save controls
"""WASD Settings"""
self.controls = {}
self.controls['forwardControl'] = inputState.watch('forward', 'w',
'w-up', inputSource=inputState.WASD)
self.controls['reverseControl'] = inputState.watch('reverse', 's',
's-up', inputSource=inputState.WASD)
self.controls['turnLeftControl'] = inputState.watch('turnLeft', 'a',
'a-up', inputSource=inputState.WASD)
self.controls['turnRightControl'] = inputState.watch('turnRight', 'd',
'd-up', inputSource=inputState.WASD)
self.controls['jumpControl'] = inputState.watch('jump', 'space',
'space-up', inputSource=inputState.Keyboard)
self.controls['isMoving'] = False
"""Key map settings"""
self.controls['key_map'] = {"cam_left":0, "cam_right":0, "cam_up":0,
"cam_down":0, "mouse1":0, "mouse2": 0,
"mouse3": 0, "scroll_up":0,
"scroll_down":0}
#Camera Control Keys
self.accept("arrow_left", self.controls_set_key, ["cam_left",1])
self.accept("arrow_right", self.controls_set_key, ["cam_right",1])
self.accept("arrow_left-up", self.controls_set_key, ["cam_left",0])
self.accept("arrow_right-up", self.controls_set_key, ["cam_right",0])
self.accept("arrow_up", self.controls_set_key, ["cam_up",1])
self.accept("arrow_down", self.controls_set_key, ["cam_down",1])
self.accept("arrow_up-up", self.controls_set_key, ["cam_up",0])
self.accept("arrow_down-up", self.controls_set_key, ["cam_down",0])
"""Mouse settings"""
#Previous mouse coordinates, used for camera and dragging elements
self.controls['mouse_prev_x'] = 0
self.controls['mouse_prev_y'] = 0
self.controls['mouse_camera_dragging'] = False
#mouse keys
#mouse1 is left click
#Call function to set the player's target
#set_target_on_mouseclick also sets the mouse1 key value...need to make
# this more extensible
self.accept("mouse1", self.set_target_on_mouseclick)
self.accept("mouse1-up", self.controls_set_key, ["mouse1", 0])
#mouse3 is right click
self.accept("mouse3", self.controls_set_key, ["mouse3", 1])
self.accept("mouse3-up", self.controls_set_key, ["mouse3", 0])
#mouse2 is scroll wheel click
self.accept("mouse2", self.controls_set_key, ["mouse2", 1])
self.accept("mouse2-up", self.controls_set_key, ["mouse2", 0])
#mouse scroll
self.accept('wheel_up', self.controls_set_key,["scroll_up", 1 ])
self.accept('wheel_down', self.controls_set_key, ["scroll_down", 1])
self.accept ('escape', sys.exit) # hit escape to quit!
def controls_set_key(self, key, value):
"""Set up keyboard keys
Create a key_map dictionary to store the key being pressed and the
value (which will be either 1 for on or 0 for off)
"""
self.controls['key_map'][key] = value
"""=======Lights==============================================="""
def init_lights(self):
"""init_lights
Set up light system
"""
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setBloom(blend=(0,0,0,.5), desat=-0.5,
intensity=1.0, size="small")
if filterok == False:
print "Your video card cannot handle this"
return
self.glowSize=.2
# Create a simple directional light
self.lights = {}
#Set up directional light
self.lights['dlight'] = render.attachNewNode (DirectionalLight\
('DirectionalLight'))
self.lights['dlight'].setColor(VBase4(1, 1, 1, 1))
render.setLight(self.lights['dlight'])
self.lights['dlight'].setPos(50,50,50)
self.lights['dlight'].lookAt(0,0,0)
#Sun position
self.lights['sunPos'] = 0
# Create an ambient light
self.lights['alight'] = AmbientLight('AmbientLight')
self.lights['alight'].setColor(VBase4(0.1, 0.1, 0.1, 0.1))
self.lights['alnp'] = render.attachNewNode(self.lights['alight'])
render.setLight(self.lights['alnp'])
#Create an invisible "sun" node which the dlight will lookAt()
self.lights['sun_node'] = render.attachNewNode("sun_node")
self.lights['sun_node'].setPos(10,10,10)
self.lights['sun_node'].setScale(2)
#Create a sun model that will be a visual representation of where the
# sun is. Will be, essentially, in the opposite position of the
# fake sun node
self.lights['sun_model'] = loader.loadModel(target_dir+'/models/sphere.egg')
self.lights['sun_model'].reparentTo(render)
self.lights['sun_model'].setPos(10,10,10)
self.lights['sun_model'].setScale(2)
self.lights['sky_box'] = loader.loadModel(target_dir+'/models/skybox.egg')
self.lights['sky_box'].reparentTo(render)
self.lights['sky_box'].setScale(5)
sky_tex = loader.loadTexture(\
target_dir+'/models/textures/clouds_bw.png')
sky_tex.setWrapU(Texture.WMRepeat)
sky_tex.setWrapV(Texture.WMRepeat)
self.lights['sky_box'].setTexture(sky_tex,1)
"""=======Actors==============================================="""
def init_actors(self):
"""init_actors
Setup actors"""
#Setup the PC entity
self.entities['PC'] = EoAEntity(gravity_walker=True,modelName="boxman",
name='PC', startPos=(0,0,5),
max_health=521, max_power=82,
stats={'agi':10, 'dex':19, 'int':19,
'sta':15, 'str':14, 'wis':18})
for i in range(5):
self.entities['NPC_'+str(i)] = EoAEntity(modelName="boxman",
max_health=100,
name='NPC_'+str(i),startPos=(random()*i+i,
random()*i+i,80))
"""=======Camera==============================================="""
def init_camera(self):
"""init_camera
Set up the camera. Allow for camera autofollow, freemove, etc"""
base.disableMouse()
base.camera.reparentTo(self.entities['PC'].Actor)
base.camera.setPos(0, -15, 25)
base.camera.lookAt(self.entities['PC'].Actor)
angledegrees = 2
angleradians = angledegrees * (math.pi / 180.0)
base.camera.setPos(20*math.sin(angleradians),-20.0*\
math.cos(angleradians),3)
base.camera.setHpr(angledegrees, 0, 0)
"""Set up some camera controls"""
self.controls['camera_settings'] = {}
#Camera timer is used to control how long a button is being held
#to control the camera
self.controls['camera_settings']['timer'] = 0
self.controls['camera_settings']['zoom'] = 20
"""=======Skydome=============================================="""
def init_skydome(self):
#SKYBOX
self.skybox = loader.loadModel(target_dir+'/models/dome2')
self.skybox.reparentTo(render)
self.skybox.setScale(4000,4000,1000)
#self.skybox.setLightOff()
texturefile = target_dir + "/models/textures/clouds_bw.png"
texture = loader.loadTexture(texturefile)
self.textureStage0 = TextureStage("stage0")
self.textureStage0.setMode(TextureStage.MReplace)
self.skybox.setTexture(self.textureStage0,texture,.2)
self.rate = Vec4(0.004, 0.002, 0.008, 0.010)
self.textureScale = Vec4(1,1,1,1)
self.skycolor = Vec4(.1, .1, .1, 0)
self.skybox.setShader( loader.loadShader(target_dir+\
'/shaders/skydome2.sha' ) )
self.skybox.setShaderInput("sky", self.skycolor)
self.skybox.setShaderInput("clouds", self.rate)
self.skybox.setShaderInput("ts", self.textureScale)
"""-----------------tasks--------------------------------------------------
TASKS
--------------------------------------------------------------------"""
"""=======Update character movement============================"""
def update_movement(self,task):
"""Task that updates the walking animation on our GravityWalker
TODO - Stop using gravity walker and implement ODE physics?
If using ODE or something other than gravitywalker, handle controls
for movement here
"""
# Adjust to match the walkcycle, to minimize sliding
self.entities['PC'].Actor.setPlayRate(0.5 * \
self.entities['PC'].physics['playerWalker'].speed,
'walk')
#Check if the player is moving. If so, play walk animation
if inputState.isSet('forward') or inputState.isSet('reverse') or \
inputState.isSet('turnLeft') or inputState.isSet('turnRight'):
if self.controls['isMoving'] is False:
self.entities['PC'].Actor.loop('walk')
self.controls['isMoving'] = True
else:
if self.controls['isMoving']:
print 'stopped'
self.entities['PC'].Actor.stop()
self.entities['PC'].Actor.loop('idle')
self.controls['isMoving'] = False
#Done here
return Task.cont
"""======Update camera========================================="""
def update_camera(self,task):
"""Check for camera control input and update accordingly"""
# Get the time self.elapsed since last frame. We need this
# for framerate-independent movement.
self.elapsed = globalClock.getDt()
"""---------Keyboard movement-------------------"""
"""Rotate Camera left / right"""
if self.controls['key_map']['cam_left'] !=0:
"""Rotate the camera to the left"""
#increment the camera timer, determines speed of camera rotation
self.controls['camera_settings']['timer'] += .1
angledegrees = self.controls['camera_settings']['timer'] * 50
angleradians = angledegrees * (math.pi / 180.0)
#Set the X, Y as the zoom value * sine or cosine (respectively) of
# angle radians, which is determined by rotating the camera left
# or right around the character. The zoom variable determines
# in essence, the zoom level which is calcuated simply as
# self.elapsed * 20. Notice this is also the value we use to
# setY when we zoom in or out - no coincidence, these numbers
# are the same because we want to know the location of the
# camera when we pan around the character (this location is
# multiplied by sin or cos of angleradians
base.camera.setPos(self.controls['camera_settings']['zoom']*\
math.sin(angleradians),
-self.controls['camera_settings']['zoom']*\
math.cos(angleradians),
base.camera.getZ())
#Set the heading / yaw (h) of the camera to point at the character
base.camera.setHpr(angledegrees, 0, 0)
if self.controls['key_map']['cam_right'] !=0:
"""Rotate the camera to the right"""
#increment the camera timer
self.controls['camera_settings']['timer'] -= .1
angledegrees = self.controls['camera_settings']['timer'] * 50
angleradians = angledegrees * (math.pi / 180.0)
base.camera.setPos(self.controls['camera_settings']['zoom']*\
math.sin(angleradians),
-self.controls['camera_settings']['zoom']*\
math.cos(angleradians),
base.camera.getZ())
base.camera.setHpr(angledegrees, 0, 0)
"""Zoom camera in / out"""
#ZOOM IN
if self.controls['key_map']['cam_up'] !=0:
#Zoom in
base.camera.setY(base.camera, +(self.elapsed*20))
#Store the camera position
self.controls['camera_settings']['zoom'] -= self.elapsed*20
#ZOOM OUT
if self.controls['key_map']['cam_down'] !=0:
#Zoom out
base.camera.setY(base.camera, -(self.elapsed*20))
#Store the camera position
self.controls['camera_settings']['zoom'] += self.elapsed*20
"""---------Mouse movement-------------------"""
#Zoom in on mouse scroll forward
if self.controls['key_map']['scroll_up'] !=0:
#Zoom in
base.camera.setY(base.camera, +(self.elapsed*20))
#Store the camera position
self.controls['camera_settings']['zoom'] -= .1
#Reset the scroll state to off
self.controls['key_map']['scroll_up'] = 0
#Zoom in on mouse scroll forward
if self.controls['key_map']['scroll_down'] !=0:
#Zoom in
base.camera.setY(base.camera, -(self.elapsed*20))
#Store the camera position
self.controls['camera_settings']['zoom'] -= .1
#Reset the scroll state to off
self.controls['key_map']['scroll_down'] = 0
#Move camera left / right by mouseclick
#mous3 is right click button
if self.controls['key_map']['mouse3'] != 0:
"""Rotate the camera to the left or right"""
#We know right click is being held, checked to see if it's moving
# left or right
if base.mouseWatcherNode.hasMouse():
cur_mouse_x=base.mouseWatcherNode.getMouseX()
cur_mouse_y=base.mouseWatcherNode.getMouseY()
else:
#The base does not have the mouse watcher node, meaning the
# mouse is probably outside the game window. If this is
# the case, set the cur mouse x and y to the prev coords
cur_mouse_x = self.controls['mouse_prev_x']
cur_mouse_y = self.controls['mouse_prev_y']
#Check to see if the camera is being dragged. This ensures that
# the camera won't move when the mouse is first clicked
if self.controls['mouse_camera_dragging'] is True:
#compare the previous mouse x position (if it exists). If the
# cur position is greater, it means the mouse has moved to the
# left side of the screen, so update the camera position
if cur_mouse_x > self.controls['mouse_prev_x']:
#Camera will be moving to the right
self.controls['camera_settings']['timer'] -= .1
elif cur_mouse_x < self.controls['mouse_prev_x']:
#Camera will be moving to the left
self.controls['camera_settings']['timer'] += .1
#Move the camera
angledegrees = self.controls['camera_settings']['timer'] * 50
angleradians = angledegrees * (math.pi / 180.0)
#Set the X, Y as the zoom value ... see camera rotation code
# above for more details
base.camera.setPos(self.controls['camera_settings']['zoom']*\
math.sin(angleradians),
-self.controls['camera_settings']['zoom']*\
math.cos(angleradians),
base.camera.getZ())
#Set the yaw of the camera to point at the character
base.camera.setHpr(angledegrees, 0, 0)
#Set current x,y mouse coordinates as previous coordinates so we
# can do comparisons the next time the function is called
self.controls['mouse_prev_x'] = cur_mouse_x
self.controls['mouse_prev_y'] = cur_mouse_y
self.controls['mouse_camera_dragging'] = True
elif self.controls['key_map']['mouse3'] == 0:
#The right click button has been depressed, so the camera is
# no longer being dragged
self.controls['mouse_camera_dragging'] = False
#self.entities['PC'].physics['playerWalker'].getCollisionsActive()
return Task.cont
"""======Update lighting========================================="""
def update_lighting(self, task):
#Update the Sun's position.
#TODO - tie this in with day/night/time system
#Move the sun
angleDegrees = task.time * 100.0
angleRadians = angleDegrees * (math.pi / 180.0)
self.lights['sun_node'].setPos(75*math.sin(angleRadians),
0,-75.0*math.cos(angleRadians))
#Set the sun model's position based on the sun node. Will be reversed
# in the X direction
self.lights['sun_model'].setPos(-self.lights['sun_node'].getX(),
3, -self.lights['sun_node'].getZ())
#self.lights['dlight'].setHpr(0,angleDegrees,0)
self.lights['dlight'].lookAt(self.lights['sun_node'])
#self.lights['sky_box'].setHpr(0,angleDegrees,0)
#Set the skybox's position to the camera's position so the camera
# never touches the skybox, makes the skybox appear to never move
self.lights['sky_box'].setPos(base.camera.getPos())
return Task.cont
"""=======update_entity_animations============================="""
def update_entity_animations(self, task):
"""Check to see if any entities have moved since the last check
If entity d(xyz) has changed, play animation
Better way to handle this? Every entity could have a task to
update its animation based on its state.
"""
#Loop through all entities and animate them
for i in self.entities:
if i != "PC":
#Get the entity's current position
test_pos = self.entities[i].getPos()
#Turn it into an integer for checking
test_pos_int = [float("%.2f" % j) for j in test_pos]
#See if the current position matches the previous position
if test_pos_int != self.entities[i].prevPos:
#Check to see if the entity has been moving
if self.entities[i].is_moving is False and \
self.entities[i].moving_buffer > 20:
#Play the walk animation
self.entities[i].Actor.loop('walk')
#The entity is moving now
self.entities[i].is_moving = True
#Reset the moving buffer
self.entities[i].moving_buffer = 0
#Increment the moving buffer by one to help reduce
#skittering
self.entities[i].moving_buffer += 1
else:
#else, the previous and current position is the same
if self.entities[i].is_moving:
#Check to see if entity is set as moving to ensure we
#don't do this loop the idle animation every frame
self.entities[i].Actor.stop()
self.entities[i].Actor.loop('idle')
self.entities[i].is_moving = False
#Set the entity's previous position
self.entities[i].prevPos = test_pos_int
"""to update NPC's location
pos = self.entities['NPC_0'].getPos()
self.entities['NPC_0'].setPos(x,y,z)
"""
return Task.cont
"""=======update_mouse_collisions=============================="""
def update_mouse_collisions(self, task):
"""Handle muse collisions for hover and click"""
#TODO - optimize? Does this provide an advatge?
#Task.time returns a float with many digits, so doing all these checks
#per iteration is a little time consuming. Let's compare only the first
#digit of task.time to see if we should do the mouse collisions checks
#or not. Since the timing does not have to be 100% perfect as we're
#checking for mouse interactions, we can afford not to be as exact
#as possible. Need to check if following test saves any FPS
#normal test
#if self.prev_time != task.time:
#optimized test
#if float("%.1f" % self.prev_time) != float("%.1f" % task.time):
#Check to see if we can access the mouse
if base.mouseWatcherNode.hasMouse():
#get the mouse position
mpos = base.mouseWatcherNode.getMouse()
#Set the position of the ray based on the mouse position
self.physics['collisions']['mouse']['picker_ray'].setFromLens(\
base.camNode, mpos.getX(), mpos.getY())
#Do the actual collision pass (Do it only on the squares for
#efficiency purposes)
base.cTrav.traverse(EoAUniverse.nodes['entity_root'])
#Get number of entries in the collision handler
if self.physics['collisions']['mouse']['cHandler'].\
getNumEntries() > 0:
#Get the closest object
self.physics['collisions']['mouse']['cHandler'].sortEntries()
#Store the picked object
self.physics['collisions']['mouse']['current_node'] = self.\
physics['collisions']['mouse']['cHandler'].\
getEntry(0).getIntoNodePath()
self.physics['collisions']['mouse']['current_node'] = self.\
physics['collisions']['mouse']['current_node'].\
findNetTag('mouse_obj_tag')
try:
if not self.physics['collisions']['mouse']\
['current_node'].isEmpty():
#Get the entity from the python tag
"""Check for mouse hopping from object to object,
mouse might hover over NPC_1 to NPC_2. If we don't
check for this, a node may stay highlighted if the
mouse collides from NPC to NPC"""
#Check if the current picked object is equal to the
#previous picked object (and that it isn't none)
if self.physics['collisions']['mouse']['prev_node'] !=\
self.physics['collisions']['mouse']['current_node'] \
and self.physics['collisions']['mouse']\
['prev_node'] is not None:
#Turn off the highlight light
self.physics['collisions']['mouse']['prev_node'].\
setLightOff()
#Turn back on the default lights
self.physics['collisions']['mouse']['prev_node'].\
setLight(self.lights['alnp'])
self.physics['collisions']['mouse']['prev_node'].\
setLight(self.lights['dlight'])
#We don't set the previously picked node object
#here because we don't want to set the previous
#node to the current node if the previous node
#is equal to none
"""If the hovered over node is not the curret node,
set light"""
#Add an effect
#Create an ambient light so the name node will be
#one uniform light
ambient = AmbientLight('ambient')
ambient.setColor(Vec4(.5,.7,.7,.1))
ambientNP = self.physics['collisions']['mouse']\
['current_node'].attachNewNode(\
ambient.upcastToPandaNode())
# If we did not call setLightOff() first, the green
#light would add to the total set of lights on this
#object. Since we do call setLightOff(), we are
#turning off all the other lights on this object first,
#and then turning on only the green light.
self.physics['collisions']['mouse']['current_node'].\
setLightOff()
self.physics['collisions']['mouse']['current_node'].\
setLight(ambientNP)
#We set the highlighting for the moused over node,
#now set the previous node to the current selected node
if self.physics['collisions']['mouse']['prev_node'] !=\
self.physics['collisions']['mouse']['current_node']:
self.physics['collisions']['mouse']['prev_node'] =\
self.physics['collisions']['mouse']['current_node']
except:
print "Error on mouse over node " + str(self.physics\
['collisions']['mouse']['current_node'])
else:
#The mouse isn't over anything, check to see if the previous
#node is set
if self.physics['collisions']['mouse']['prev_node'] \
is not None:
if self.entities['PC'].target != \
self.physics['collisions']['mouse']['prev_node'].\
getPythonTag('entity'):
#Turn off the highlight light
self.physics['collisions']['mouse']['prev_node'].\
setLightOff()
#Turn back on the default lights
self.physics['collisions']['mouse']['prev_node'].\
setLight(self.lights['alnp'])
self.physics['collisions']['mouse']['prev_node'].\
setLight(self.lights['dlight'])
#Set the previous node to none
self.physics['collisions']['mouse']['prev_node'] = None
self.physics['collisions']['mouse']['current_node'] = None
#self.prev_time = task.time
return Task.cont
"""=======Update skybox========================================"""
def cameraUpdated(self, task):
#self.lights['sunPos']
self.skycolor = Vec4( (self.lights['sunPos'] % 360.0) / 360,
(self.lights['sunPos'] % 360.0) / 360,
(self.lights['sunPos'] % 360.0) / 360
,0 )
self.skybox.setShaderInput("sky", self.skycolor)
render.setShaderInput('time', task.time)
return Task.cont
"""-----------------EoA Universe Functions---------------------------------
EoA Universe Functions
--------------------------------------------------------------------"""
"""=======Set PC's target======================================"""
def set_target_on_mouseclick(self):
"""Set the player's target to an entity based on mouse click"""
#Set update mouse1 key values
self.controls_set_key("mouse1", 1)
#Set the target if a node is under the mouse
if self.physics['collisions']['mouse']['current_node'] is not None:
"""If something was clicked"""
picked_entity = self.physics['collisions']['mouse']\
['current_node'].getPythonTag('entity')
#print 'clicked' + str(picked_entity.name)
self.entities['PC'].set_target(target=picked_entity)
if self.physics['collisions']['mouse']['prev_target'] is not None \
and self.physics['collisions']['mouse']['prev_target'] != \
self.physics['collisions']['mouse']['current_node']:
self.physics['collisions']['mouse']['prev_target'].\
setLightOff()
#Turn back on the default lights
self.physics['collisions']['mouse']['prev_target'].\
setLight(self.lights['alnp'])
self.physics['collisions']['mouse']['prev_target'].\
setLight(self.lights['dlight'])
#Set previous target to the current node (set the last clicked on
#node equal to the node the mouse is over)
self.physics['collisions']['mouse']['prev_target'] = \
self.physics['collisions']['mouse']['current_node']
else:
"""No entities are under the click, so clear the target and any
lighting on the previously selected node"""
try:
#Turn off the previous selected node's lights
self.physics['collisions']['mouse']['prev_target'].\
setLightOff()
#Turn back on the default lights
self.physics['collisions']['mouse']['prev_target'].\
setLight(self.lights['alnp'])
self.physics['collisions']['mouse']['prev_target'].\
setLight(self.lights['dlight'])
except:
print "Could not turn off node's lighting"
#Clear the PC's current target
self.entities['PC'].set_target(target=None)
#Clear the target text
"""TODO create a set_target_on_mouseclick method that updates
targetbox"""
self.GUI.target_box['target_text'].setText("")
class World(ShowBase): # CONDISER: change to DirectObject/FSM
def __init__(self):
ShowBase.__init__(self)
self.createLoadScreen('./LEGameAssets/Textures/title_screen.png')
base.graphicsEngine.renderFrame()
#== Environment and Rendering Settings ==
base.setFrameRateMeter(FLAG_SHOW_FRAMES_PER_SECOND)
if FLAG_USE_AUTOSHADER:
render.setShaderAuto()
self.filters = CommonFilters(base.win, self.cam) # NEW
if FLAG_SHOW_GLOW:
bloomSize = 4 #'small'
filterok = self.filters.setBloom(blend=(0, 0, 0, 1),
desat=-0.5,
intensity=3.0,
size=bloomSize)
if (filterok == False):
print 'WARNING:Video card not powerful enough to do image postprocessing'
#tex = loader.loadTexture("./LEGameAssets/Textures/loadbar_tray.png")
self.loadBar = DirectWaitBar(text="",
value=0,
scale=(.35, .5, .5),
pos=(0.006, .83, .83))
#self.loadBar['barRelief'] = DirectWaitBar.GROOVE
#self.loadBar['scale'] = 0.05
#self.loadBar['barTexture'] = tex
self.loadBar['barColor'] = (6.0 / 255.0, 11.0 / 255, 28.0 / 255.0, 1)
self.loadBar.reparentTo(render2d)
self.loadBar.hide()
base.graphicsEngine.renderFrame()
self.setBackgroundColor(166.0 / 255.0, 207.0 / 255.0, 240.0 / 255.0, 1)
self.skybox = self.loader.loadModel(
"LEGameAssets/Models/skybox_final.egg")
self.skybox.setScale(50)
self.skybox.reparentTo(render)
#== Load the level and the managers ==
self.assets, self.objects, self.gameObjects, self.sounds, self.sequences = loadWorld(
SCENE_FILE, LIBRARY_INDEX)
self.loadBar['value'] += 5
base.graphicsEngine.renderFrame()
self.conversations = loadConversations(SCENE_FILE, LIBRARY_INDEX)
self.scenes = {}
self.loadScenes()
self.loadBar['value'] += 5
base.graphicsEngine.renderFrame()
self.journalMgr = JournalMgr(self)
self.loadJournal(self.journalMgr, JOURNAL_FILE)
self.conversationMgr = ConversationMgr(self, self.conversations)
self.scriptMgr = ScriptMgr(self)
self.scriptMgr.loadScripts(SCRIPTS_LIST)
self.scriptInterface = ScriptInterface(self)
self.inventoryMgr = InventoryMgr(self)
loadInventory(self.inventoryMgr, INVENTORY_FILE)
self.loadBar['value'] += 5
base.graphicsEngine.renderFrame()
self.ranSequences = []
#== Main Character ==
self.hero = None
for name, gameObj in self.gameObjects.iteritems():
if gameObj.getNP().hasTag('LE-mainChar'):
self.hero = gameObj
break
else:
# make a default hero
defaultHeroNP = loader.loadModel("panda")
self.hero = GameObject(defaultHeroNP)
self.hero.reparentTo(render)
self.hero.setPos(0, 0, 0)
self.hero.setTag('LE-mainChar', '180')
self.gameObjects[self.hero.getName()] = self.hero
self.setCollideMasks(self.gameObjects)
# remove the hero from the objects dict so it cannot be clicked by player
if self.hero.getName() in self.objects:
del self.objects[self.hero.getName()]
#== Camera ==
camHeightFactor = CAMERA_HEIGHT
camTrailFactor = -CAMERA_TRAIL # careful of +/- distinction
self.heroHeight = self.getModelHeight(self.hero)
self.heroHeadingOffset = float(self.hero.getTag('LE-mainChar'))
self.lastHeroH = self.hero.getH(render) + self.heroHeadingOffset
# setup the camera pivot, which will follow the main character model and anchor the camera
self.camPivot = NodePath('camPivot')
self.camPivot.reparentTo(render)
self.camHeight = camHeightFactor * self.heroHeight
self.camTrail = camTrailFactor * self.heroHeight
self.cam.setPos(self.camPivot.getPos() +
(0, self.camTrail, self.camHeight))
self.cam.wrtReparentTo(self.camPivot)
self.placeCamera(self.hero) # match X and Y to main character
self.alignCamera(self.hero) # match heading to main character
#self.camPivot.setH(render, self.hero.getH(render) + self.heroHeadingOffset)
self.gameCam = self.cam
#== Collisions ==
self.setupCollisions()
#== Controls ==
self.disableMouse()
self.keyMap = {'w': False, 'a': False, 's': False, 'd': False}
self.enableMovement(self.hero)
self.accept("mouse1", self.onClickin3D)
self.accept('escape', sys.exit)
self.accept('z', render.place)
#== UI and Combat ==
self.gameplayUI = GameplayUI(self)
self.gameplayUI.hideAll()
# for health bars and on screen UI
self.overlayAmbientLight = AmbientLight('overlayAmbientLight')
self.overlayAmbientLight.setColor(VBase4(1.0, 1.0, 1.0, 1.0))
self.overlayAmbientLightNP = render.attachNewNode(
self.overlayAmbientLight)
# initialize the combat manager (which includes AI) now that a main character and gameplayUI instance and overlay light is established
self.combatMgr = CombatMgr(self)
# initialize player's spells
self.heroSpells = []
for properties in PLAYER_SPELLS:
spell = Spell(self.hero, properties)
self.heroSpells.append(spell)
#== Start Tasks
taskMgr.add(self.moveHeroTask, 'moveHeroTask', appendTask=True)
taskMgr.add(self.cameraFollowTask, 'cameraFollowTask', appendTask=True)
taskMgr.add(self.processHeroCollisions, 'processHeroCollisions')
taskMgr.add(self.updateHeroHeight, 'updateHeroHeight')
self.combatMgr.startTasks()
self.accept('enter', self.destroyLoadScreen)
self.destroyLoadScreen()
##== Utility and World Initialization functions =============================##
def loadJournal(self, journalMgr, journalFile):
f = open(Filename(journalFile).toOsSpecific())
doc = xml.dom.minidom.parse(f)
root = doc.childNodes[0]
for n in root.childNodes:
if n.localName == "journalEntries":
journalMgr.decode(n)
f.close()
def getModelHeight(self, model):
min, max = Point3(), Point3()
model.calcTightBounds(min, max)
return max.getZ() - min.getZ()
def createLoadScreen(self,
imageFile='./LEGameAssets/Textures/load_screen.png'):
self.loadScreen = OnscreenImage(image=imageFile)
aspect2d.hide()
self.loadScreen.reparentTo(render2d)
if (hasattr(self, "gameplayUI")):
self.gameplayUI.hideAll()
def destroyLoadScreen(self):
self.loadBar.hide()
self.loadScreen.detachNode()
self.loadScreen.destroy()
aspect2d.show()
self.ignore('enter')
self.gameplayUI.showAll()
for name, gameObj in self.gameObjects.iteritems():
gameObj.callTrigger(self, 'LE-trigger-onScene')
def startLoadBar(self, range=100):
self.loadBar.show()
self.loadBar['range'] = range
self.loadBar['value'] = 0
base.graphicsEngine.renderFrame()
def increaseLoadBar(self, value):
self.loadBar['value'] += value
base.graphicsEngine.renderFrame()
##== Collisions =============================================================##
def setupCollisions(self):
self.cTrav = CollisionTraverser('mainTraverser')
self.cTrav.setRespectPrevTransform(True)
# Line collider for setting hero height based on ground geometry
heroLine = CollisionNode('heroLine')
heroLine.addSolid(
CollisionRay(Point3(0, 0, self.heroHeight), Vec3(0, 0, -1)))
heroLine.setFromCollideMask(BITMASK_GROUND)
heroLine.setIntoCollideMask(BitMask32.allOff())
self.heroGroundCollide = render.attachNewNode(heroLine)
self.heroGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroGroundCollide, self.heroGroundHandler)
# cameraSphere = CollisionNode('cameraSphere')
# cameraSphere.addSolid(CollisionSphere(0,0,0,10))
# cameraSphere.setFromCollideMask(BITMASK_CAMERA)
# cameraSphere.setIntoCollideMask(BitMask32.allOff())
# self.cameraSphereCollide = self.cam.attachNewNode(cameraSphere)
# self.cameraSphereQueue = CollisionHandlerQueue()
# self.cTrav.addCollider(self.cameraSphereCollide, self.cameraSphereQueue)
self.herowallcollision = False
self.heroWallCollideX = render.attachNewNode("heroWallX")
self.heroWallCollideY = render.attachNewNode("heroWallY")
self.heroWallCollideZ = render.attachNewNode("heroWallZ")
# Line collider for running into obstacles and walls in X direction
heroLineX = CollisionNode('heroLineX')
heroLineX.addSolid(CollisionRay(Point3(0, 0, 0), Vec3(0, 0, 1)))
self.heroWallCollideLineX = self.heroWallCollideX.attachNewNode(
heroLineX)
self.heroWallCollideLineX.node().setFromCollideMask(
BITMASK_WALL_TERRAIN)
self.heroWallCollideLineX.node().setIntoCollideMask(BitMask32.allOff())
self.heroWallQueueX = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroWallCollideLineX, self.heroWallQueueX)
# Line collider for running into obstacles and walls in Y direction
heroLineY = CollisionNode('heroLineY')
heroLineY.addSolid(CollisionRay(Point3(0, 0, 0), Vec3(0, 0, 1)))
self.heroWallCollideLineY = self.heroWallCollideY.attachNewNode(
heroLineY)
self.heroWallCollideLineY.node().setFromCollideMask(
BITMASK_WALL_TERRAIN)
self.heroWallCollideLineY.node().setIntoCollideMask(BitMask32.allOff())
self.heroWallQueueY = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroWallCollideLineY, self.heroWallQueueY)
# Line collider for running into obstacles and walls in Z direction
heroLineZ = CollisionNode('heroLineZ')
heroLineZ.addSolid(CollisionRay(Point3(0, 0, 0), Vec3(0, 0, 1)))
self.heroWallCollideLineZ = self.heroWallCollideZ.attachNewNode(
heroLineZ)
self.heroWallCollideLineZ.node().setFromCollideMask(
BITMASK_WALL_TERRAIN)
self.heroWallCollideLineZ.node().setIntoCollideMask(BitMask32.allOff())
self.heroWallQueueZ = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroWallCollideLineZ, self.heroWallQueueZ)
# # Sphere collider for running into obstacles and walls
# heroSphere = CollisionNode('heroSphere')
# heroSphere.addSolid(CollisionSphere(0,0,0,7))
# self.heroWallCollide = render.attachNewNode(heroSphere)
# self.heroWallCollide.node().setFromCollideMask(BITMASK_WALL)
# self.heroWallCollide.node().setIntoCollideMask(BitMask32.allOff())
# self.heroWallQueue = CollisionHandlerQueue()
# self.cTrav.addCollider(self.heroWallCollide, self.heroWallQueue)
# self.herowallcollision = False
# Sphere collider for running into obstacles and walls in X direction
heroSphereX = CollisionNode('heroSphereX')
heroSphereX.addSolid(CollisionSphere(0, 0, 0, 7))
self.heroWallCollideSphereX = self.heroWallCollideX.attachNewNode(
heroSphereX)
self.heroWallCollideSphereX.node().setFromCollideMask(BITMASK_WALL)
self.heroWallCollideSphereX.node().setIntoCollideMask(
BitMask32.allOff())
#self.heroWallQueueX = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroWallCollideSphereX,
self.heroWallQueueX)
self.herowallcollision = False
# Sphere collider for running into obstacles and walls in Y direction
heroSphereY = CollisionNode('heroSphereY')
heroSphereY.addSolid(CollisionSphere(0, 0, 0, 7))
self.heroWallCollideSphereY = self.heroWallCollideY.attachNewNode(
heroSphereY)
self.heroWallCollideSphereY.node().setFromCollideMask(BITMASK_WALL)
self.heroWallCollideSphereY.node().setIntoCollideMask(
BitMask32.allOff())
#self.heroWallQueueY = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroWallCollideSphereY,
self.heroWallQueueY)
# Sphere collider for running into obstacles and walls in Z direction
heroSphereZ = CollisionNode('heroSphereZ')
heroSphereZ.addSolid(CollisionSphere(0, 0, 0, 7))
self.heroWallCollideSphereZ = self.heroWallCollideZ.attachNewNode(
heroSphereZ)
self.heroWallCollideSphereZ.node().setFromCollideMask(BITMASK_WALL)
self.heroWallCollideSphereZ.node().setIntoCollideMask(
BitMask32.allOff())
#self.heroWallQueueZ = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroWallCollideSphereZ,
self.heroWallQueueZ)
# Ray collider for clicking on objects in the game
self.pickerCollisionQueue = CollisionHandlerQueue()
self.pickerCN = CollisionNode('pickerRayCN')
self.pickerCNP = self.cam.attachNewNode(self.pickerCN)
self.pickerCN.setFromCollideMask(BITMASK_CLICK)
self.pickerCN.setIntoCollideMask(BitMask32.allOff())
self.pickerRay = CollisionRay()
self.pickerCN.addSolid(self.pickerRay)
self.cTrav.addCollider(self.pickerCNP, self.pickerCollisionQueue)
# Sphere collider for triggering scripts
self.heroCN = CollisionNode('heroCN')
self.heroCN.addSolid(CollisionSphere(0, 0, 0,
5)) # TODO: find good radius
self.heroCNP = self.hero.attachNewNode(self.heroCN)
self.heroCN.setFromCollideMask(BITMASK_HERO_COLLIDE)
self.heroCN.setIntoCollideMask(BitMask32.allOff())
self.heroCollisionQueue = CollisionHandlerQueue()
self.cTrav.addCollider(self.heroCNP, self.heroCollisionQueue)
# Line collider for transparency
self.cameraEntriesPre = []
radius = self.getModelHeight(self.hero) * CAMERA_TRAIL / 2
self.cameraCollisionQueue = CollisionHandlerQueue()
self.cameraHero = CollisionNode('cameraHero')
self.cameraHeroLine = CollisionSegment(self.hero.getPos(render),
self.cam.getPos(render))
self.cameraHero.addSolid(self.cameraHeroLine)
self.cameraHero.setFromCollideMask(BITMASK_CAMERA)
self.cameraHero.setIntoCollideMask(BitMask32.allOff())
self.cameraHeroP = self.render.attachNewNode(self.cameraHero)
self.cTrav.addCollider(self.cameraHeroP, self.cameraCollisionQueue)
#self.cameraHeroP.show()
if FLAG_SHOW_COLLISIONS:
self.cTrav.showCollisions(render)
# TODO: show specific collision nodepaths
def setCollideMasks(self, gameObjDict):
for name, obj in gameObjDict.iteritems():
bitmask = obj.getCollideMask()
if obj.hasTag('LE-ground'):
bitmask |= BITMASK_GROUND
#obj.getNP().setCollideMask(bitmask) # TODO: remove
if obj.hasTag('LE-attackable'):
bitmask |= BITMASK_CLICK
if obj.hasTag('LE-wall'):
if (isinstance(obj.getNP(), GeoMipTerrain)):
bitmask |= BITMASK_TERRAIN
else:
bitmask |= BITMASK_WALL
if obj.scripts.has_key('LE-trigger-onClick'):
bitmask |= BITMASK_CLICK
if obj.scripts.has_key('LE-trigger-onCollision'):
bitmask |= BITMASK_HERO_COLLIDE
if obj.hasTag('OBJRoot'):
if obj.hasTag('LE-ground') or obj.hasTag('LE-mainChar'):
pass
else:
bitmask |= BITMASK_CAMERA
obj.setCollideMask(bitmask)
def onClickin3D(self):
pickedObj = None
if self.conversationMgr.isConversationOpen():
return
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
else:
return
self.cTrav.addCollider(self.pickerCNP, self.pickerCollisionQueue)
self.pickerRay.setFromLens(self.cam.node(), mpos.getX(), mpos.getY())
self.cTrav.traverse(render)
if (self.pickerCollisionQueue.getNumEntries() > 0):
self.pickerCollisionQueue.sortEntries()
for i in range(self.pickerCollisionQueue.getNumEntries()):
parent = self.pickerCollisionQueue.getEntry(
i).getIntoNodePath().getParent()
while not self.objects.has_key(parent.getName()):
if (parent.getName() == "render"):
return
parent = parent.getParent()
pickedObj = parent
if (pickedObj == None):
continue
else:
break
#if pickedObj.hasTag("LE-trigger-onClick"): # TODO: needed, or is having key in self.objects enough?
if (pickedObj == None):
return
self.pickerCollisionQueue.clearEntries()
self.cTrav.removeCollider(self.pickerCNP)
gameObj = self.gameObjects[pickedObj.getName()]
distToTarget = self.hero.getDistance(gameObj)
if self.combatMgr.checkCanAttack(self.hero, gameObj):
if distToTarget <= self.heroSpells[
self.curSpellIndex].getAttackRange():
self.combatMgr.queueAttack(self.hero,
self.heroSpells[self.curSpellIndex],
gameObj)
else:
textObject = OnscreenText(text='The target is out of range!',
fg=(1, 0, 0, 1),
pos=(0, 0),
scale=0.09,
align=TextNode.ACenter)
def destroyWarning1():
textObject.destroy()
sequence = Sequence(Wait(2), Func(destroyWarning1))
sequence.start()
return
elif (distToTarget > CLICK_RANGE):
textObject = OnscreenText(text='The target is out of range!',
fg=(1, 0, 0, 1),
pos=(0, 0),
scale=0.09,
align=TextNode.ACenter)
def destroyWarning2():
textObject.destroy()
sequence = Sequence(Wait(2), Func(destroyWarning2))
sequence.start()
return
gameObj.callTrigger(self, 'LE-trigger-onClick')
# Task for processing hero's collisions with GameObjects, triggering OnCollision scripts
def processHeroCollisions(self, task):
#self.cTrav.traverse(render)
debug("processHeroCollisions")
# CONSIDER: may not be necessary to sort
if (self.heroCollisionQueue.getNumEntries() > 0):
self.heroCollisionQueue.sortEntries()
debug("queue size: " + str(self.heroCollisionQueue.getNumEntries()))
for i in range(self.heroCollisionQueue.getNumEntries()):
# CONSIDER: if entry.hasInto(): for efficiency
debug("i: " + str(i))
# TODO: check if GameObject is passable, and react accordingly (store old position, revert to it)
if (self.heroCollisionQueue.getNumEntries() <= 0):
return
entry = self.heroCollisionQueue.getEntry(i)
debug("entry: " + str(entry))
if (entry):
intoNP = entry.getIntoNodePath()
else:
continue
if (intoNP != None) or (not intoNP.isEmpty()):
while not self.objects.has_key(intoNP.getName()):
if (intoNP.getName() == "render"):
return task.cont
intoNP = intoNP.getParent()
pickedObj = intoNP
if pickedObj == None:
continue
gameObj = self.gameObjects[pickedObj.getName()]
gameObj.callTrigger(self, 'LE-trigger-onCollision')
return task.cont
##== Camera Movement ========================================================##
# places the camera pivot to match the position of the node path parameter
# used to have the camera pivot match the main character's position as he moves
def placeCamera(self, np):
self.camPivot.setX(render, np.getX(render))
self.camPivot.setY(render, np.getY(render))
def alignCamera(self, np):
self.camPivot.setH(render,
self.hero.getH(render) + self.heroHeadingOffset)
self.cam.setP(CAMERA_PITCH)
def cameraFollowTask(self, task):
heroH = self.hero.getH(render) + self.heroHeadingOffset
camPivotH = self.camPivot.getH(render)
# normalizes the headings to avoid jumps in the difference
# which could come from passing 360 and going back to 0, for example
# TODO: stress test, esp. with different values of self.heroHeadingOffset
while heroH + 180 < camPivotH:
heroH += 360
while camPivotH + 180 < heroH:
camPivotH += 360
self.lastHeroH = heroH
rotateLeft = (heroH >= camPivotH)
rotateRight = not rotateLeft
diff = math.fabs(heroH - camPivotH)
if diff > CAMERA_TURN_THRESHOLD:
if rotateLeft:
self.camPivot.setH(self.camPivot.getH() + CAMERA_TURN_SPEED)
elif rotateRight:
self.camPivot.setH(self.camPivot.getH() - CAMERA_TURN_SPEED)
# if(len(self.cameraEntriesPre)>0):
# #print self.cameraEntriesPre
# if(self.hero.getDistance(self.cam) > 5):
# moveAmount = min(globalClock.getDt()*200,5.0)
# pos = self.cam.getQuat().getForward()*moveAmount
# newpos = self.cam.getPos() + pos
# self.oldCameraEntriesPre = []
# for e in self.cameraEntriesPre:
# self.oldCameraEntriesPre.append(e)
# self.cam.setFluidPos(newpos)
#
# else:
# if(self.hero.getDistance(self.cam) < 100):
# moveAmount = min(globalClock.getDt()*200,5.0)
# pos = self.cam.getQuat().getForward()*(-moveAmount)
# oldpos = self.cam.getPos()
# newpos = self.cam.getPos() + pos
# self.cam.setFluidPos(newpos)
# for e in self.oldCameraEntriesPre:
# #print e.getIntoNodePath()
# self.cTrav.traverse(e.getIntoNodePath())
# #self.cTrav.traverse(render)
# if(len(self.cameraSphereQueue.getEntries())>0):
# self.cam.setFluidPos(oldpos)
return task.cont
def runCamera(self, cameraName, sequence, isLoop=False):
debug("Running the camera")
#debug(str(self.sequences))
self.oldCamera = self.cam
self.dr = self.win.makeDisplayRegion()
dr2 = self.cam.node().getDisplayRegion(0) #
self.objects[cameraName].node().setLens(base.camLens)
parent = self.cam.getParent()
self.cam.detachNode()
self.dr.setCamera(self.objects[cameraName])
def temp():
dr2.setCamera(self.oldCamera)
self.oldCamera.reparentTo(parent)
self.dr.setActive(False)
del self.dr
self.dr = None
self.accept("mouse1", self.onClickin3D)
debug("Ran")
if (isLoop):
newSequence = Sequence(sequence)
self.addSequence(newSequence)
def stopCameraFromLoop():
newSequence.finish()
temp()
self.accept("mouse1", stopCameraFromLoop)
self.addSequence(newSequence)
newSequence.loop()
else:
newSequence = Sequence(sequence, Func(temp))
def stopCamera():
newSequence.finish()
self.accept("mouse1", stopCamera)
self.addSequence(newSequence)
newSequence.start()
##== Character Movement =====================================================##
def moveHeroTo(self, destinationObj):
pos = destinationObj.getPos(render)
hpr = destinationObj.getHpr(render)
self.hero.setPosHpr(render, pos, hpr)
self.placeCamera(self.hero)
self.alignCamera(self.hero)
def updateHeroHeight(self, task=None):
groundEntries = []
#move the collision line to the hero position
self.heroGroundCollide.setPos(self.hero.getPos(render))
#loop through every collision entry for the line
for e in self.heroGroundHandler.getEntries():
if e.getIntoNodePath().hasNetTag('OBJRoot'):
#find the actual root of the object
np = e.getIntoNodePath().findNetTag('OBJRoot')
#only react to objects that are tagged as the ground
if np.hasTag('LE-ground'):
groundEntries.append(e)
if groundEntries:
#sort the collision entries based on height
groundEntries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(),\
x.getSurfacePoint(render).getZ()))
#set hero height and pivot height
self.hero.setZ(groundEntries[0].getSurfacePoint(render).getZ() +
MAIN_CHAR_GROUND_OFFSET)
self.camPivot.setZ(
groundEntries[0].getSurfacePoint(render).getZ() +
MAIN_CHAR_GROUND_OFFSET)
# TODO: unlink these from being in the same task in case we want pivot to not be linked to hero (ex. cutscene)
self.heroGroundHandler.clearEntries()
return task.cont
def updateHeroPos(self, queue, stepSize):
wallEntries = []
for w in queue.getEntries():
np = w.getIntoNodePath().findNetTag('OBJRoot')
if np.hasTag('LE-wall'):
if self.isInObstacleRange(self.hero, w, stepSize):
wallEntries.append(w)
if len(wallEntries) > 0:
self.herowallcollision = True
#self.collisionsurfaceP = wallEntries[0].getSurfacePoint(render)
else:
self.herowallcollision = False
def updateCameraCollision(self):
self.cameraHeroLine.setPointA(self.cam.getPos(render))
self.cameraHeroLine.setPointB(self.hero.getPos(render))
if (self.cameraEntriesPre):
for i in self.cameraEntriesPre:
i.getIntoNodePath().setTransparency(TransparencyAttrib.MAlpha)
i.getIntoNodePath().setAlphaScale(1.0)
del self.cameraEntriesPre[:]
for i in self.cameraCollisionQueue.getEntries():
i.getIntoNodePath().setAlphaScale(0.5)
self.cameraEntriesPre.append(i)
def moveHero(self, direction, dt):
temp = render.attachNewNode("Dummy") #NodePath()
moveStep = MAIN_CHAR_MOVE_SPEED * dt
if moveStep > MAIN_CHAR_MAX_STEP:
moveStep = MAIN_CHAR_MAX_STEP
temp.setPos(self.camPivot, 0, direction * moveStep, 0)
#oldPos = self.heroWallCollideX.getPos()
self.heroWallCollideX.setX(temp.getX())
self.heroWallCollideY.setY(temp.getY())
self.heroWallCollideZ.setZ(temp.getZ()) #+10)
self.cTrav.traverse(render)
#check on X direction
self.updateHeroPos(self.heroWallQueueX, moveStep)
self.moveHeroToWallCollide(
Point3(temp.getX(), self.hero.getY(), self.hero.getZ()))
#check on Y direction
self.updateHeroPos(self.heroWallQueueY, moveStep)
self.moveHeroToWallCollide(
Point3(self.hero.getX(), temp.getY(), self.hero.getZ()))
#check on Z direction
self.updateHeroPos(self.heroWallQueueZ, moveStep)
self.moveHeroToWallCollide(
Point3(self.hero.getX(), self.hero.getY(), temp.getZ()))
self.heroWallCollideX.setPos(self.hero.getPos())
self.heroWallCollideY.setPos(self.hero.getPos())
self.heroWallCollideZ.setPos(self.hero.getPos())
self.placeCamera(self.hero)
self.updateCameraCollision()
temp.detachNode()
def moveHeroToWallCollide(self, pos):
if self.herowallcollision == False:
self.hero.setPos(pos) #self.camPivot, 0, MAIN_CHAR_MOVE_SPEED, 0)
def isInObstacleRange(self, mover, colEntry, stepSize):
colPoint = colEntry.getSurfacePoint(render)
if colPoint[2] >= mover.getZ(render):
dist = findDistance3D(mover.getX(), mover.getY(), mover.getZ(),
colPoint[0], colPoint[1], colPoint[2])
obstacleThreshold = self.heroHeight * self.heroHeight + stepSize * stepSize
if dist * dist <= obstacleThreshold:
return True
return False
def turnHeroLeft(self):
up = render.getRelativeVector(base.cam, Vec3(0, 0, 1))
up.normalize()
curHeroQuat = self.hero.getQuat()
newHeroQuat = Quat()
newHeroQuat.setFromAxisAngle(MAIN_CHAR_ROTATE_SPEED, up)
self.hero.setQuat(curHeroQuat * newHeroQuat)
self.hero.setR(0)
self.hero.setP(0)
self.updateCameraCollision()
def turnHeroRight(self):
up = render.getRelativeVector(base.cam, Vec3(0, 0, 1))
up.normalize()
curHeroQuat = self.hero.getQuat()
newHeroQuat = Quat()
newHeroQuat.setFromAxisAngle(-MAIN_CHAR_ROTATE_SPEED, up)
self.hero.setQuat(curHeroQuat * newHeroQuat)
self.hero.setR(0)
self.hero.setP(0)
self.updateCameraCollision()
def disableMovement(self, gameObj):
if gameObj.getName() == self.hero.getName():
self.ignore('w')
self.ignore('w-up')
self.ignore('a')
self.ignore('a-up')
self.ignore('s')
self.ignore('s-up')
self.ignore('d')
self.ignore('d-up')
else:
if gameObj.getAIBehaviorsHandle().behaviorStatus('pursue') != -1:
gameObj.getAIBehaviorsHandle().pauseAi('pursue')
def enableMovement(self, gameObj):
if gameObj.getName() == self.hero.getName():
self.accept('w', self.setKeyStatus, extraArgs=['w', True])
self.accept('w-up', self.setKeyStatus, extraArgs=['w', False])
self.accept('a', self.setKeyStatus, extraArgs=['a', True])
self.accept('a-up', self.setKeyStatus, extraArgs=['a', False])
self.accept('s', self.setKeyStatus, extraArgs=['s', True])
self.accept('s-up', self.setKeyStatus, extraArgs=['s', False])
self.accept('d', self.setKeyStatus, extraArgs=['d', True])
self.accept('d-up', self.setKeyStatus, extraArgs=['d', False])
else:
if gameObj.getAIBehaviorsHandle().behaviorStatus(
'pursue') == 'paused':
gameObj.getAIBehaviorsHandle().resumeAi('pursue')
def setKeyStatus(self, key, isDown):
self.keyMap[key] = isDown
print self.hero.getName()
######################################################################
## # ZJC - 07/29/2011: THIS CODE WAS COMMENTED OUT BECAUSE A MORE EFFICIENT WAY WAS FOUND
##
## prefixList = []
## #NEXT LINE- ZJC - 07/29/2011: This line is used to mark where to import the array used to deal with import flags.
## #LoaderFlagImportArray
## name = self.hero.getName().split('_')[0] # ZJC - 07/29/2011: name is assumed to be formatted NAME_otherstuff
## name2 = self.hero.getName().split('_')[1] # ZJC - 07/29/2011: name2 is assumed to be PREFIX_NAME_otherstuff
## if name in prefixList: # ZJC - 07/29/2011: Checks if the name is in the array, if it is name is not formatted as assumed
## name = name2 # ZJC - 07/29/2011: Use the second format if the first name is in the list
## print name
######################################################################
name = self.hero.getName().split('_')[
0] # ZJC - 07/29/2011: Assumes format is Name_mod:#
## print name
for i in range(
len(self.here.getName().split('_'))
): # ZJC - 07/29/2011: Loop will check every possibility in the name string for any level of merges/imports
name2 = self.hero.getName().split(
'_'
)[i] # ZJC - 07/29/2011: name2 holds the current piece of the name string
if ("mod:" in name2) and (
name != name2
): # ZJC - 07/29/2011: This means the name format is Prefix(es)_Name_mod:#
name = self.hero.getName().split(
'_'
)[i -
1] # ZJC - 07/29/2011: Assigns correct model name, the one just before mod:#
if isDown:
if key == 'w':
if self.hero.getActorHandle() != None:
self.hero.getActorHandle().stop(
name + '_ani_idle'
) # ZJC - 07/26/2011: Stop the 'name' specific idle animation
self.hero.getActorHandle().setPlayRate(
1.0, name + '_ani_run'
) # ZJC - 07/26/2011: Set play rate for the 'name' specific run animation
self.hero.getActorHandle().loop(
name + '_ani_run'
) # ZJC - 07/26/2011: Run the 'name' specific run animation
self.keyMap['s'] = False
elif key == 's':
if self.hero.getActorHandle() != None:
self.hero.getActorHandle().stop(
name + '_ani_idle'
) # ZJC - 07/26/2011: Stop the 'name' specific idle animation
self.hero.getActorHandle().setPlayRate(
-0.7, name + '_ani_run'
) # ZJC - 07/26/2011: Set play rate for the 'name' specific run animation
self.hero.getActorHandle().loop(
name + '_ani_run'
) # ZJC - 07/26/2011: Run the 'name' specific run animation
self.keyMap['w'] = False
elif key == 'a':
self.keyMap['d'] = False
elif key == 'd':
self.keyMap['a'] = False
elif not isDown:
if key == 'w':
if not self.keyMap['s']:
if self.hero.getActorHandle() != None:
self.hero.getActorHandle().stop(
name + '_ani_run'
) # ZJC - 07/26/2011: Stop the 'name' specific run animation
self.hero.getActorHandle().loop(
name + '_ani_idle'
) # ZJC - 07/26/2011: Run the 'name' specific idle animation
elif key == 's':
if not self.keyMap['w']:
if self.hero.getActorHandle() != None:
self.hero.getActorHandle().stop(
name + '_ani_run'
) # ZJC - 07/26/2011: Stop the 'name' specific run animation
self.hero.getActorHandle().loop(
name + '_ani_idle'
) # ZJC - 07/26/2011: Run the 'name' specific idle animation
elif key == 'a':
pass
elif key == 'd':
pass
## ZJC - 07/26/2011: This was the previous version of the code, it has been commented out and left as
## a reference. The changes made are defined in the comments above.
## if isDown:
## if key == 'w':
## if self.hero.getActorHandle() != None:
## self.hero.getActorHandle().stop('anim_idleFemale') # TODO: make a constant / set in LE
## self.hero.getActorHandle().setPlayRate(1.0, 'anim_jogFemale')
## self.hero.getActorHandle().loop('anim_jogFemale')
## self.keyMap['s'] = False
## elif key == 's':
## if self.hero.getActorHandle() != None:
## self.hero.getActorHandle().stop('anim_idleFemale') # TODO: make a constant / set in LE
## self.hero.getActorHandle().setPlayRate(-0.7, 'anim_jogFemale')
## self.hero.getActorHandle().loop('anim_jogFemale')
## self.keyMap['w'] = False
## elif key == 'a':
## self.keyMap['d'] = False
## elif key == 'd':
## self.keyMap['a'] = False
## elif not isDown:
## if key == 'w':
## if not self.keyMap['s']:
## if self.hero.getActorHandle() != None:
## self.hero.getActorHandle().stop('anim_jogFemale')
## self.hero.getActorHandle().loop('anim_idleFemale')
## elif key == 's':
## if not self.keyMap['w']:
## if self.hero.getActorHandle() != None:
## self.hero.getActorHandle().stop('anim_jogFemale')
## self.hero.getActorHandle().loop('anim_idleFemale')
## elif key == 'a':
## pass
## elif key == 'd':
## pass
def moveHeroTask(self, task):
dt = globalClock.getDt()
direction = int(self.keyMap['w']) - int(self.keyMap['s'])
self.moveHero(direction, dt)
if self.keyMap['a']:
self.turnHeroLeft()
elif self.keyMap['d']:
self.turnHeroRight()
return task.cont
##== Scene Handling =========================================================##
def loadScenes(self):
# NOTE: Do not remove! This function is populated by StandaloneExporter
pass
def addSequence(self, sequence):
self.ranSequences.append(sequence)
#this is for changing scenes
def resetAllSequences(self):
for seq in self.ranSequences:
seq.finish()
dr = self.cam.node().getDisplayRegion(0)
dr.setCamera(self.gameCam)
self.ranSequences = []
def openScene(self, sceneName):
if (self.scenes.has_key(sceneName) == False):
print "ERROR:There is no scene under the name ", sceneName, "."
return
self.startLoadBar(12)
self.createLoadScreen()
#Part2:Clear all of the collision lists
self.cTrav.removeCollider(self.heroCNP)
self.heroGroundHandler.clearEntries()
self.heroCollisionQueue.clearEntries()
self.resetAllSequences()
self.increaseLoadBar(1)
#Part3: stop all of the tasks
taskMgr.remove('processHeroCollisions')
taskMgr.remove('updateHeroHeight')
taskMgr.remove('moveHeroTask')
taskMgr.remove('cameraFollowTask')
taskMgr.remove("updateShaders") # ?
self.combatMgr.stopTasks()
self.gameplayUI.stop()
self.gameplayUI.removeAllHealthBars()
self.increaseLoadBar(1)
#Part1.1: Stop currently running parts like conversations or camera
if (self.conversationMgr.isConversationOpen()):
self.conversationMgr.closeConversation()
#Part 1.2: stop the camera
self.increaseLoadBar(1)
#Part4: Turn-Off all of the player controls
self.ignore("mouse1")
self.increaseLoadBar(1)
#Part5: Remove all of the game elements that are related with the current scene
del self.combatMgr
self.increaseLoadBar(1)
#Part6: Remove all of the children and the lights from the render
render.getChildren().detach()
render.clearLight()
self.increaseLoadBar(1)
#Part7:Add the camera and hero or any game element that should be exist in any scene back
self.camPivot.reparentTo(render)
self.hero.reparentTo(render)
#self.heroWallCollide.reparentTo(render)
self.heroWallCollideX.reparentTo(render)
self.heroWallCollideY.reparentTo(render)
self.heroWallCollideZ.reparentTo(render)
self.heroGroundCollide.reparentTo(render)
self.cameraHeroP.reparentTo(render)
self.overlayAmbientLightNP.reparentTo(render)
self.increaseLoadBar(1)
#Part8:Add the new objects from the new scene
self.assets, self.objects, self.gameObjects, self.sounds, self.sequences = loadWorld(
self.scenes[sceneName], LIBRARY_INDEX)
self.increaseLoadBar(1)
#Part9:Add the hero to the new gameObject list and remove the duplicates of the hero
self.gameObjects[self.hero.getName()] = self.hero
if (self.objects.has_key(self.hero.getName())):
object = self.objects[self.hero.getName()]
if (object.hasTag('LE-mainChar')):
object.detachNode()
del self.objects[self.hero.getName()]
for name, gameObj in self.gameObjects.iteritems():
if gameObj.getNP().hasTag('LE-ground'):
#debug("is Ground")
bitmask = gameObj.getNP().getCollideMask()
bitmask |= BITMASK_GROUND
gameObj.getNP().setCollideMask(bitmask)
self.increaseLoadBar(1)
#Part10:Restart the tasks.
self.combatMgr = CombatMgr(self)
taskMgr.add(self.processHeroCollisions, 'processHeroCollisions')
taskMgr.add(self.updateHeroHeight, 'updateHeroHeight')
taskMgr.add(self.moveHeroTask, 'moveHeroTask')
taskMgr.add(self.cameraFollowTask, 'cameraFollowTask')
self.combatMgr.startTasks()
self.gameplayUI.start()
self.increaseLoadBar(1)
self.setCollideMasks(self.gameObjects)
self.increaseLoadBar(1)
#Part11: Change the color of the sky
if (sceneName.startswith("interior")
or sceneName.startswith("Interior")):
self.setBackgroundColor(BGC_DARK_GREY)
else:
self.skybox.reparentTo(render)
self.setBackgroundColor(BGC_LIGHT_BLUE)
self.increaseLoadBar(1)
#Part12: Restart the player controls
self.accept("mouse1", self.onClickin3D)
self.increaseLoadBar(1)
self.accept("enter", self.destroyLoadScreen)
debug("After open Scene: " +
str(self.heroCollisionQueue.getNumEntries()))
self.heroCollisionQueue.clearEntries()
self.cTrav.addCollider(self.heroCNP, self.heroCollisionQueue)
self.destroyLoadScreen()
class World:
def __init__(self):
base.disableMouse()
# Turns off the default mouse-camera controls in Panda3D.
base.setBackgroundColor(0, 0, 0)
# Sets the background to black.
self.inputManager = InputManager()
# Creates an InputManager to handle all of the user input in the game.
#taskMgr.doMethodLater(10, self.debugTask, "Debug Task")
# Tells the debugTask to run once every ten seconds. The debug task is a good
# place to put various data print outs about the game to help with debugging.
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setBloom(blend=(0, 0, 0, 1),
desat=-0.5,
intensity=3.0,
size=2)
# Creates a bloom filter that will integrate with the Glow maps applied to objects to create
# the halos around glowing objects.
render.setShaderAuto()
# Turns on Panda3D's automatic shader generation.
self.menuGraphics = loader.loadModel("../Models/MenuGraphics.egg")
# Loads the egg that contains all the menu graphics.
self.fonts = {
"silver": loader.loadFont("../Fonts/LuconSilver.egg"),
"blue": loader.loadFont("../Fonts/LuconBlue.egg"),
"orange": loader.loadFont("../Fonts/LuconOrange.egg")
}
# Loads the three custom fonts our game will use.
preloader = Preloader(self.fonts)
hud = HUD(self.fonts)
# Creates the HUD.
self.race = Race(self.inputManager, hud)
self.race.createDemoRace()
# creates an instance of the race class and tells it to
# start a demo race.
self.createStartMenu()
# creates the start menu.
musicMgr = base.musicManager
self.music = musicMgr.getSound(
"../Sound/Loveshadow-Takin_Yo_Time_(The_Wingman_Mix).wav")
self.music.setLoop(True)
self.music.setVolume(.5)
self.music.play()
# loads a sound file for the background music, sets it to loop, and plays it.
def createStartMenu(self):
menu = Menu(self.menuGraphics, self.fonts, self.inputManager)
menu.initMenu([
0,
None,
["New Game", "Quit Game"], # The two options the menu will have.
[
[self.race.createRace, self.createReadyDialogue
], # functions executed by the first option.
[base.userExit]
], # function executed by the second option.
[[None, None], [None]]
]) # The arguments to be passed to the functions.
# createStartMenu: Creates a new menu to be used as the start menu.
def createReadyDialogue(self):
menu = Menu(self.menuGraphics, self.fonts, self.inputManager)
menu.initMenu([
3,
"Are you ready?",
["Yes", "Exit"], # The two options the menu will have.
[[self.race.startRace],
[self.race.createDemoRace]], # functions executed by the options.
[[3], [None]]
]) # The arguments to be passed to the functions.
# createReadyDialogue: Creates a new menu to be used as dialogue box that querries if the player is ready or not.
def debugTask(self, task):
print(taskMgr)
# prints all of the tasks in the task manager.
return task.again
class GlowDemo(ShowBase):
def __init__(self):
# Initialize the ShowBase class from which we inherit, which will
# create a window and set up everything we need for rendering into it.
ShowBase.__init__(self)
base.disableMouse()
base.setBackgroundColor(0, 0, 0)
camera.setPos(0, -50, 0)
# Check video card capabilities.
if not base.win.getGsg().getSupportsBasicShaders():
addTitle(
"Glow Filter: Video driver reports that Cg shaders are not supported.")
return
# Use class 'CommonFilters' to enable a bloom filter.
# The brightness of a pixel is measured using a weighted average
# of R,G,B,A. We put all the weight on Alpha, meaning that for
# us, the framebuffer's alpha channel alpha controls bloom.
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setBloom(
blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size="small")
if (filterok == False):
addTitle(
"Toon Shader: Video card not powerful enough to do image postprocessing")
return
self.glowSize = 1
# Post the instructions
self.title = addTitle("Panda3D: Tutorial - Glow Filter")
self.inst1 = addInstructions(0.06, "ESC: Quit")
self.inst2 = addInstructions(0.12, "Space: Toggle Glow Filter Small/Med/Large/Off")
self.inst3 = addInstructions(0.18, "Enter: Toggle Running/Spinning")
self.inst4 = addInstructions(0.24, "V: View the render-to-texture results")
# load our model
self.tron = Actor()
self.tron.loadModel("models/tron")
self.tron.loadAnims({"running": "models/tron_anim"})
self.tron.reparentTo(render)
self.interval = self.tron.hprInterval(60, LPoint3(360, 0, 0))
self.interval.loop()
self.isRunning = False
# put some lighting on the model
dlight = DirectionalLight('dlight')
alight = AmbientLight('alight')
dlnp = render.attachNewNode(dlight)
alnp = render.attachNewNode(alight)
dlight.setColor((1.0, 0.7, 0.2, 1))
alight.setColor((0.2, 0.2, 0.2, 1))
dlnp.setHpr(0, -60, 0)
render.setLight(dlnp)
render.setLight(alnp)
# Panda contains a built-in viewer that lets you view the results of
# your render-to-texture operations. This code configures the viewer.
self.accept("v", base.bufferViewer.toggleEnable)
self.accept("V", base.bufferViewer.toggleEnable)
base.bufferViewer.setPosition("llcorner")
base.bufferViewer.setLayout("hline")
# base.camLens.setFov(100)
# event handling
self.accept("space", self.toggleGlow)
self.accept("enter", self.toggleDisplay)
self.accept("escape", sys.exit, [0])
def toggleGlow(self):
self.glowSize = self.glowSize + 1
if self.glowSize == 4:
self.glowSize = 0
self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0,
size=self.glowSize)
def toggleDisplay(self):
self.isRunning = not self.isRunning
if not self.isRunning:
camera.setPos(0, -50, 0)
self.tron.stop("running")
self.tron.pose("running", 0)
self.interval.loop()
else:
camera.setPos(0, -170, 3)
self.interval.finish()
self.tron.setHpr(0, 0, 0)
self.tron.loop("running")
class MainApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
# Load shaders. If this fails, quit.
if(not self.loadShaders()):
return
#Make some floors for us :)
floorTex=loader.loadTexture('maps/envir-ground.jpg')
cm=CardMaker('')
cm.setFrame(-2,2,-2,2)
floor = render.attachNewNode(PandaNode("floor"))
for y in range(12):
for x in range(12):
nn = floor.attachNewNode(cm.generate())
nn.setP(-90)
nn.setPos((x-6)*4, (y-6)*4, 0)
floor.setTexture(floorTex)
floor.flattenStrong()
# set up shaders and anti alias
self.render.setShaderAuto()
self.render.setAntialias(AntialiasAttrib.MAuto)
# set up lights
dlight = DirectionalLight('dlight')
alight = AmbientLight('alight')
dlnp = render.attachNewNode(dlight)
alnp = render.attachNewNode(alight)
dlight.setColor(Vec4(1.0, 0.7, 0.2, 1))
alight.setColor(Vec4(0.2, 0.2, 0.2, 1))
dlnp.setHpr(0, -60, 0)
render.setLight(dlnp)
render.setLight(alnp)
# Models
#Tron
self.pandaActor = Actor("models/tron")
self.pandaActor.setScale(0.3, 0.3, 0.3)
self.pandaActor.reparentTo(self.render)
self.pandaActor.setPos(10, 0, 4.2)
#Panda
# Load the "panda" model. Loading a model returns a
# NodePath object.
##self.panda = loader.loadModel("panda")
# Remember, loaded objects start out hidden! If we want to
# see the panda, it must be reparented to the "render" node.
##self.panda.reparentTo(render)
# By default, position is specified relative to a node's
# parent.Position is specified as "x,y,z" or "right, forward, up"
# Since panda's parent is the root node (render),
# this command moves panda to the global position (0, 30, -5).
##self.panda.setPos(0, 0, 0)
# Alternately, the position can be given relative to any other
# NodePath. Here, we set the position to be 30 feet in front
# of the camera, and slightly to the right. Note the use of
# 'camera', another pre-defined NodePath object.
##self.panda.setX(camera, 10)
# Text
self.text = TextNode('node name')
self.textNodePath = aspect2d.attachNewNode(self.text)
self.textNodePath.setScale(0.05)
self.text.setTextColor(1, 1, 1, 1)
# enable physics
base.enableParticles()
self.physicsNode=NodePath(PandaNode("PhysicsNode"))
self.physicsNode.reparentTo(render)
# set up camera with physics
self.cameraActorNode=ActorNode("camera-physics")
self.cameraActorNodeParent=self.physicsNode.attachNewNode(self.cameraActorNode)
base.physicsMgr.attachPhysicalNode(self.cameraActorNode)
self.camera.reparentTo(self.cameraActorNodeParent)
# set up camera and mouse settings
self.camera.setPos(6.27662, -48.9656, 26.0119)
self.camera.setHpr(7.30458, -27.7855, 3.34447)
self.cameraInterval = self.camera.posInterval(10,
Point3(10,10,20),
startPos=Point3(camera.getPos()))
self.cameraPace = Sequence(self.cameraInterval)
self.cameraForwardThrottleEnabled = False
#self.cameraPace.start()
# disable debug mode for starters
self.setDebugMode(False)
# event handling
self.accept("space", self.toggleGlow)
self.accept("escape", sys.exit, [0])
self.accept('o', self.toggleDebugMode)
self.accept('p', self.pauseSequence)
self.accept('w', self.moveForward)
self.accept('a', self.moveLeft)
self.accept('d', self.moveRight)
self.accept('s', self.moveBack)
self.accept('arrow_up', self.enableCameraForwardThrottle)
self.accept('arrow_up-up', self.disableCameraForwardThrottle)
# add tasks
self.taskMgr.add(self.doLogic, "DoLogic")
# self.taskMgr.add(self.refreshGUI, "RefreshGUI")
def enableCameraForwardThrottle(self):
self.cameraForwardThrottleEnabled = True
def disableCameraForwardThrottle(self):
self.cameraForwardThrottleEnabled = False
def refreshGUI(self, task):
string = str(self.pandaActor.getPos())
self.text.setText(string)
self.text.setCardColor(0, 0, 0, 0.5)
self.text.setCardAsMargin(0, 0, 0, 0)
return task.cont
def moveForward(self):
currentPosition = self.pandaActor.getPos()
newPosition = Point3(0,2,0) + currentPosition
pandaMoveForwardInterval = self.pandaActor.posInterval(0.1,
Point3(newPosition),
startPos=Point3(currentPosition))
self.pandaPace = Sequence(pandaMoveForwardInterval)
self.pandaPace.start()
return currentPosition
def moveBack(self):
currentPosition = self.pandaActor.getPos()
newPosition = Point3(0,-2,0) + currentPosition
pandaMoveForwardInterval = self.pandaActor.posInterval(0.1,
Point3(newPosition),
startPos=Point3(currentPosition))
self.pandaPace = Sequence(pandaMoveForwardInterval)
self.pandaPace.start()
return currentPosition
def moveLeft(self):
currentPosition = self.pandaActor.getPos()
newPosition = Point3(-2,0,0) + currentPosition
pandaMoveForwardInterval = self.pandaActor.posInterval(0.1,
Point3(newPosition),
startPos=Point3(currentPosition))
self.pandaPace = Sequence(pandaMoveForwardInterval)
self.pandaPace.start()
return currentPosition
def moveRight(self):
currentPosition = self.pandaActor.getPos()
newPosition = Point3(2,0,0) + currentPosition
pandaMoveForwardInterval = self.pandaActor.posInterval(0.1,
Point3(newPosition),
startPos=Point3(currentPosition))
self.pandaPace = Sequence(pandaMoveForwardInterval)
self.pandaPace.start()
return currentPosition
def pauseSequence(self):
self.pandaPace.pause()
def doLogic(self, task):
dt = globalClock.getDt()
# this method is a placeholder to test if differnt stuff has occured
# like checking wether the robot is ready for a new command, etc.
if self.cameraForwardThrottleEnabled:
currentVelocity = self.cameraActorNode.getPhysicsObject().getVelocity()
newVelocity = currentVelocity + Vec3(dt*250,0,0)
self.cameraActorNode.getPhysicsObject().setVelocity(newVelocity)
# slow down camera ("friction")
self.cameraActorNode.getPhysicsObject().setVelocity(self.cameraActorNode.getPhysicsObject().getVelocity() * 0.92)
return Task.cont
def toggleGlow(self):
self.glowSize = self.glowSize + 1
if (self.glowSize == 4): self.glowSize = 0
self.filters.setBloom(blend=(0,0,0,1), desat=-0.5, intensity=3.0, size=self.glowSize)
print "Glow size set to", self.glowSize
def printCameraPosition(self):
print self.camera.getPos()
print self.camera.getHpr()
def toggleDebugMode(self):
if(self.debugMode):
self.setDebugMode(False)
else:
self.setDebugMode(True)
def setDebugMode(self, enabled):
self.debugMode = enabled
if(enabled):
self.enableMouse()
self.accept('c', self.printCameraPosition)
else:
self.disableMouse()
self.ignore('c')
def loadShaders(self):
# Check video card capabilities for shaders.
if (base.win.getGsg().getSupportsBasicShaders() == 0):
addTitle("Glow Filter: Video driver reports that shaders are not supported.")
return False
# Load filters
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setBloom(blend=(0,0,0,1), desat=-0.5, intensity=3.0, size="small")
if (filterok == False):
addTitle("Toon Shader: Video card not powerful enough to do image postprocessing")
return False
self.glowSize=1
# Shadow shaders
# TODO: Implement shadows
return True
def __init__(self):
self.height = 500
super().__init__(self)
self.scene = self.loader.loadModel("./models/world.egg")
playerTexture = loader.loadTexture("models/starfoxShip.jpg")
enemyTexture = loader.loadTexture("models/enemyShip.jpg")
bulletTexture = loader.loadTexture("models/shot.png")
self.scene.reparentTo(self.render)
base.setBackgroundColor(0.1, 0.1, 0.1, 1)
self.player = self.scene.find("player")
self.player.setPythonTag("ObjectController", Player(self.player))
self.player.setTexture(playerTexture)
self.building_enemy = self.scene.find("building_enemy")
self.dynamic_enemy = self.scene.find("enemy1")
self.dynamic_enemy.setTexture(enemyTexture)
self.bullet = self.scene.find("bullet")
self.bullet.setTexture(bulletTexture)
base.cTrav = CollisionTraverser()
self.CollisionHandlerEvent = CollisionHandlerEvent()
base.enableParticles()
self.CollisionHandlerEvent.addInPattern('into-%in')
self.CollisionHandlerEvent.addOutPattern('out-%in')
self.accept('into-collision_player', self.crash)
self.accept('into-collision_plane', self.crash)
self.accept('into-collision_enemy', self.crash)
base.cTrav.addCollider(self.scene.find("player/collision**"),
self.CollisionHandlerEvent)
base.cTrav.addCollider(self.scene.find("basePlane/collision**"),
self.CollisionHandlerEvent)
self.player.find("**collision**").node().setFromCollideMask(0x3)
self.player.find("**collision**").node().setIntoCollideMask(0x3)
self.dynamic_enemy.find("**collision**").node().setFromCollideMask(0x5)
self.dynamic_enemy.find("**collision**").node().setIntoCollideMask(0x5)
self.building_enemy.find("**collision**").node().setFromCollideMask(
0x5)
self.building_enemy.find("**collision**").node().setIntoCollideMask(
0x5)
#base.cTrav.showCollisions(self.render)
self.taskMgr.add(self.update, "update")
InputManager.initWith(self, [
InputManager.arrowUp, InputManager.arrowDown,
InputManager.arrowLeft, InputManager.arrowRight,
InputManager.space, InputManager.keyX, InputManager.keyV
])
self.rails = self.scene.attachNewNode("rails")
self.scene.find("basePlane").setHpr(70, 0, 0)
self.rails.setPos(self.scene, 0, 0, 0)
self.player.reparentTo(self.rails)
self.player.setPos(self.rails, 0, 0, 0)
self.rails_y = -50
self.createStaticEnemy(self.building_enemy, 0, 50, 0)
self.createStaticEnemy(self.building_enemy, -50, 50, 0)
self.createStaticEnemy(self.building_enemy, -100, 50, 0)
self.createStaticEnemy(self.building_enemy, -70, 130, 0)
self.createStaticEnemy(self.building_enemy, -120, 80, 0)
self.createStaticEnemy(self.building_enemy, -220, 130, 0)
DynamicEnemy(self.dynamic_enemy,
self.scene,
Vec3(-230, 140, 10),
base.cTrav,
self.CollisionHandlerEvent,
type=ENEMY_TYPE.CHASER)
#DynamicEnemy(self.dynamic_enemy, self.scene, Vec3(-240,160,10) , base.cTrav, self.CollisionHandlerEvent)
#DynamicEnemy(self.dynamic_enemy, self.scene, Vec3(-250,200,10) , base.cTrav, self.CollisionHandlerEvent)
#DynamicEnemy(self.dynamic_enemy, self.scene, Vec3(-270,160,10) , base.cTrav, self.CollisionHandlerEvent)
#DynamicEnemy(self.dynamic_enemy, self.scene, Vec3(-250,200,10) , base.cTrav, self.CollisionHandlerEvent)
self.building_enemy.hide()
self.dynamic_enemy.hide()
self.fog = Fog("fog")
self.fog.setColor(0.1, 0.1, 0.1)
self.fog.setExpDensity(.3)
self.fog.setLinearRange(50, 150)
self.fog.setLinearFallback(45, 160, 320)
self.render.setFog(self.fog)
self.dirLight = DirectionalLight("dir light")
self.dirLight.color = (0.7, 0.7, 1, 1)
self.dirLightPath = self.render.attachNewNode(self.dirLight)
self.dirLightPath.setHpr(45, -45, 0)
self.dirLight.setShadowCaster(True, 512, 512)
render.setLight(self.dirLightPath)
filters = CommonFilters(base.win, base.cam)
filters.setBloom(size="large", mintrigger=0.2)
self.render.setShaderAuto()
self.initSounds()
self.initUI()
self.onGame = False
class Engine(ShowBase):
def __init__(self, mouse):
ShowBase.__init__(self)
self.mouse = mouse
self.joy_x = None
self.joy_y = None
props = WindowProperties()
props.setMouseMode(WindowProperties.MRelative) # keep mouse in screen
self.disableMouse()
self.win.requestProperties(props)
self.setBackgroundColor(0, 0, 0)
# Make missiles glow
self.filters = CommonFilters(self.win, self.cam)
self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size="large")
self.screen_width = self.win.getXSize()
self.screen_height = self.win.getYSize()
self.center_x = self.screen_width/2
self.center_y = self.screen_height/2
# self.win.movePointer(0, self.center_x, self.center_y)
self.enableParticles()
self.cTrav = CollisionTraverser()
# self.cTrav.setRespectPrevTransform(True)
self.pusher = PhysicsCollisionHandler()
self.pusher.addInPattern('%fn-into-%in')
self.target = None
self.maxvel = 50
self.roll_time = 0
self.fuel = 1000
self.ship()
self.sounds()
self.hud()
self.part = Spacedust(self)
self.events()
self.camLens.setFov(70)
self.camLens.setNear(1)
self.camLens.setFar(500)
self.get_key = {
"ACCEL": False,
"DECEL": False,
"FORWARD_THRUST": False,
"REVERSE_THRUST": False,
"ROLL_LEFT": False,
"ROLL_RIGHT": False,
"ROLL_LEFT_BEG": False,
"ROLL_RIGHT_BEG": False,
"FIRE": False,
"FIRING": False,
"LOCK": False,
"LOCKING": False,
}
self.AIworld = AIWorld(self.render)
self.taskMgr.add(self.update, "task-update")
self.taskMgr.doMethodLater(1, self.fuel_usage, "task-fuel-usage")
self.taskMgr.add(self.AI_update, "AI-update")
self.gen_enemy()
def gen_enemy(self):
x = randint(-1000, 1000)
y = randint(-1000, 1000)
z = randint(-1000, 1000)
Enemy(self, 0, x, y, z)
def AI_update(self, task):
self.AIworld.update()
return task.cont
def hud(self):
self.font = self.loader.loadFont("./fnt/subatomic.tsoonami.ttf")
self.aim = OnscreenImage(image="./png/ring.png", pos=Vec3(0), scale=0.02)
self.aim.setTransparency(TransparencyAttrib.MAlpha)
self.locker = OnscreenImage(image="./png/ring.png", pos=Vec3(0), scale=0.12)
self.locker.setTransparency(TransparencyAttrib.MAlpha)
self.locker.hide()
self.txtFuel = OnscreenText(parent=self.render2d, align=TextNode.ALeft, pos=(-0.95, 0.8), text='FUEL', fg=(1, 1, 1, 0.5), scale=0.05, font=self.font, mayChange=True)
self.txtSpeed = OnscreenText(parent=self.render2d, align=TextNode.ALeft, pos=(-0.95, 0.7), text='SPEED', fg=(1, 1, 1, 0.5), scale=0.05, font=self.font, mayChange=True)
self.txtDist = OnscreenText(parent=self.render2d, align=TextNode.ALeft, pos=(-0.95, 0.6), text='DIST', fg=(1, 1, 1, 0.5), scale=0.05, font=self.font, mayChange=True)
self.txtCoord = OnscreenText(parent=self.render2d, align=TextNode.ALeft, pos=(-0.95, 0.5), text='COORD', fg=(1, 1, 1, 0.5), scale=0.05, font=self.font, mayChange=True)
self.taskMgr.doMethodLater(1, self.instruments, "task-instruments")
def instruments(self, task):
self.txtSpeed.setText("SPEED: %s" % str(int(self.mvel)))
self.txtFuel.setText("FUEL: %s" % str(self.fuel))
if self.target is not None:
self.txtDist.setText("DISTANCE: %s" % str(round(self.dist, 1)))
else:
self.txtDist.setText("DISTANCE: ---")
self.txtCoord.setText("COORD: %s %s %s" % (str(round(self.fighter.getX(), 1)), str(round(self.fighter.getY(), 1)), str(round(self.fighter.getZ(), 1))))
return task.again
def set_key(self, key, value):
self.get_key[key] = value
def toggle_key(self, key):
self.set_key(key, not self.get_key[key])
def init_roll(self, a, task):
if task.time <= 2:
if self.roll_time <= task.time:
self.roll_time = task.time
else:
self.roll_time += task.time
if self.roll_time > 2:
self.roll_time = 2
self.fighter.setR(self.fighter.getR() + a * self.roll_time)
else:
self.fighter.setR(self.fighter.getR() + a * 2)
return task.cont
def end_roll(self, a, b, task):
if task.time < b:
self.roll_time -= task.time
if self.roll_time < 0:
self.roll_time = 0
self.fighter.setR(self.fighter.getR() + a * (b - task.time))
return task.cont
else:
return task.done
def roll(self, a):
if a > 0:
self.set_key("ROLL_RIGHT_BEG", True)
else:
self.set_key("ROLL_LEFT_BEG", True)
self.taskMgr.add(self.init_roll, "task-init-roll", extraArgs=[a], appendTask=True)
def unroll(self, a):
if a > 0:
self.set_key("ROLL_RIGHT_BEG", False)
else:
self.set_key("ROLL_LEFT_BEG", False)
self.taskMgr.remove("task-init-roll")
self.taskMgr.add(self.end_roll, "task-end-roll", extraArgs=[a, self.roll_time], appendTask=True)
def to_roll(self):
if self.get_key["ROLL_LEFT"]:
if not self.get_key["ROLL_LEFT_BEG"]:
if self.fuel > 5:
self.roll(-1)
self.snd_roller.play()
else:
if self.get_key["ROLL_LEFT_BEG"]:
self.unroll(-1)
self.snd_roller.stop()
if self.get_key["ROLL_RIGHT"]:
if not self.get_key["ROLL_RIGHT_BEG"]:
if self.fuel > 5:
self.roll(+1)
self.snd_roller.play()
else:
if self.get_key["ROLL_RIGHT_BEG"]:
self.unroll(+1)
self.snd_roller.stop()
def fuel_usage(self, task):
if self.get_key["FORWARD_THRUST"] or self.get_key["REVERSE_THRUST"]:
self.fuel -= 9
if self.get_key["ROLL_LEFT_BEG"] or self.get_key["ROLL_RIGHT_BEG"]:
self.fuel -= 4
self.fuel -= 1
if self.fuel < 0:
self.fuel = 0
return task.again
def chk_speed(self, mvel):
if mvel < 0.01:
# stop fighter dead
if self.prt.getActive():
self.set_key("DECEL", False)
mvel = 0
if mvel > self.maxvel:
# stop fighter accelerating
if self.pft.getActive():
self.set_key("ACCEL", False)
mvel = self.maxvel
self.part.p.renderer.setLineScaleFactor(mvel*2)
self.part.pn.setPos(self.fighter, 0, 10, 0)
return mvel
def thrust_shake(self, task):
x = uniform(-1000, 1000)
y = uniform(-1000, 1000)
self.repos(x, y, 0.001)
return task.cont
def thrust_end(self, task):
if task.time < 5:
f = (5. - task.time) / 5.
s = 1000.*f
x = uniform(-s, s)
y = uniform(-s, s)
self.repos(x, y, 0.001)
self.snd_thrust.setVolume(f)
return task.cont
self.snd_thrust.stop()
return task.done
def thrust(self, a):
if a > 0:
self.set_key("FORWARD_THRUST", True)
else:
self.set_key("REVERSE_THRUST", True)
self.taskMgr.remove("task-thrust-end")
self.snd_thrust.setVolume(1)
self.snd_thrust.play()
self.taskMgr.add(self.thrust_shake, "task-thrust-shake")
def unthrust(self, a):
if a > 0:
self.set_key("FORWARD_THRUST", False)
else:
self.set_key("REVERSE_THRUST", False)
self.taskMgr.remove("task-thrust-shake")
self.taskMgr.add(self.thrust_end, "task-thrust-end")
def to_thrust(self):
if self.get_key["ACCEL"]:
if self.mvel < self.maxvel - 1:
if not self.get_key["FORWARD_THRUST"]:
if self.fuel > 10:
self.pft.setActive(True)
self.thrust(+1)
else:
if self.get_key["FORWARD_THRUST"]:
self.pft.setActive(False)
self.unthrust(+1)
if self.get_key["DECEL"]:
if self.mvel > 0:
if not self.get_key["REVERSE_THRUST"]:
if self.fuel > 10:
self.prt.setActive(True)
self.thrust(-1)
else:
if self.get_key["REVERSE_THRUST"]:
self.prt.setActive(False)
self.unthrust(-1)
def events(self):
self.accept("escape", self.quit)
self.accept('mouse1', self.set_key, ["FIRE", True])
self.accept('mouse1-up', self.set_key, ["FIRE", False])
self.accept('mouse3', self.set_key, ["LOCK", True])
self.accept('mouse3-up', self.set_key, ["LOCK", False])
self.accept("w", self.set_key, ["ACCEL", True])
self.accept("w-up", self.set_key, ["ACCEL", False])
self.accept("s", self.set_key, ["DECEL", True])
self.accept("s-up", self.set_key, ["DECEL", False])
self.accept("a", self.set_key, ["ROLL_LEFT", True])
self.accept("a-up", self.set_key, ["ROLL_LEFT", False])
self.accept("d", self.set_key, ["ROLL_RIGHT", True])
self.accept("d-up", self.set_key, ["ROLL_RIGHT", False])
def update(self, task):
self.pos()
self.speed()
if self.fuel > 0:
self.to_roll()
self.to_thrust()
self.to_fire()
self.to_lock()
self.rehud()
return task.cont
def rehud(self):
if self.target is not None:
c = self.target.np.getPos(self.fighter)
self.dist = c.length()
c.normalize()
self.d2 = c - Vec3(0, 1, 0)*c.dot(Vec3(0, 1, 0))
self.target.radar.setPos(self.d2.getX(), 1, self.d2.getZ())
def sounds(self):
self.audio3d = Audio3DManager.Audio3DManager(self.sfxManagerList[0], self.camera)
self.audio3d.setListenerVelocityAuto()
self.snd_space = self.loader.loadSfx("./snd/space.flac")
self.snd_space.setLoop(True)
self.snd_thrust = self.loader.loadSfx("./snd/thrust.flac")
self.snd_thrust.setLoop(True)
self.snd_roller = self.loader.loadSfx("./snd/roller.flac")
self.snd_roller.setLoop(True)
self.snd_launch = self.loader.loadSfx("./snd/launch.flac")
self.snd_lock = self.loader.loadSfx("./snd/lock.flac")
self.snd_space.play()
def quit(self):
self.taskMgr.running = False
def repos(self, x, y, d):
player_q = self.fighter.getQuat()
up = player_q.getUp()
right = player_q.getRight()
up.normalize()
right.normalize()
up_q = copy(player_q)
right_q = copy(player_q)
up_q.setFromAxisAngle(-(x * d), up)
right_q.setFromAxisAngle(y * d, right)
self.fighter.setQuat(player_q.multiply(up_q.multiply(right_q)))
def move_end(self, x, y, task):
if task.time <= 1:
d = 0.002*(1 - task.time)
self.repos(x, y, d)
return task.cont
return task.done
def pos(self):
if self.mouse:
md = self.win.getPointer(0)
x = md.getX()
y = md.getY()
else:
x = self.joy_x
y = self.joy_y
if self.win.movePointer(0, self.center_x, self.center_y):
x -= self.center_x
y -= self.center_y
if x != 0 or y != 0:
self.taskMgr.add(self.move_end, 'task-move-end', extraArgs=[x, y], appendTask=True)
def speed(self):
fwd = self.fighter.getQuat().getForward()
fwd.normalize()
self.mvel = self.anpo.getVelocity().length()
# speed control
self.mvel = self.chk_speed(self.mvel)
self.anpo.setVelocity(fwd * self.mvel)
def ship(self):
an = ActorNode()
an.getPhysicsObject().setMass(100)
self.fighter = self.render.attachNewNode(an)
self.physicsMgr.attachPhysicalNode(an)
self.anpo = an.getPhysicsObject()
fn = ForceNode("force-node-fighter")
self.fighter.attachNewNode(fn)
self.pft = LinearVectorForce(Vec3(0, +1, 0) * 500) # forward thrust
self.prt = LinearVectorForce(Vec3(0, -1, 0) * 500) # reverse thrust
self.pft.setMassDependent(1)
self.prt.setMassDependent(1)
self.pft.setActive(False)
self.prt.setActive(False)
fn.addForce(self.pft)
fn.addForce(self.prt)
an.getPhysical(0).addLinearForce(self.pft)
an.getPhysical(0).addLinearForce(self.prt)
self.camera.reparentTo(self.fighter)
from_obj = self.fighter.attachNewNode(CollisionNode('fighter'))
from_obj.node().setFromCollideMask(BitMask32(0x1))
from_obj.setCollideMask(BitMask32(0x1))
from_obj.node().addSolid(CollisionSphere(0, 0, 0, 1))
# from_obj.show()
self.pusher.addCollider(from_obj, self.fighter)
self.cTrav.addCollider(from_obj, self.pusher)
def launch_bullet(self):
speed = 500.
scale = Vec3(0.05)
color = Vec4(0, 1, 0, 1)
mask = BitMask32(0x2)
lookat = Vec3(0, 100, 0)
Missile(self, "bullet", speed, scale, color, mask, self.fighter, Vec3(-0.5, 0, 0), self.fighter, lookat, 0.5)
Missile(self, "bullet", speed, scale, color, mask, self.fighter, Vec3(+0.5, 0, 0), self.fighter, lookat, 0.5)
self.snd_launch.play()
def to_fire(self):
if self.get_key["FIRE"]:
if not self.get_key["FIRING"]:
self.set_key("FIRING", True)
self.taskMgr.doMethodLater(0.16, self.fire_bullet, "task-fire-bullet")
else:
if self.get_key["FIRING"]:
self.set_key("FIRING", False)
self.taskMgr.remove("task-fire-bullet")
def fire_bullet(self, task):
if self.fuel >= 5:
self.fuel -= 5
self.launch_bullet()
return task.again
def launch_missile(self):
speed = 100
scale = Vec3(0.2)
color = Vec4(1, 0, 0, 1)
mask = BitMask32(0x2)
lookat = Vec3(0, 0, 0)
self.missile = Missile(self, "missile", speed, scale, color, mask, self.fighter, Vec3(0, 0, -2), self.target.np, lookat, 3)
self.snd_launch.play()
self.taskMgr.add(self.guide_missile, "task-guide-missile")
def guide_missile(self, task):
try:
quat = Quat()
lookAt(quat, self.target.np.getPos() - self.missile.anp.getPos(), Vec3.up())
self.missile.anp.setQuat(quat)
fwd = quat.getForward()
fwd.normalize()
mvel = self.missile.anpo.getVelocity().length()
self.missile.anpo.setVelocity(fwd*mvel)
except:
return task.done
return task.cont
def can_lock(self):
if self.dist >= 30 and self.dist <= 300 and abs(self.d2.getX()) <= 0.1 and abs(self.d2.getZ()) <= 0.1:
return True
else:
return False
def remove_lock(self):
if self.get_key["LOCKING"]:
self.set_key("LOCKING", False)
self.locker.hide()
self.snd_lock.stop()
self.taskMgr.remove("task-fire-missile")
def to_lock(self):
if self.get_key["LOCK"]:
if self.can_lock():
if self.fuel >= 100:
if not self.get_key["LOCKING"]:
self.set_key("LOCKING", True)
self.locker.setScale(0.12)
self.locker.setColor(1, 0, 0, 0.5)
self.locker.show()
self.snd_lock.play()
self.taskMgr.add(self.fire_missile, "task-fire-missile")
else:
self.remove_lock()
else:
self.remove_lock()
else:
self.remove_lock()
def fire_missile(self, task):
if self.fuel >= 100:
if task.time < 3.6:
e = (3.6 - task.time)/3.6
f = 0.02 + e*0.1
self.locker.setScale(f)
self.locker.setColor(e, 1-e, 0, 0.5)
return task.cont
else:
self.fuel -= 100
self.launch_missile()
return task.done
class Universe(DirectObject):
def __init__(self, neweval, starList=[]):#, console=[]):
#messenger.toggleVerbose()
self.stars=starList
self.mouselook=True
self.zoom = .33
self.mapMode = False
self.evaluator = neweval
self.hudScale = 1
self.objectScale=.01
self.starScale = .1
self.skyScale=40000
self.dt=.02
self.starting=True
self.mouseX = 0
self.mouseY = 0
self.dX=0
self.dY=0
self.dZ=0
self.player = Body()
## self.mouseBody = Body()
## self.mouseBody.name = "mouse"
self.player.name = "player"
self.player.mass = 0
self.player.position.x=0
self.player.position.y=0
self.player.position.z=-0.04
self.player.orientation.y=90
self.accRate =2
# self.player.bodies=[]
# self.evaluator.system.bodies.append(self.player)
neweval.system.bodies.append(self.player)
self.evaluator= soPhysics.soPhysics(neweval.system)
self.evaluator.system.moveToStar()
self.filters = CommonFilters(base.win, base.cam)
self.filterok = self.filters.setBloom(blend=(1,1,1,1), desat=-0.5, intensity=1.0, size="small")
self.glowSize=1
#base.enableParticles()
#self.p = ParticleEffect()
#self.p.loadConfig("sun2.ptf")
self.loadPlanets()
#self.console = console
self.toggleConsole()
if len(starList)>0:
self.loadStars()
base.camLens.setNear(0.01)
base.camLens.setFar(100000)
# base.camLens.setFar(170000000000000000000000000000000000000)
self.mouselook=False
#render.setShaderAuto()
self.loadLights()
taskMgr.add(self.move,"move")
def loadLights(self):
plight = PointLight('plight')
plight.setColor(VBase4(1, 1, 1, 1))
self.plnp = render.attachNewNode(plight)
self.plnp.setPos(0, 0, 0)
render.setLight(self.plnp)
self.ambientLight = AmbientLight( 'ambientLight' )
self.ambientLight.setColor( Vec4( 0.1, 0.1, 0.1, 1 ) )
self.ambientLightNP = render.attachNewNode( self.ambientLight.upcastToPandaNode() )
render.setLight(self.ambientLightNP)
def loadStars(self):
print "loading stars"
for star in self.stars:
star.body.node = render.attachNewNode(star.body.name)
star.body.sphere = loader.loadModelCopy("models/dodecahedron")
sunMaterial =Material()
#sunMaterial.setEmission(VBase4(1,1,1,1))
sunMaterial.setEmission(VBase4(star.color[0],star.color[1],star.color[2], 1))
star.body.node.setMaterial(sunMaterial)
star.body.sphere.reparentTo(star.body.node)
star.body.sphere.setScale(self.starScale * star.radius)
star.body.node.setPos(star.body.position.x,star.body.position.y,star.body.position.z)
def setTexture(self, body, i):
if body.mass< 0.001:
body.texture = loader.loadTexture("models/earthmoon.jpg")
elif body.mass >= 0.001 and body.mass < .002:
body.texture = loader.loadTexture("models/mars.jpg")
elif body.mass >= .002 and body.mass < .003:
body.texture = loader.loadTexture("models/venus.jpg")
elif body.mass >= .003 and body.mass < .006:
body.texture = loader.loadTexture("models/mercury.jpg")
elif body.mass >= .006 and body.mass < .009:
body.texture = loader.loadTexture("models/pluto.jpg")
elif body.mass >= .009 and body.mass < .01:
body.texture = loader.loadTexture("models/uranus.jpg")
elif body.mass >= .01 and body.mass < .03:
body.texture = loader.loadTexture("models/saturn.jpg")
elif body.mass >= .03 and body.mass < .05:
body.texture = loader.loadTexture("models/neptune.jpg")
elif body.mass >= .05 and body.mass < .1:
body.texture = loader.loadTexture("models/saturn.jpg")
elif body.mass >= .1 and body.mass < .2:
body.texture = loader.loadTexture("models/jupiter.jpg")
else :
print body.mass
sunMaterial =Material()
sunMaterial.setTwoside(True)
body.name = "star"
#body.setColor(VBase4(1,1,1,1))
#self.p.start(parent = body.node, renderParent = body.node)
if body.mass >=.7 and body.mass < 1.0: #M type
body.texture = loader.loadTexture("models/Mstar.jpg")
sunMaterial.setEmission(VBase4(1,.6,.6,1))
elif body.mass >= 1.0 and body.mass < 1.5: #K type
body.texture = loader.loadTexture("models/Kstar.jpg")
sunMaterial.setEmission(VBase4(1,.6,.6,1))
elif body.mass >= 1.0 and body.mass < 1.5: #G type
body.texture = loader.loadTexture("models/GMstar.jpg")
sunMaterial.setEmission(VBase4(1,.6,.6,1))
#elif body.mass >= 1.5 and body.mass < 1.5: #G type
#body.texture = loader.loadTexture("models/Mstar.jpg")
#sunMaterial.setEmission(VBase4(1,.6,.6,1))
else:
body.texture = loader.loadTexture("models/Ostar.jpg")
sunMaterial.setEmission(VBase4(.8,.8,1,1))
body.node.setShaderAuto()
body.node.setMaterial(sunMaterial)
body.sphere.setTexture(body.texture,1)
def loadSinglePlanet(self, body,i):
body.node = render.attachNewNode(body.name)
if self.evaluator.gridSystem.names[i]!="player" and body.name != "player":
body.sphere = loader.loadModelCopy("models/planet_sphere")
body.sphere.reparentTo(body.node)
self.scalebody( i)
## scaleRate = ((math.sqrt(self.evaluator.gridSystem.mass[i]))/100)+.01
## body.sphere.setScale(scaleRate)
## self.evaluator.gridSystem.rad[i]=scaleRate
## body.mass=self.evaluator.gridSystem.mass[i]
## self.setTexture(body, i)
body.node.setPos(self.evaluator.gridSystem.pos[i][0],
self.evaluator.gridSystem.pos[i][1],
self.evaluator.gridSystem.pos[i][2])
else:
self.loadPlayer(body)
def detachNode(self, i):
#count = len(self.evaluator.system.bodies)-1
print "detaching node: ",i#count
self.evaluator.system.bodies[i].node.detachNode()
def loadPlanets(self):
pval = self.evaluator.gridSystem.player
print "player: ",pval
print self.evaluator.gridSystem.getPlayerIndex()
i=0
for body in self.evaluator.system.bodies:
if i ==pval:
print "player at: ",i
self.loadPlayer(self.player)
if i != pval:
self.loadSinglePlanet(body,i)
i+=1
self.sky = loader.loadModel("models/solar_sky_sphere")
self.sky_tex = loader.loadTexture("models/startex.jpg")
self.sky.setTexture(self.sky_tex, 1)
self.sky.setScale(self.skyScale)
self.sky.reparentTo(render)
def scaleUp(self):
self.accRate*= 1.01
print "accRate increasing",self.accRate
## print self.starScale
## for star in self.stars:
## star.body.sphere.setScale(self.starScale)
def scaleDown(self):
self.accRate*= .99
print "accRate decreasing",self.accRate
## print self.starScale
## for star in self.stars:
## star.body.sphere.setScale(self.starScale)
def toggleConsole(self):
print "toggle console"
#self.console.toggle()
def addPlanet(self):
self.loadSinglePlanet(self.evaluator.system.addSinglePlanet())
return
def loadRoid(self, abody):
if(len(self.player.bodies)<10):
self.player.bodies.append(abody)
self.evaluator.system.bodies.append(abody)
self.evaluator.accelerateCuda()
abody.node = render.attachNewNode(abody.name)
abody.model = loader.loadModelCopy("models/planet_sphere")
abody.model.reparentTo(abody.node)
abody.texture = loader.loadTexture("models/pluto.jpg")
abody.model.setScale(.01)
abody.node.setPos(abody.position.x ,abody.position.y ,abody.position.z)
return
def deloadRoid(self):
if(len(self.player.bodies) >0):
abody = self.player.bodies.pop()
self.evaluator.system.bodies.pop()
abody.node.detachNode()
return
def loadPlayer(self, abody):
abody.node = render.attachNewNode(abody.name)
abody.model = loader.loadModelCopy("models/fighter")
abody.model.reparentTo(abody.node)
if abody.name == "player":
abody.texture = loader.loadTexture("models/texturemap.png")
elif abody.name == "mouse":
abody.texture = loader.loadTexture("models/sun.jpg")
abody.model.setScale(.00005)
abody.radius=.00005
i = self.evaluator.gridSystem.getPlayerIndex()
self.evaluator.gridSystem.rad[i]=0.01
abody.node.setPos(self.evaluator.gridSystem.pos[i][0],
self.evaluator.gridSystem.pos[i][1],
self.evaluator.gridSystem.pos[i][2])
def exit(self):
quit()
return
def fullscreen(self):
print "doh"
def move(self,task):
# self.accept("p", self.addPlanet)
self.accept("`", self.toggleConsole)
self.accept("wheel_right", self.tiltLeft)
self.accept("wheel_left", self.tiltRight)
# self.accept("mouse6", self.tiltLeft)
# self.accept("mouse7", self.tiltRight)
#self.accept("w", self.tiltLeft)
#self.accept("r", self.tiltRight)
self.accept("mouse2", self.handlemouse2Click)
#self.accept("mouse3", self.handleRightMouseClick)
#self.accept("mouse1", self.handleLeftMouseClick)
self.accept("wheel_up", self.zoomIn)
self.accept("wheel_down", self.zoomOut)
self.accept("escape", self.exit)
self.accept("space",self.stop)
self.accept("s",self.brake)
self.accept("w",self.accelerate)
self.accept("f",self.fullscreen)
self.accept("m",self.togglemap)
self.accept("[",self.scaleDown)
self.accept("]",self.scaleUp)
self.accept("l",self.togglemouselook)
dt = self.dt
if not self.mapMode:
self.evaluator.accelerateCuda()
self.updateMouse(self.player)
if self.starting:
dt=dt/2.0
self.starting=False
#self.reloadPlanets()
self.setAllPositions()
return Task.cont
def tiltLeft(self):
print "left"
self.player.orientation.z-=10
def tiltRight(self):
print "right"
self.player.orientation.z+=10
def togglemouselook(self):
print "toggling mouselook"
if self.mouselook:
self.mouselook = False
else:
self.mouselook = True
def togglemap(self):
print "toggling map"
if (self.mapMode):
self.mapMode=False
self.zoom=1.1
else:
self.mapMode=True
self.zoom = 59000
def accelerate(self):
print "accelerating ship"
i = self.evaluator.gridSystem.getPlayerIndex()
self.evaluator.gridSystem.acc[i][0]+=self.dX*8
self.evaluator.gridSystem.acc[i][1]+=self.dY*8
self.evaluator.gridSystem.acc[i][2]+=self.dZ*8
#self.evaluator.gridSystem.printBody(i)
return
def stop(self):
i = self.evaluator.gridSystem.player
print "stopping ship", i
self.evaluator.gridSystem.printBody(i)
self.evaluator.gridSystem.vel[i][0]=0.0
self.evaluator.gridSystem.vel[i][1]=0.0
self.evaluator.gridSystem.vel[i][2]=0.0
return
def brake(self):
print "slowing ship"
i = self.evaluator.gridSystem.player
self.evaluator.gridSystem.printBody(i)
self.evaluator.gridSystem.acc[i][0]-=self.dX
self.evaluator.gridSystem.acc[i][1]-=self.dY
self.evaluator.gridSystem.acc[i][2]-=self.dZ
def handleMouse2(self):
print "deccelerating ship"
self.player.acceleration.x-=self.dX/10
self.player.acceleration.y-=self.dY/10
self.player.acceleration.z-=self.dZ/10
def handlemouse2Click(self):
print "mouse2"
self.togglemouselook()
def handlemouseLeftClick(self):
print "mouseLeft"
def handlemouseRightClick(self):
print "mouseRight"
def handleLeftMouseClick(self):
print "impactor deployed"
abody=Body()
abody.velocity.x = self.player.velocity.x
abody.velocity.y = self.player.velocity.y
abody.velocity.z = self.player.velocity.z
abody.position.x = self.player.position.x
abody.position.y = self.player.position.y
abody.position.z = self.player.position.z
abody.acceleration.x += self.dX/15
abody.acceleration.y += self.dY/15
abody.acceleration.z += self.dZ/15
abody.mass =0.00000001
self.loadRoid(abody)
return
def handleRightMouseClick(self):
print "removing impactor"
self.deloadRoid()
def zoomIn(self):
self.zoom*=0.9
print self.zoom
#self.scaleDown()
return
def zoomOut(self):
self.zoom*=1.1
print self.zoom
#self.scaleUp()
if self.zoom > 60000:
self.zoomIn()
return
def updateMouse(self, abody):
if (True):
newX=self.mouseX
newY=self.mouseY
if self.mouselook and base.mouseWatcherNode.hasMouse():
newX = base.mouseWatcherNode.getMouseX()
newY = base.mouseWatcherNode.getMouseY()
deltaX = self.mouseX - newX
deltaY = self.mouseY - newY
self.mouseX = newX
self.mouseY = newY
if abody.orientation.y >360:
abody.orientation.y -=360
if abody.orientation.x >360:
abody.orientation.x -=360
if abody.orientation.y > 180:
abody.orientation.y += (360*deltaY)
else:
abody.orientation.y -= (360*deltaY)
if abody.orientation.y > 180:
abody.orientation.x -= (360*deltaX)
else:
abody.orientation.x += (360*deltaX)
self.dZ = self.zoom*math.sin((-abody.orientation.y+180)*(math.pi / 180.0))
hyp = self.zoom*math.cos((-abody.orientation.y+180)*(math.pi / 180.0))
self.dX = hyp * math.sin((-abody.orientation.x+180)*(math.pi / 180.0))
self.dY = hyp * math.cos((-abody.orientation.x+180)*(math.pi / 180.0))
base.camera.setHpr(abody.orientation.x,
abody.orientation.y,abody.orientation.z)
cpos=self.evaluator.gridSystem.getPlayerIndex()
#base.camera.printPos()
base.camera.setPos(self.evaluator.gridSystem.pos[cpos][0]-self.dX,
self.evaluator.gridSystem.pos[cpos][1]-self.dY,
self.evaluator.gridSystem.pos[cpos][2]-self.dZ)
def setAllPositions(self):
for j in self.evaluator.gridSystem.collisions:
self.scalebody(j)
self.evaluator.gridSystem.collisoins=[]
for k in self.evaluator.gridSystem.removed:
self.detachNode(k)
## abody = Body(self.evaluator.system.getDirectedPlanet())
## self.evaluator.gridSystem.insertBody(abody,k)
## self.loadSinglePlanet(abody, k)
self.evaluator.gridSystem.removed=[]
i=0
for body in self.evaluator.system.bodies:
self.set_body_position(body,
self.evaluator.gridSystem.pos[i][0],
self.evaluator.gridSystem.pos[i][1],
self.evaluator.gridSystem.pos[i][2])
i+=1
def scalebody(self, i):
body = self.evaluator.system.bodies[i]
if body.name == "player":
print "rescaling: ",i," ",body.name
raw_input()
scaleRate = ((math.sqrt(self.evaluator.gridSystem.mass[i]))/50)+.001
body.sphere.setScale(scaleRate)
self.evaluator.gridSystem.rad[i]=scaleRate
body.mass=self.evaluator.gridSystem.mass[i]
self.setTexture(body, i)
def set_body_position(self,body,x,y,z):
if body.name == "star":
#print "moving light"
self.plnp.setPos(x,y,z)
body.node.setPos(x,y,z)
body.node.setHpr(body.orientation.x, body.orientation.y, body.orientation.z)
class Landwalker(ShowBase):
def __init__(self):
#loadPrcFile("Config.prc")
ShowBase.__init__(self)
self.config = ConfigManager.loadSettings()
#Config stuff here
self.filters = CommonFilters(base.win, base.cam)
self.AOEnabled = False
self.bloomEnabled = False
self.invertEnabled = False
self.OSD = True
self.shadersLoaded = False
self.xray_mode = False
self.show_model_bounds = False
self.fogEnabled = True
self.mouseEnabled = False
#Store which keys are currently pressed
self.keyMap = {
"1": 0,
"escape": 0,
"left": 0,
"right": 0,
"forward": 0,
"backward": 0,
"cam-left": 0,
"cam-right": 0,
}
self.ButtonImage = loader.loadModel(
"phase_3/models/gui/quit_button.bam")
self.introButtons()
def introButtons(self):
def loadGame():
print("Loading game...")
Button1.removeNode()
Button2.removeNode()
imageObject.destroy()
self.loadGame()
imageObject = OnscreenImage(image='stat_board.png', pos=(0, 0, 0))
imageObject.setTransparency(TransparencyAttrib.MAlpha)
Button1 = DirectButton(
frameSize=None,
text="Load Game",
image=(self.ButtonImage.find('**/QuitBtn_UP'),
self.ButtonImage.find('**/QuitBtn_DN'),
self.ButtonImage.find('**/QuitBtn_RLVR')),
relief=None,
command=loadGame,
text_pos=(0, -0.015),
geom=None,
pad=(0.01, 0.01),
suppressKeys=0,
pos=(-.85, -0, -.93),
text_scale=0.059999999999999998,
borderWidth=(0.015, 0.01),
scale=.7)
Button1.setPosHprScale(0.00, 0.00, 0.30, 0.00, 0.00, 0.00, 2.53, 2.53,
2.53)
Button2 = DirectButton(
frameSize=None,
text="Customize",
image=(self.ButtonImage.find('**/QuitBtn_UP'),
self.ButtonImage.find('**/QuitBtn_DN'),
self.ButtonImage.find('**/QuitBtn_RLVR')),
relief=None,
command=loadGame,
text_pos=(0, -0.015),
geom=None,
pad=(0.01, 0.01),
suppressKeys=0,
pos=(-.85, -0, -.93),
text_scale=0.059999999999999998,
borderWidth=(0.015, 0.01),
scale=.7)
Button2.setPosHprScale(0.00, 0.00, -0.30, 0.00, 0.00, 0.00, 2.53, 2.53,
2.53)
def loadGame(self):
# Adding onscreen text here
self.inst1 = addInstructions(0.06, "Press F to toggle wireframe")
self.inst2 = addInstructions(0.12, "Press X to toggle xray")
self.inst3 = addInstructions(0.18,
"Press 1 to activate cartoon shading")
self.inst4 = addInstructions(0.24,
"Press 2 to deactivate cartoon shading")
self.inst4 = addInstructions(0.30, "Press 3 to toggle fog")
self.inst4 = addInstructions(0.36, "Press 4 to toggle free camera")
self.inst4 = addInstructions(0.42, "Press 5 to toggle bloom")
self.inst4 = addInstructions(0.48,
"Press 6 to toggle Ambient Occlusion")
self.inst4 = addInstructions(
0.54, "Press Escape to toggle the onscreen debug")
#Loading required modules...
self.loadWorld()
localAvatar = self.getActor()
base.localAvatar = localAvatar
self.LoadButtons()
self.loadShaders()
self.FogDensity = self.loadFog()
self.objectList = list()
self.objectList.append(self.scene)
# Floater Object (For camera)
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(self.actorBody)
self.floater.setY(-10)
self.floater.setZ(8.5)
self.floater.setHpr(0, -10, 0)
# Set Camera
self.camera.reparentTo(self.floater)
# Accept the control keys for movement and rotation
self.accept('f', self.toggleWireframe)
self.accept('x', self.toggle_xray_mode)
self.accept('b', self.toggle_model_bounds)
self.accept("escape", self.toggle_osd)
self.accept("1", self.loadCartoonShaders)
self.accept("2", self.unloadShaders)
self.accept("3", self.toggleFog)
self.accept("4", self.toggleCamera)
self.accept("5", self.toggleBloom)
self.accept("6", self.toggleAmbientOcclusion)
#warning: bright! self.accept("6", self.toggleInvert)
self.accept("arrow_left", self.setKey, ["left", True])
self.accept("arrow_right", self.setKey, ["right", True])
self.accept("arrow_up", self.setKey, ["forward", True])
self.accept("arrow_down", self.setKey, ["backward", True])
self.accept("arrow_left-up", self.setKey, ["left", False])
self.accept("arrow_right-up", self.setKey, ["right", False])
self.accept("arrow_up-up", self.setKey, ["forward", False])
self.accept("arrow_down-up", self.setKey, ["backward", False])
self.taskMgr.add(self.move, "moveTask")
self.offset = 3.2375
wallBitmask = BitMask32(1)
floorBitmask = BitMask32(2)
base.cTrav = CollisionTraverser()
walkControls = GravityWalker(legacyLifter=True)
walkControls.setWallBitMask(wallBitmask)
walkControls.setFloorBitMask(floorBitmask)
walkControls.setWalkSpeed(16.0, 24.0, 8.0, 80.0)
walkControls.initializeCollisions(base.cTrav,
self.actorBody,
floorOffset=0.025,
reach=4.0)
walkControls.setAirborneHeightFunc(self.getAirborneHeight())
walkControls.enableAvatarControls()
# self.controlManager.add(walkControls, 'walk')
self.actorBody.physControls = walkControls
localAvatar.physControls.placeOnFloor()
# problem: onScreenDebug.enabled = self.toggle
# print(updateOnScreenDebug.enabled)
onScreenDebug.enabled = True
base.setFrameRateMeter(True)
PStatClient.connect()
base.taskMgr.add(self.updateOnScreenDebug, 'UpdateOSD')
def loadWorld(self):
#Loading our Scene
self.scene = loader.loadModel("models/world.egg.pz")
self.scene.reparentTo(self.render)
self.setBackgroundColor(0.53, 0.80, 0.92, 1)
def removeWorld(self):
self.scene.removeNode()
def getActor(self):
# Loading our Actor
actorStartPos = self.scene.find("**/start_point").getPos()
self.actorBody = ActorDict.playerBody
self.actorBody.reparentTo(self.render)
self.actorBody.loop('neutral')
self.actorBody.setPos(actorStartPos + (0, 0, 1.5))
self.actorBody.setScale(0.3)
self.actorBody.setH(-180)
def ActorHead():
actorHead = loader.loadModel("custom/def_m.bam")
actorHead.reparentTo(self.actorBody.find('**/to_head'))
actorHead.setScale(0.20)
actorHead.setZ(0)
actorHead.setH(-180)
ActorHead()
return self.actorBody
def LoadButtons(self):
Button_Up = loader.loadModel(
'phase_3/models/gui/quit_button.bam').find('**/QuitBtn_UP')
Button_Down = loader.loadModel(
'phase_3/models/gui/quit_button.bam').find('**/QuitBtn_DN')
Button_Rlvr = loader.loadModel(
'phase_3/models/gui/quit_button.bam').find('**/QuitBtn_RLVR')
# https://pastebin.com/agdb8260
Arrow_Up = loader.loadModel(
'phase_3/models/gui/nameshop_gui.bam').find('**/triangleButtonUp')
Arrow_Down = loader.loadModel(
'phase_3/models/gui/nameshop_gui.bam').find('**/triangleButtonDwn')
Arrow_Rlvr = loader.loadModel('phase_3/models/gui/nameshop_gui.bam'
).find('**/triangleButtonRllvr')
Buttons = [Button_Up, Button_Down, Button_Rlvr]
numItemsVisible = 4
itemHeight = 0.11
myScrolledList = DirectScrolledList(
decButton_pos=(0.35, 0, 0.54),
decButton_text_scale=0.04,
decButton_relief=None,
decButton_image=(Arrow_Up, Arrow_Down, Arrow_Rlvr),
incButton_pos=(0.35, 0, -0.01),
incButton_hpr=(0, 0, 180),
incButton_text_scale=0.04,
incButton_relief=None,
incButton_image=(Arrow_Up, Arrow_Down, Arrow_Rlvr),
pos=(0.74, 0, 0.4),
numItemsVisible=numItemsVisible,
forceHeight=itemHeight,
itemFrame_pos=(0.35, 0, 0.43))
modelArray = [
'phase_4/models/neighborhoods/toontown_central.bam',
'phase_13/models/parties/partyGrounds.bam', 'models/world.egg.pz',
'custom/ship/ship.egg'
]
nameArray = [
'Toontown Central', 'Party Grounds', 'Default World', 'Ship Test'
]
for index, name in enumerate(nameArray):
l = DirectButton(text=name,
image=(Buttons),
extraArgs=[modelArray[index]],
command=self.spawnObject,
text_scale=0.045,
text_pos=(0, -0.007, 0),
relief=None)
myScrolledList.addItem(l)
#will be used to spawn objects
def spawnObject(self, modelName):
#if spawned object already exists, we're gonna need to remove it
while len(self.objectList) >= 1:
for world in self.objectList:
world.removeNode()
self.objectList.pop(0)
spawnedObject = loader.loadModel(modelName)
spawnedObject.reparentTo(render)
spawnedObject.setPos(base.localAvatar.getPos())
#spawnedObject = self.scene
#self.removeWorld(self.objectList.find(spawnedObject))
self.objectList.append(spawnedObject)
print("Model Name: " + repr(modelName))
print("Spawned Object: " + repr(spawnedObject))
testobjectindex = len(self.objectList)
print(testobjectindex)
print(self.objectList)
#self.removeWorld()
def loadPStats(self):
os.system("pstats.exe")
def loadFog(self):
self.fog = Fog('distanceFog')
self.fog.setColor(0, 0, 0)
self.fog.setExpDensity(.01)
self.render.setFog(self.fog)
self.fog.setOverallHidden(False)
return self.fog.getExpDensity()
def loadShaders(self):
normalsBuffer = self.win.makeTextureBuffer("normalsBuffer", 0, 0)
normalsBuffer.setClearColor(LVecBase4(0.5, 0.5, 0.5, 1))
self.normalsBuffer = normalsBuffer
normalsCamera = self.makeCamera(normalsBuffer,
lens=self.cam.node().getLens())
normalsCamera.node().setScene(self.render)
drawnScene = self.normalsBuffer.getTextureCard()
drawnScene.setTransparency(1)
drawnScene.setColor(1, 1, 1, 0)
drawnScene.reparentTo(self.render2d)
self.drawnScene = drawnScene
def toggleAmbientOcclusion(self):
if not self.AOEnabled:
self.filters.setAmbientOcclusion()
self.AOEnabled = True
else:
self.filters.delAmbientOcclusion()
self.AOEnabled = False
def toggleInvert(self):
if not self.invertEnabled:
self.filters.setInverted()
self.invertEnabled = True
else:
self.filters.delInverted()
self.invertEnabled = False
def toggleBloom(self):
if not self.bloomEnabled:
self.filters.setBloom()
self.bloomEnabled = True
else:
self.filters.delBloom()
self.bloomEnabled = False
def toggleCamera(self):
if not self.mouseEnabled:
base.enableMouse()
self.mouseEnabled = True
else:
base.disableMouse()
self.camera.setPosHpr(0, 0, 0, 0, 0, 0)
self.mouseEnabled = False
def toggleFog(self):
if not self.fogEnabled:
self.fog.setExpDensity(self.FogDensity)
self.fogEnabled = True
else:
self.fog.setExpDensity(0)
self.fogEnabled = False
def toggle_xray_mode(self):
"""Toggle X-ray mode on and off. This is useful for seeing the
effectiveness of the portal culling."""
self.xray_mode = not self.xray_mode
if self.xray_mode:
self.scene.setColorScale((1, 1, 1, 0.5))
self.scene.setTransparency(TransparencyAttrib.MDual)
else:
self.scene.setColorScaleOff()
self.scene.setTransparency(TransparencyAttrib.MNone)
def toggle_model_bounds(self):
"""Toggle bounding volumes on and off on the models."""
self.show_model_bounds = not self.show_model_bounds
if self.show_model_bounds:
for model in self.objectList:
model.showBounds()
else:
for model in self.objectList:
model.hideBounds()
def toggle_osd(self):
self.OSD = not self.OSD
if self.OSD:
self.onScreenDebug.enabled = True
else:
self.onScreenDebug.enabled = False
def getAirborneHeight(self):
return self.offset + 0.025000000000000001
def updateOnScreenDebug(self, task):
if (onScreenDebug.enabled):
onScreenDebug.add('Avatar Position', base.localAvatar.getPos())
onScreenDebug.add('Avatar Angle', base.localAvatar.getHpr())
onScreenDebug.add('Camera Position', base.camera.getPos())
onScreenDebug.add('Camera Angle', base.camera.getHpr())
return Task.cont
def unloadShaders(self):
if self.shadersLoaded:
self.drawnScene.hide()
self.shadersLoaded = False
def loadCartoonShaders(self):
if not self.shadersLoaded:
self.separation = 0.0015
self.cutoff = 0.35
inkGen = loader.loadShader("shaders/inkGen.sha")
self.drawnScene.setShader(inkGen)
self.drawnScene.setShaderInput(
"separation", LVecBase4(self.separation, 0, self.separation,
0))
self.drawnScene.setShaderInput("cutoff", LVecBase4(self.cutoff))
self.drawnScene.show()
self.shadersLoaded = True
# Records the state of the arrow keys
def setKey(self, key, value):
self.keyMap[key] = value
# Accepts arrow keys to move either the player or the menu cursor,
# Also deals with grid checking and collision detection
def move(self, task):
dt = globalClock.getDt()
if self.keyMap["forward"]:
self.localAvatar.setY(self.localAvatar, 20 * dt)
elif self.keyMap["backward"]:
self.localAvatar.setY(self.localAvatar, -20 * dt)
if self.keyMap["left"]:
self.localAvatar.setHpr(self.localAvatar.getH() + 1.5,
self.localAvatar.getP(),
self.localAvatar.getR())
elif self.keyMap["right"]:
self.localAvatar.setHpr(self.localAvatar.getH() - 1.5,
self.localAvatar.getP(),
self.localAvatar.getR())
currentAnim = self.actorBody.getCurrentAnim()
if self.keyMap["forward"]:
if currentAnim != "walk":
self.localAvatar.loop("walk")
elif self.keyMap["backward"]:
# Play the walk animation backwards.
if currentAnim != "walk":
self.localAvatar.loop("walk")
self.localAvatar.setPlayRate(-1.0, "walk")
elif self.keyMap["left"] or self.keyMap["right"]:
if currentAnim != "walk":
self.localAvatar.loop("walk")
self.localAvatar.setPlayRate(1.0, "walk")
else:
if currentAnim is not None:
self.localAvatar.stop()
self.localAvatar.loop("neutral")
self.isMoving = False
return task.cont
class World(DirectObject):
global traverser, queue
def __init__(self):
startMenu = menu.Menu(self)
#Please do not remove this function, it makes the menu work.
def beginGame(self):
"""beginGame
parameters:
self
returns:
none
Description:
What would normalley be the contants of __init__. Called only after the menu.
"""
self.configurePanda()
camera.setPosHpr(0, -15, 0, 0, 0, 0) # x,y,z,heading, pitch, roll
#world init
self.setupBullet()
self.loadModels()
self.setupLights()
#self.initMove()
self.accept("escape",sys.exit)
self.overlay = overlay.Overlay(self)
#self.ball = ball.Ball(self)
self.onRay = list()
self.offRay = list()
self.activeRay = list()
def configurePanda(self):
"""configurePanda
parameters:
self
returns:
none
Description:
Set the rendering and display options for panda.
"""
props = WindowProperties()
props.setCursorHidden(True)
#props.setSize(1440, 900)
#props.setFullscreen(1)
base.win.requestProperties(props)
render.setShaderAuto()
base.disableMouse()
base.setFrameRateMeter(True)
#render.setAntialias(AntialiasAttrib.MAuto)
#render.setAntialias(AntialiasAttrib.MMultisample,4)
self.filters = CommonFilters(base.win, base.cam)
self.filters.setBloom(blend=(1,0,0,1), desat=-0.5, intensity=6.0, size=2)
#self.filters.setAmbientOcclusion()
#self.filters.setCartoonInk()
def setupBullet(self):
"""setupBullet
parameters:
self
returns:
none
Description:
Initialize bullet and (if needed) the bullet debug renderer.
"""
taskMgr.add(self.update, 'updateWorld')
self.worldNP = render.attachNewNode('World')
# World
#self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
#self.debugNP.show()
#self.debugNP.node().showWireframe(True)
#self.debugNP.node().showConstraints(False)
#self.debugNP.node().showBoundingBoxes(False)
#self.debugNP.node().showNormals(False)
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, 0))
#self.world.setDebugNode(self.debugNP.node())
def loadModels(self):
"""loadModels
parameters:
self
returns:
none
Description:
Loads the models and related collisions. Most game init goes here.
"""
# create the environment
self.env = collision.loadAndPositionModelFromFile("../assets/3d/mayaActors/arena_collisions_nogrid.egg")
self.envBoxes = objects.genBulletBoxes(self.env,self.world)
#load objects out of the environment
#human
self.mover = Human(self,self.world,self.worldNP)
tmp = self.env.find("**/PlayerSpawn1")
self.mover.bulletInit(self.world,tmp.getPos())
tmp.detachNode()
#AI players
self.players = objects.loadPlayers(self.env,self.world,self.worldNP)
for i in range(0,5):
self.players[i].bulletInit(self.world,self.players[i].instance.getPos())
#Spawners
collisionHandler=0
self.aTrapSpawn = objects.loadTrapAs(self.env, self.world, self.worldNP)
self.bTrapSpawn = objects.loadTrapBs(self.env, self.world, self.worldNP)
self.ammoSpawn = objects.loadAmmo(self.env, self.world, self.worldNP)
#optimization
self.env.flattenStrong()
render.analyze()
self.crowd = loader.loadModel("../assets/3d/Actors/crowd.egg")
self.crowd.reparentTo(render)
self.crowd.setScale(10)
self.crowd.setPos(0,0,-1000)
def setupLights(self):
"""setupLights
parameters:
self
returns:
none
Description:
Stick in some general lights.
"""
self.ambientLight = lights.setupAmbientLight()
self.dirLight = DirectionalLight("dirLight")
self.dirLight.setColor((.4,.4,.4,1))
self.dirLightNP = render.attachNewNode(self.dirLight)
self.dirLightNP.setHpr(0,-25,0)
render.setLight(self.dirLightNP)
#self.light = lights.loadModelSpotlightByName(self.human,"humanlight","humanlight1","segwaLight")
#panda2 = collision.loadAndPositionModelFromFile("panda-model",scale=.005,pos=tifLeftLight.getPos())
def update(self, task):
"""update
parameters:
self
returns:
none
Description:
Game Loop
"""
dt = globalClock.getDt()
# Update the spawners
for i in self.aTrapSpawn:
contacts = self.world.contactTest(i.sphere).getContacts()
if len(contacts)>0:
i.trap1Collide(contacts,self.mover)
for i in self.bTrapSpawn:
contacts = self.world.contactTest(i.sphere).getContacts()
if len(contacts)>0:
i.trap2Collide(contacts,self.mover)
for i in self.ammoSpawn:
contacts = self.world.contactTest(i.sphere).getContacts()
if len(contacts)>0:
i.ammoCollide(contacts,self.mover)
# update the traps and projectiles
for i in human.floatTrap.traps:
contacts = self.world.contactTest(i.sphere).getContacts()
if len(contacts)>0:
i.check(contacts,self.mover,self.players)
for i in human.clawTrap.traps:
contacts = self.world.contactTest(i.sphere).getContacts()
if len(contacts)>0:
i.check(contacts,self.mover,self.players)
for i in Projectile.projectiles:
contacts = self.world.contactTest(i.sphere).getContacts()
if len(contacts)>0:
i.check(contacts,self.mover,self.players)
# step forward the physics simulation
self.world.doPhysics(dt,1)
return task.cont
class Application(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.useAdvancedVisualEffects =\
ConfigVariableBool("use-advanced-visual-effects", True) and\
base.win.getGsg().getSupportsBasicShaders() and\
base.win.getGsg().getSupportsGlsl() and\
base.win.getGsg().getSupportsDepthTexture()
self.game = Game(scriptPath)
self.phoneState = PhoneState(self)
self.setupFilters()
self.setupModels()
self.setupLighting()
self.setupKeyboardControl()
self.camera.setPos(0.0, 0.0, 1.7)
self.setupMouseControl()
self.phoneState.request("Hidden")
blockSize = 10.0
self.maxX = self.game.getCityBlueprint().getSizeWE() * blockSize / 2.0
self.maxY = self.game.getCityBlueprint().getSizeNS() * blockSize / 2.0
self.setBackgroundColor(0.2, 0.4, 1.0, 1.0)
def setupFilters(self):
if (self.useAdvancedVisualEffects):
self.filters = CommonFilters(self.win, self.cam)
self.filters.setBloom()
def setupKeyboardControl(self):
self.accept("escape", sys.exit)
def setupMouseControl(self):
self.disableMouse()
self.mousex = 0
self.mousey = 0
self.last = 0
self.mousebtn = [0,0,0]
self.accept("mouse1", self.setMouseBtn, [0, 1])
self.accept("mouse1-up", self.setMouseBtn, [0, 0])
self.taskMgr.add(self.controlCamera, "cameraTask")
def setupLights(self):
self.sunLight = self.render.attachNewNode(DirectionalLight("sunLight"))
self.sunLight.setColor(Vec4(0.8, 0.8, 0.8, 1))
self.sunLight.node().getLens().setFilmSize(128, 64)
self.sunLight.node().getLens().setNearFar(20,2000)
self.sunLight.setPos(60, 30, 50)
self.sunLight.lookAt(0, 0, 0)
self.render.setLight(self.sunLight)
# self.sunLight.node().showFrustum()
if self.useAdvancedVisualEffects:
self.sunLight.node().setShadowCaster(True, 256, 256)
self.render.setShaderAuto()
self.ambientLight = self.render.attachNewNode(AmbientLight("ambientLight"))
self.ambientLight.node().setColor(Vec4(0.2, 0.2, 0.2, 1))
self.render.setLight(self.ambientLight)
def setupModels(self):
self.city = self.loader.loadModel("models/city")
self.city.reparentTo(self.render)
self.phoneState.setupPhone()
self.cityOutline = self.loader.loadModel("models/city_outline")
self.cityOutline.reparentTo(self.phoneState.minimap)
def setupLighting(self):
self.ambientLight = self.render.attachNewNode(AmbientLight("ambientLight"))
self.ambientLight.node().setColor(Vec4(1, 1, 1, 1))
self.render.setLight(self.ambientLight)
def setMouseBtn(self, btn, value):
self.mousebtn[btn] = value
if (btn == 0 and value == 1 and self.phoneState.state == "Center"):
phoneDisplayRegionCenterX = self.win.getXSize() * (self.phoneState.phoneDisplayRegion.getLeft() + self.phoneState.phoneDisplayRegion.getRight()) / 2.0
phoneDisplayRegionCenterY = self.win.getYSize() * (1.0 - (self.phoneState.phoneDisplayRegion.getBottom() + self.phoneState.phoneDisplayRegion.getTop()) / 2.0)
mouse = self.win.getPointer(0)
s = 2 ** self.phoneState.minimapZoom
x = clamp(self.camera.getX() + (mouse.getX() - phoneDisplayRegionCenterX) / s, -self.maxX, self.maxX)
y = clamp(self.camera.getY() + (phoneDisplayRegionCenterY - mouse.getY()) / s, -self.maxY, self.maxY)
previousHeading = self.camera.getH() % 360.0
heading = (rad2Deg(atan2(y - self.camera.getY(), x - camera.getX())) - 90.0) % 360.0
if (180.0 < abs(heading - previousHeading)):
if (previousHeading < heading):
heading -= 360.0
else:
heading += 360.0
self.camera.setH(previousHeading)
self.phoneState.orientationTriangle.setH(previousHeading)
Parallel(
self.camera.posInterval(0.5, Vec3(x, y, self.camera.getZ())),
self.phoneState.minimapCamera.posInterval(0.5, Vec3(x, y, self.phoneState.minimapCamera.getZ())),
self.phoneState.orientationTriangle.posInterval(0.5, Vec3(x, y, self.phoneState.orientationTriangle.getZ())),
self.camera.hprInterval(0.5, Vec3(heading, self.camera.getP(), self.camera.getR())),
self.phoneState.orientationTriangle.hprInterval(0.5, Vec3(heading, self.phoneState.orientationTriangle.getP(), self.phoneState.orientationTriangle.getR()))
).start()
def setBlurSharpen(self, amount):
if (not self.useAdvancedVisualEffects):
return
if (amount == 1.0):
self.filters.delBlurSharpen()
else:
self.filters.setBlurSharpen(amount=amount)
def controlCamera(self, task):
if (self.phoneState.state == "Center"):
return Task.cont
# figure out how much the mouse has moved (in pixels)
mouse = self.win.getPointer(0)
x = mouse.getX()
y = mouse.getY()
windowCenterX = self.win.getXSize() / 2
windowCenterY = self.win.getYSize() / 2
heading = self.camera.getH()
pitch = self.camera.getP()
if self.win.movePointer(0, windowCenterX, windowCenterY):
heading -= (x - windowCenterX) * 0.2
pitch = clamp(pitch - (y - windowCenterY) * 0.2, -45, 45)
self.camera.setHpr(heading, pitch, 0)
elapsed = task.time - self.last
if (self.last == 0):
elapsed = 0
if (self.mousebtn[0]):
direction = self.camera.getMat().getRow3(1)
self.camera.setPos(self.camera.getPos() + direction * elapsed*30)
clampX(self.camera, -self.maxX, self.maxX)
clampY(self.camera, -self.maxY, self.maxY)
self.camera.setZ(2)
self.phoneState.minimapCamera.setX(self.camera.getX())
self.phoneState.minimapCamera.setY(self.camera.getY())
self.phoneState.orientationTriangle.setX(self.camera.getX())
self.phoneState.orientationTriangle.setY(self.camera.getY())
self.phoneState.orientationTriangle.setHpr(heading, -90, 0)
self.last = task.time
return Task.cont
class Engine(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
props = WindowProperties()
props.setTitle('Test')
self.win.requestProperties(props)
# self.render.setAntiAlias(AntialiasAttrib.MAuto)
self.transitions = Transitions(self.loader)
self.transitions.setFadeColor(0, 0, 0)
self.filters = CommonFilters(self.win, self.cam)
# self.filters.setCartoonInk()
self.filters.setBlurSharpen(1)
# self.filters.setVolumetricLighting(self.render)
# self.buffer = self.win.makeTextureBuffer("Post-processing buffer", self.win.getXSize(), self.win.getXSize())
# print self.buffer.getYSize()
# self.texture = self.buffer.getTexture()
# self.buffer.setSort(-100)
#
# self.originalCamera = self.camera
# self.offScreenCamera = self.makeCamera(self.buffer)
# self.camera = self.offScreenCamera
#
# self.img = OnscreenImage(image=self.texture, pos=(0, 0, 0.5))
self.scene = None
self.channel = Channel()
def set_scene(self, scene_module):
# self.transitions.fadeOut(0.2)
args = []
if self.scene:
args.append(Parallel(Func(self.fade_out), LerpFunc(self.blur_out, duration=0.2)))
args.append(Wait(0.2))
args.append(Func(self._set_scene, scene_module))
args.append(Parallel(Func(self.fade_in), LerpFunc(self.blur_in, duration=0.4)))
Sequence(*args).start()
def blur_out(self, t):
# index = int(t)
# self.filters.delBlurSharpen()
self.filters.setBlurSharpen(1 - t)
self.filters.setBloom(intensity=t)
def blur_in(self, t):
# index = int(t)
# self.filters.delBlurSharpen()
self.filters.setBlurSharpen(t)
self.filters.setBloom(intensity=-t)
def fade_out(self):
self.transitions.fadeOut(0.2)
def fade_in(self):
self.transitions.fadeIn(0.2)
def _set_scene(self, scene_module):
group, class_ = scene_module.split('.')
module = importlib.import_module('game.scenes.{}'.format(group))
scene_class = getattr(module, class_)
if self.scene:
self.scene.destroy()
del self.scene
self.scene = scene_class(self)
# self.transitions.fadeIn(0.2)
def start(self):
self.channel = Channel()
self.channel.connect()
self.set_scene('auth.AuthScene')
while True:
self.taskMgr.step()
if self.channel.can_read():
for packet in self.channel.read_packets():
self.scene.on_packet(packet)
class Arena(DirectObject):
collshow = False
def initShader(self):
tempnode = NodePath(PandaNode("temp node"))
tempnode.setAttrib(LightRampAttrib.makeSingleThreshold(0.5, 0.9))
tempnode.setShaderAuto()
base.cam.node().setInitialState(tempnode.getState())
self.separation = 1 # Pixels
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setBloom()
if (filterok == False):
addTitle("Toon Shader: Video card not powerful enough to do image postprocessing")
sys.exit
def initCollision(self):
base.cTrav = CollisionTraverser()
base.collisionHandlerEvent = CollisionHandlerEvent()
base.collisionHandlerEvent.addInPattern('%fn-i-%in')
base.collisionHandlerEvent.addOutPattern('%fn-o-%in')
base.collisionHandlerEvent.addAgainPattern('%fn-a-%in')
self.accept('mouseray-a-ground',self.collideGroundAgain)
self.lastX = 0
self.lastDirection = 0
def collideGroundAgain(self,entry):
np_into=entry.getIntoNodePath()
pos = entry.getSurfacePoint(np_into)
pos.setZ(1)
x = pos.getX()
if(x == self.lastX):
return
if(x < self.lastX):
direction = -1
else:
direction = 1
if(direction != self.lastDirection):
if(direction == -1):
self.sonic.left()
self.tails.left()
else:
self.sonic.right()
self.tails.right()
self.lastDirection = direction
self.lastX = x
if (x < -7 ) : pos.setX(-7)
if (x > 7 ) : pos.setX(7)
pos.setY(-7)
self.sonic.collisionNodePath.setPos(pos)
pos.setY(-5)
self.tails.collisionNodePath.setPos(pos)
# self.pandaActor.setPos(pos)
def updateMouseTask(self, task):
if base.mouseWatcherNode.hasMouse():
mpos=base.mouseWatcherNode.getMouse()
self.mouse.collisionRay.setFromLens(base.camNode, mpos.getX(),mpos.getY())
return task.cont
def mouseClick(self):
messenger.send("Spider")
print 'click'
def toggle_collisions(self):
self.collshow = not self.collshow
if self.collshow:
self.collisionTraverser.showCollisions(base.render)
l=base.render.findAllMatches("**/+CollisionNode")
for cn in l: cn.show()
else:
self.collisionTraverser.hideCollisions()
l=base.render.findAllMatches("**/+CollisionNode")
for cn in l: cn.hide()
def toggle_wire(self):
base.toggleWireframe()
base.toggleTexture()
def __init__(self):
base.audio = Audio()
base.audio.play('complex')
self.initShader()
self.initCollision()
self.camera = Camera()
self.mouse = Mouse()
self.ground = Ground()
self.smiley = Smiley()
self.frowney = Frowney()
self.gorrila = Gorrila()
self.sonic = Sonic()
self.tails = Tails()
self.monster = Monster()
base.arrow = Arrow()
self.dragon = Dragon()
self.panda = Panda()
self.pandaren = Pandaren()
self.tombstone = Tombstone()
self.tombstone.spiders = []
for i in range(50):
self.tombstone.spiders.append(Spider(str(i)))
self.tombstone.batch()
taskMgr.add(self.updateMouseTask, "updatePicker")
self.accept('escape',sys.exit)
self.accept('mouse1',self.mouseClick)
def __init__(self):
"""Start the app."""
self.base = ShowBase()
self.base.disableMouse()
filters = CommonFilters(self.base.win, self.base.cam)
filters.setBloom(blend=(0, 0, 0, 1))
self.base.render.setShaderAuto(
BitMask32.allOn() & ~BitMask32.bit(Shader.BitAutoShaderGlow))
ts = TextureStage('ts')
ts.setMode(TextureStage.MGlow)
tex = self.base.loader.loadTexture('models/black.png')
self.base.render.setTexture(ts, tex)
self.terrain = Terrain(self.base.render, self.base.loader)
minimap_size = 200
self.minimap = Minimap(
self.base.win.makeDisplayRegion(
1 - minimap_size / self.base.win.getProperties().getXSize(), 1,
1 - minimap_size / self.base.win.getProperties().getYSize(),
1))
self.minimap.node_path.reparentTo(self.base.render)
# self.light_nodes =
self.set_lights()
self.set_fog()
self.key_state = dict.fromkeys(Object.values(config.key_map.character),
False)
self.set_key_state_handler()
self.game_state = "pause"
self.toggle_pause()
self.selection = Selection(self.base.loader, self.terrain.geom_node)
self.selection_text = OnscreenText(
mayChange=True,
scale=0.07,
align=TextNode.ALeft,
pos=(0.02 - self.base.getAspectRatio(), 1 - 0.07))
self.timer_text = OnscreenText(mayChange=True,
scale=0.07,
align=TextNode.ALeft,
pos=(0.02 - self.base.getAspectRatio(),
-1 + 0.02 + 0.07))
self.enemies = set()
self.base.accept(config.key_map.utility.pause, self.toggle_pause)
self.base.accept(
"q", lambda: self.selection.advance_tower(self.base.loader))
self.base.accept("mouse1", self.player_click)
self.base.cam.node().setCameraMask(BitMask32.bit(0))
self.base.setBackgroundColor(*config.map_params.colors.sky)
self.player = Player()
self.base.taskMgr.add(lambda task: self.terrain.start_up(), "start up")
self.mouse_pos = (0.0, 0.0)
self.base.taskMgr.add(self.move_player_task, "move_player_task")
self.base.taskMgr.add(self.move_enemies_task, "move_enemies_task")
self.base.taskMgr.add(self.player_select_task, "player_select_task")
self.base.taskMgr.add(self.tower_task, "tower_task")
self.base.taskMgr.add(self.check_end_game, "check_end_game_task")
rand = Random()
rand.seed(config.map_params.seed)
self.base.taskMgr.doMethodLater(1,
self.clock_task,
'clock_task',
extraArgs=[rand])
self.rounds = 0
self.coin = 40
class MyApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
# Disable the camera trackball controls.
self.disableMouse()
# Load the environment model.
self.environ = self.loader.loadModel("models/environment")
# Reparent the model to render.
self.environ.reparentTo(self.render)
# Apply scale and position transforms on the model.
self.environ.setScale(0.25, 0.25, 0.25)
self.environ.setPos(-8, 42, 0)
# Add the spinCameraTask procedure to the task manager.
self.taskMgr.add(self.spinCameraTask, "SpinCameraTask")
# Load and transform the panda actor.
self.pandaActor = Actor(models="models/panda-model",
anims={"walk": "models/panda-walk4"})
self.pandaActor.setScale(0.005, 0.005, 0.005)
self.pandaActor.reparentTo(self.render)
# Loop its animation.
self.pandaActor.loop("walk")
# Create the four lerp intervals needed for the panda to
# walk back and forth.
A = Point3(0, 10, 0)
B = Point3(0, -10, 0)
pandaPosInterval1 = self.pandaActor.posInterval(13, B, startPos=A)
pandaPosInterval2 = self.pandaActor.posInterval(13, A, startPos=B)
pandaHprInterval1 = self.pandaActor.hprInterval(3,
Point3(180, 0, 0),
startHpr=Point3(
0, 0, 0))
pandaHprInterval2 = self.pandaActor.hprInterval(3,
Point3(0, 0, 0),
startHpr=Point3(
180, 0, 0))
# Create and play the sequence that coordinates the intervals.
self.pandaPace = Sequence(pandaPosInterval1,
pandaHprInterval1,
pandaPosInterval2,
pandaHprInterval2,
name="pandaPace")
self.pandaPace.loop()
self.teapot = self.loader.loadModel('models/teapot')
self.teapot.reparentTo(self.render)
self.console = Console(self)
self.filters = CommonFilters(self.win, self.cam)
self.filters.setCartoonInk()
self.filters.setAmbientOcclusion()
self.filters.setBloom()
# Define a procedure to move the camera.
def spinCameraTask(self, task):
angleDegrees = task.time * 6.0
angleRadians = angleDegrees * (pi / 180.0)
self.camera.setPos(20 * sin(angleRadians), -20.0 * cos(angleRadians),
3)
self.camera.setHpr(angleDegrees, 0, 0)
return Task.cont
class ConfigRender:
def __init__(self):
render.setAntialias(AntialiasAttrib.MAuto)
# render.setRenderModeWireframe()
DGG.getDefaultFont().setPixelsPerUnit(100)
self.setShaders()
self.initLights()
self.initTransitions()
self.setFPS()
self.setCam()
def setCam(self):
base.camLens.setNearFar(10, 500)
# base.camLens.setFov(40)
def setShaders(self):
if not base.win.getGsg().getSupportsBasicShaders():
print(
"Toon Shader: Video driver reports that Cg shaders are not supported."
)
return
tempnode = NodePath(PandaNode("temp node"))
tempnode.setAttrib(LightRampAttrib.makeHdr0())
self.filters = CommonFilters(base.win, base.cam)
# GLOW
self.filters.setBloom(blend=(0.3, 0.4, 0.3, 0.0),
mintrigger=0.6,
maxtrigger=1.0,
desat=0.6,
intensity=1.0,
size="medium")
tempnode.setShaderAuto()
base.cam.node().setInitialState(tempnode.getState())
def initLights(self):
ambientLight = AmbientLight("ambient_light")
ambientLight.setColor((0.2, 0.2, 0.2, 1))
self.alnp = render.attachNewNode(ambientLight)
sunLens = PerspectiveLens()
sunLens.setFilmSize(50)
sun = DirectionalLight("sun")
sun.setColor((1, 1, 1, 1))
# sun.setShadowCaster(True, 4096, 4096) # highest working value
sun.setScene(render)
# sun.showFrustum()
sunLens.setFov(120, 40)
sunLens.setNearFar(2, 100)
sun.setLens(sunLens)
self.sunNp = render.attachNewNode(sun)
def setFPS(self):
FPS = 30
globalClock = ClockObject.getGlobalClock()
globalClock.setMode(ClockObject.MLimited)
globalClock.setFrameRate(FPS)
def initTransitions(self):
self.transitions = Transitions(loader)
self.transitions.setFadeColor(0, 0, 0)
self.transitionTime = 0.2
base.accept("fadeOut", self.transitions.fadeOut, [self.transitionTime])
base.accept("fadeIn", self.transitions.fadeIn, [self.transitionTime])
base.accept("noFade", self.transitions.noFade)
def fadeInOutSequence(self, callback, callbackArgs=None):
if callbackArgs:
seq = Sequence(
Func(base.messenger.send, 'fadeOut'),
Wait(self.transitionTime),
Func(callback, callbackArgs),
Wait(self.transitionTime),
Func(base.messenger.send, 'fadeIn'),
)
else:
seq = Sequence(
Func(base.messenger.send, 'fadeOut'),
Wait(self.transitionTime),
Func(callback),
Wait(self.transitionTime),
Func(base.messenger.send, 'fadeIn'),
)
seq.start()
class Quantus( DirectObject ):
def __init__( self ):
#render.setShaderAuto()
self.perPixelEnabled = False
PStatClient.connect()
base.disableMouse()
base.enableParticles()
render.setAttrib(LightRampAttrib.makeHdr2())
self.input = KeymapController()
self.input.setCurrentBranch("general.god_mode")
self.dlight = DirectionalLight('dlight')
self.dlight.setColor(VBase4(0.8, 0.8, 0.5, 1))
self.dlnp = render.attachNewNode(self.dlight.upcastToPandaNode())
self.dlnp.setHpr(0, -30, 0)
render.setLight(self.dlnp)
self.alight = AmbientLight('alight')
self.alight.setColor(VBase4(0.1, 0.1, 0.1, 1))
self.alnp = render.attachNewNode(self.alight)
render.setLight(self.alnp)
self.filters = CommonFilters(base.win, base.cam)
self.filters.setBloom()
#self.filters.setVolumetricLighting(caster=self.dlnp)
render.setAntialias(AntialiasAttrib.MAuto)
traverser = CollisionTraverser('traverser name')
base.cTrav = traverser
base.cTrav.setRespectPrevTransform(True)
#self.tank = Tank()
gravityFN = ForceNode('world-forces')
gravityFNP = render.attachNewNode(gravityFN)
gravityForce = LinearVectorForce(0,0,-9.81) #gravity acceleration
gravityFN.addForce(gravityForce)
base.physicsMgr.addLinearForce(gravityForce)
team = Team(0, None, "This team rules!")
self.player = Human(0,0,"ME!!11!!!")
self.tank = Vehicle(0, 100, "tank.x", 1, self.input)
self.tank.addController(self.player, 0)
self.tank.enable()
mapLoader = MapLoader()
self.map = mapLoader.load("Awesome Cool Map.map")
self.map.getRoot().reparentTo(render)
self.tank.create(Vec3(0,0,5000), self.map.getCurrentSector())
self.godMode = GodMode(self.map, self.input)
#self.godMode.enable()
self.accept( "switch_sector", self.switchSector )
self.accept( "god_mode", self.godMode.toggleEnabled )
self.accept( "menu", sys.exit)
self.accept( "per_pixel_lighting", self.togglePerPixelLighting )
self.step()
def switchSector(self):
sectors = self.map.getSectors()
numSectors = len(sectors)
for sectorNum in range(0,numSectors):
if self.map.getCurrentSector() == sectors[sectorNum]:
self.map.setCurrentSector(sectors[(sectorNum+1)%numSectors])
break
def togglePerPixelLighting( self ):
if self.perPixelEnabled:
self.perPixelEnabled = False
render.clearShader()
else:
self.perPixelEnabled = True
render.setShaderAuto()
def step( self ):
# render next frame
taskMgr.step()
alight = AmbientLight('amibent')
alight.setColor(VBase4(3, 3, 3, 1))
alnp = render.attachNewNode(alight)
plight = PointLight('point')
plight.setColor(VBase4(0.8, 0.8, 0.8, 1))
plnp = render.attachNewNode(plight)
plnp.setPos(0, 0, 1)
render.setLight(alnp)
pnda = loader.loadModel("panda")
pnda.reparentTo(plnp)
pnda2 = loader.loadModel("panda")
pnda2.reparentTo(render)
pnda2.setPos(0,0,-10)
base.camera.lookAt(pnda)
fltr = CommonFilters(base.win, base.cam)
fltr.setBloom()
#fltr.setGammaAdjust(1.5)
#fltr.setAmbientOcclusion()
#fltr.setBlurSharpen(2)
#fltr.setInverted()
#fltr.setCartoonInk(separation=1, color=(0, 0, 0, 1))
#fltr.setVolumetricLighting(pnda, 32, 5.0, 0.1, 0.1)
run()
# from direct.showbase.ShowBase import ShowBase
# from panda3d.core import Plane, Vec3, Point3, CardMaker
# from panda3d.core import WindowProperties
# from panda3d.core import LPoint2f
# class YourClass(ShowBase):
# def __init__(self):
class GlowDemo(ShowBase):
def __init__(self):
# Initialize the ShowBase class from which we inherit, which will
# create a window and set up everything we need for rendering into it.
ShowBase.__init__(self)
base.disableMouse()
base.setBackgroundColor(0, 0, 0)
camera.setPos(0, -50, 0)
# Check video card capabilities.
if not base.win.getGsg().getSupportsBasicShaders():
addTitle(
"Glow Filter: Video driver reports that Cg shaders are not supported."
)
return
# Use class 'CommonFilters' to enable a bloom filter.
# The brightness of a pixel is measured using a weighted average
# of R,G,B,A. We put all the weight on Alpha, meaning that for
# us, the framebuffer's alpha channel alpha controls bloom.
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setBloom(blend=(0, 0, 0, 1),
desat=-0.5,
intensity=3.0,
size="small")
if (filterok == False):
addTitle(
"Toon Shader: Video card not powerful enough to do image postprocessing"
)
return
self.glowSize = 1
# Post the instructions
self.title = addTitle("Panda3D: Tutorial - Glow Filter")
self.inst1 = addInstructions(0.06, "ESC: Quit")
self.inst2 = addInstructions(
0.12, "Space: Toggle Glow Filter Small/Med/Large/Off")
self.inst3 = addInstructions(0.18, "Enter: Toggle Running/Spinning")
self.inst4 = addInstructions(0.24,
"V: View the render-to-texture results")
# load our model
self.tron = Actor()
self.tron.loadModel("models/tron")
self.tron.loadAnims({"running": "models/tron_anim"})
self.tron.reparentTo(render)
self.interval = self.tron.hprInterval(60, LPoint3(360, 0, 0))
self.interval.loop()
self.isRunning = False
# put some lighting on the model
dlight = DirectionalLight('dlight')
alight = AmbientLight('alight')
dlnp = render.attachNewNode(dlight)
alnp = render.attachNewNode(alight)
dlight.setColor((1.0, 0.7, 0.2, 1))
alight.setColor((0.2, 0.2, 0.2, 1))
dlnp.setHpr(0, -60, 0)
render.setLight(dlnp)
render.setLight(alnp)
# Panda contains a built-in viewer that lets you view the results of
# your render-to-texture operations. This code configures the viewer.
self.accept("v", base.bufferViewer.toggleEnable)
self.accept("V", base.bufferViewer.toggleEnable)
base.bufferViewer.setPosition("llcorner")
base.bufferViewer.setLayout("hline")
# base.camLens.setFov(100)
# event handling
self.accept("space", self.toggleGlow)
self.accept("enter", self.toggleDisplay)
self.accept("escape", sys.exit, [0])
def toggleGlow(self):
self.glowSize = self.glowSize + 1
if self.glowSize == 4:
self.glowSize = 0
self.filters.setBloom(blend=(0, 0, 0, 1),
desat=-0.5,
intensity=3.0,
size=self.glowSize)
def toggleDisplay(self):
self.isRunning = not self.isRunning
if not self.isRunning:
camera.setPos(0, -50, 0)
self.tron.stop("running")
self.tron.pose("running", 0)
self.interval.loop()
else:
camera.setPos(0, -170, 3)
self.interval.finish()
self.tron.setHpr(0, 0, 0)
self.tron.loop("running")
