class CollisionZoom:
collision: CollisionNode = field(
default_factory=lambda: CollisionNode("cam collisions"))
traverser: CollisionTraverser = field(
default_factory=lambda: CollisionTraverser("cam traverser"))
queue: CollisionHandlerQueue = field(
default_factory=lambda: CollisionHandlerQueue())
body_width: float = 0.5
def levelInit(self, levelname):
# Load a backdrop model and attach it to the Scene Graph
self.environment = loader.loadModel(levelname)
self.environment.reparentTo(render)
# Set up level collision
self.cTrav = CollisionTraverser()
self.pusher = CollisionHandlerPusher()
def setup(self):
self._old_cTrav = base.cTrav
base.cTrav = CollisionTraverser()
base.cTrav.setRespectPrevTransform(True)
if self._debug:
base.cTrav.showCollisions(base.gameState.currentState.objectsNode)
self.addCollider(base.gameState.currentState.objects['equismo'])
def __init__(self):
super().__init__(name='raycaster', eternal=True)
self._picker = CollisionTraverser() # Make a traverser
self._pq = CollisionHandlerQueue() # Make a handler
self._pickerNode = CollisionNode('raycaster')
self._pickerNode.set_into_collide_mask(0)
self._pickerNP = self.attach_new_node(self._pickerNode)
self._picker.addCollider(self._pickerNP, self._pq)
def __init__(self):
# значение шага перемещения клавиатурой
self.key_step = 0.2
# значение шага поворота мышкой
self.mouse_step = 0.2
# координаты центра экрана
self.x_center = base.win.getXSize() // 2
self.y_center = base.win.getYSize() // 2
# перемещаем указатель мышки в центр экрана
base.win.movePointer(0, self.x_center, self.y_center)
# отключаем стандартное управление мышкой
base.disableMouse()
# устанавливаем поле зрения объектива
base.camLens.setFov(80)
# устанавливаем ближайшую границу отрисовки
base.camLens.setNear(0.2)
# устанавливаем текущие значения ориентации камеры
self.heading = 0
self.pitch = 0
# запускаем задачу контроля камеры
taskMgr.doMethodLater(0.02, self.controlCamera, "camera-task")
# регистрируем на нажатие клавиши "Esc"
# событие закрытия приложения
base.accept("escape", base.userExit)
# устанавливаем клавиши управления перемещением камеры
# словарь, хранящий флаги нажатия клавиш
self.keys = dict()
# заполняем словарь
for key in ['a', 'd', 'w', 's', 'q', 'e']:
# создаём запись в словаре
self.keys[key] = 0
# регистрируем событие на нажатие клавиши
base.accept(key, self.setKey, [key, 1])
# регистрируем событие на отжатие клавиши
base.accept(key + '-up', self.setKey, [key, 0])
# создание обходчика столкновений
self.traverser = CollisionTraverser()
# очередь обработки столкновений
self.collisQueue = CollisionHandlerQueue()
# узел для сферы столкновений
self.collisNode = CollisionNode('CameraSphere')
# устанавливаем маску проверки столкновений ОТ
self.collisNode.setFromCollideMask(BitMask32.bit(1))
# сбрасываем маску проверки столкновений ДО
self.collisNode.setIntoCollideMask(BitMask32.allOff())
# создайте сферу столкновения
# ...
# и прикрепите к созданному ранее узлу self.collisNode
# ...
# закрепляем узел на камере
self.collisCamNode = base.camera.attachNewNode(self.collisNode)
# уведомляем обходчик о новом «объекте ОТ»
self.traverser.addCollider(self.collisCamNode, self.collisQueue)
def __init__(self):
ShowBase.__init__(self)
# Override defaults
self.disableMouse()
self.setBackgroundColor(VBase3(160, 200, 150) / 255.0)
self.setFrameRateMeter(True)
# Lights
dlight = DirectionalLight("dlight")
dlnp = self.render.attachNewNode(dlight)
dlnp.setHpr(180.0, -70.0, 0)
self.render.setLight(dlnp)
alight = AmbientLight("alight")
alnp = self.render.attachNewNode(alight)
alight.setColor(VBase4(0.4, 0.4, 0.4, 1))
self.render.setLight(alnp)
# Collision traverser
self.cTrav = CollisionTraverser("collisionTraverser")
#self.cTrav.showCollisions(self.render)
# Collision handlers
self.carCollisionHandler = CollisionHandlerEvent()
self.carCollisionHandler.addInPattern("%fn-into-%in")
# Camera controls
self.cameraController = CameraController(self, 400, math.pi / 4.0,
math.pi / 4.0)
#self.cameraController = CameraController(self, 300, -math.pi, math.pi / 4.0)
# Load the track
#self.track = self.loader.loadModel("models/trackMotegi")
self.track = self.loader.loadModel("models/trackValencia")
checkpointsCollision = self.track.find("checkpoints").node()
checkpointsCollision.setIntoCollideMask(BitMask32(0xF0))
self.numCheckpoints = checkpointsCollision.getNumSolids()
self.track.reparentTo(self.render)
# Load the car
#self.car = KeyboardCar(self)
self.car = NeuralNetworkCar(self)
self.cameraController.follow(self.car.getNodePath())
#self.cameraController.setTarget(self.car.getNodePath())
# Reposition the car
#self.car.getNodePath().setH(180.0)
# Register car collisions with track
self.cTrav.addCollider(self.car.carCollider, self.carCollisionHandler)
self.accept("carCollider-into-trackCollision", self.car.onCrash)
self.accept("carCollider-into-checkpoints", self.car.onCheckpoint)
# State logger
self.loggingActive = False
self.log = []
self.accept("l", self.toggleStateLogger)
def generateGravity(self, NodePath):
base.cTrav = CollisionTraverser()
GravityController = GravityWalker(legacyLifter=True)
GravityController.setWallBitMask(BitmaskGlobals.WallBitmask)
GravityController.setFloorBitMask(BitmaskGlobals.FloorBitmask)
GravityController.initializeCollisions(base.cTrav,
NodePath,
floorOffset=0.025,
reach=4.0)
def __init__(self, app) -> None:
self.app = app
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head, and the other will start above the camera.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
def loadGame(self):
# Setting up key maps and the instruction set into the scene...
LandwalkerGlobals.setKeys()
LandwalkerGlobals.setInstructions()
# Loads our world.
scene = self.loadWorld()
# Makes our local avatar.
localAvatar = actor.makeActor()
base.localAvatar = localAvatar
base.localAvatar.reparentTo(render)
# Load our buttons.
self.LoadButtons()
# Load our shaders.
#fog = loadFog()
#print(fogStats(fog))
EffectsManager.loadShaders()
#FogDensity = EffectsManager.loadFog(1)
# Floater Object (For camera)
floater = NodePath(PandaNode("floater"))
floater.reparentTo(localAvatar)
floater.setY(-10)
floater.setZ(8.5)
floater.setHpr(0, -10, 0)
# Set Camera
camera.reparentTo(floater)
wallBitmask = BitMask32(1)
floorBitmask = BitMask32(2)
base.cTrav = CollisionTraverser()
# Walk controls
walkControls = GravityWalker(legacyLifter=True)
walkControls.setWallBitMask(wallBitmask)
walkControls.setFloorBitMask(floorBitmask)
walkControls.setWalkSpeed(16.0, 24.0, 8.0, 80.0)
walkControls.initializeCollisions(base.cTrav,
localAvatar,
floorOffset=0.025,
reach=4.0)
walkControls.setAirborneHeightFunc(
LandwalkerAvatarControls.getAirborneHeight())
walkControls.enableAvatarControls()
# controlManager.add(walkControls, 'walk')
localAvatar.physControls = walkControls
localAvatar.physControls.placeOnFloor()
# Some debug stuff, should be moved later once I can toggle stuff from different files./
self.onScreenDebug.enabled = True
base.setFrameRateMeter(True)
base.taskMgr.add(LandwalkerAvatarControls.move, "moveTask")
base.taskMgr.add(self.updateOnScreenDebug, 'UpdateOSD')
def __init__(self, name="auto"):
self.ctrav = CollisionTraverser()
self.chan = CollisionHandlerQueue()
self.np = NodePath(name)
self.bitmask_list = [BitMask32(2**n) for n in range(31)]
self._bitmask_ext = BitMask32(
2**31) # 31 is prepared for cd with external non-active objects
self.all_cdelements = [
] # a list of cdlnks or cdobjs for quick accessing the cd elements (cdlnks/cdobjs)
def setupCollision(self):
self.sphere = self.model.attachNewNode(CollisionNode('range'))
self.sphere.node().addSolid(CollisionSphere(0, 0, 0, self.range))
self.sphere.node().setFromCollideMask(BitMask32(2))
self.sphere.node().setIntoCollideMask(BitMask32.allOff())
self.cTrav = CollisionTraverser()
self.cHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.sphere, self.cHandler)
def __init__(self):
try:
self.__initialized
return
except:
self.__initialized = 1
NodePath.__init__(self, hidden.attachNewNode('PositionExaminer'))
self.cRay = CollisionRay(0.0, 0.0, 6.0, 0.0, 0.0, -1.0)
self.cRayNode = CollisionNode('cRayNode')
self.cRayNode.addSolid(self.cRay)
self.cRayNodePath = self.attachNewNode(self.cRayNode)
self.cRayNodePath.hide()
self.cRayBitMask = CIGlobals.FloorBitmask
self.cRayNode.setFromCollideMask(self.cRayBitMask)
self.cRayNode.setIntoCollideMask(BitMask32.allOff())
self.cSphere = CollisionSphere(0.0, 0.0, 0.0, 1.5)
self.cSphereNode = CollisionNode('cSphereNode')
self.cSphereNode.addSolid(self.cSphere)
self.cSphereNodePath = self.attachNewNode(self.cSphereNode)
self.cSphereNodePath.hide()
self.cSphereBitMask = CIGlobals.WallBitmask
self.cSphereNode.setFromCollideMask(self.cSphereBitMask)
self.cSphereNode.setIntoCollideMask(BitMask32.allOff())
self.ccLine = CollisionSegment(0.0, 0.0, 0.0, 1.0, 0.0, 0.0)
self.ccLineNode = CollisionNode('ccLineNode')
self.ccLineNode.addSolid(self.ccLine)
self.ccLineNodePath = self.attachNewNode(self.ccLineNode)
self.ccLineNodePath.hide()
self.ccLineBitMask = CIGlobals.CameraBitmask
self.ccLineNode.setFromCollideMask(self.ccLineBitMask)
self.ccLineNode.setIntoCollideMask(BitMask32.allOff())
self.cRayTrav = CollisionTraverser('PositionExaminer.cRayTrav')
self.cRayTrav.setRespectPrevTransform(False)
self.cRayQueue = CollisionHandlerQueue()
self.cRayTrav.addCollider(self.cRayNodePath, self.cRayQueue)
self.cSphereTrav = CollisionTraverser('PositionExaminer.cSphereTrav')
self.cSphereTrav.setRespectPrevTransform(False)
self.cSphereQueue = CollisionHandlerQueue()
self.cSphereTrav.addCollider(self.cSphereNodePath, self.cSphereQueue)
self.ccLineTrav = CollisionTraverser('PositionExaminer.ccLineTrav')
self.ccLineTrav.setRespectPrevTransform(False)
self.ccLineQueue = CollisionHandlerQueue()
self.ccLineTrav.addCollider(self.ccLineNodePath, self.ccLineQueue)
def __init__(self):
super().__init__(self)
self.scene = self.loader.loadModel("./models/world.egg")
self.scene.reparentTo(self.render)
base.cTrav = CollisionTraverser()
self.collisionHandlerEvent = CollisionHandlerEvent()
base.enableParticles()
#base.messenger.toggleVerbose()
#self.collisionHandlerEvent.addInPattern('from-%in')
self.collisionHandlerEvent.addInPattern('into-%in')
self.collisionHandlerEvent.addOutPattern('outof-%in')
self.player = self.scene.find("player")
self.enemy = self.scene.find("enemy1")
self.player.setPythonTag("ObjectController",
Player(self.player, collisionMask=0x4))
self.building_enemy = self.scene.find("building_enemy")
#self.player.setPos(self.scene, 0,0,5)
self.camera.setPos(self.render, 0, -50, 100)
self.taskMgr.add(self.update, "update")
self.accept('into-collision_enemy', self.crash)
self.accept('into-collision_player', self.crash)
self.accept('into-collision_plane', self.crash)
base.cTrav.addCollider(self.scene.find("player/collision**"),
self.collisionHandlerEvent)
base.cTrav.addCollider(self.scene.find("enemy1/collision**"),
self.collisionHandlerEvent)
base.cTrav.addCollider(self.scene.find("basePlane/collision**"),
self.collisionHandlerEvent)
#base.cTrav.showCollisions(self.render)
InputManager.initWith(self, [
InputManager.arrowUp, InputManager.arrowDown,
InputManager.arrowRight, InputManager.arrowLeft, InputManager.keyS,
InputManager.keyA, InputManager.space, InputManager.keyX,
InputManager.keyV
])
self.rails = self.scene.attachNewNode("rails")
self.rails.setPos(self.scene, 0, 0, 0)
self.rails_y = 0
self.player.reparentTo(self.rails)
self.player.setPos(self.rails, 0, 20, 0)
#self.createStaticEnemy(self.building_enemy , -100 ,500, 0 )
self.createStaticEnemy(self.building_enemy, 200, 850, 0)
self.createStaticEnemy(self.building_enemy, -100, 1000, 0)
self.createDynamicEnemy(self.enemy, -80, 500, 20, -200, 500, 20)
def __init__(self):
#--Collision Handler------------------------------------------------------
self.collHandler = CollisionHandlerEvent()
self.collHandler.addInPattern('%fn-into-%in')
base.cTrav = CollisionTraverser('world traverser')
#--Mouse Control----------------------------------------------------------
base.disableMouse()
self.properties = WindowProperties()
self.properties.setCursorHidden(True)
base.win.requestProperties(self.properties)
#--Register Hud Elements--------------------------------------------------
self.instruction1 = self.addInstruction("[click] to Shoot", 2)
self.instruction2 = self.addInstruction("[a] to accelerate", 1)
self.instruction3 = self.addInstruction("[esc] to quit", 0)
self.scoreHud = self.addHudElement("", 0)
self.accuracy = self.addHudElement("", 1)
self.speedHud = self.addHudElement("", 2)
self.bigHud = OnscreenText(text="",
style=1,
fg=(1, 1, 1, 1),
pos=(0, 0),
align=TextNode.ACenter,
scale=.1)
#--Load Objects and Models------------------------------------------------
self.ship = Ship(self.collHandler)
self.loadSkyBox()
game.camera.reparentTo(self.ship.getModel())
#--Start Game-------------------------------------------------------------
self.asteroids = []
self.resetGame()
#--Controls --------------------------------------------------------------
self.keysDown = {'a': 0}
self.controlTask = taskMgr.add(self.gameLoop, "game-control-task")
self.controlTask.lastTime = 0
self.accept("escape", sys.exit, [0])
self.accept("a", self.keyDown, ['a'])
self.accept("a-up", self.keyUp, ['a'])
self.accept("mouse1", self.shoot)
self.accept("space", self.shoot)
self.accept("resetgame", self.gameOver)
if (DEBUG_CONTROLS):
self.accept("0", self.ship.stop)
self.accept("9", self.ship.getModel().setHpr, [0, 0, 0])
#--Register CollisionEvent Handlers---------------------------------------
self.accept('asteroid-into-bullet', self.bulletAsteroidCollision)
def __init__(self, showbase, usersData, gameData):
DirectObject.__init__(self)
self.showbase = showbase
self.usersData = usersData
self.gameData = gameData
random.seed(self.gameData.randSeed)
# Initialize the collision traverser.
self.cTrav = CollisionTraverser()
# Initialize the handler.
self.collHandEvent = CollisionHandlerEvent()
self.collHandEvent.addInPattern('into-%in')
self.world = World(showbase)
self.ambientLight = showbase.render.attachNewNode(
AmbientLight("ambientLight"))
# Set the color of the ambient light
self.ambientLight.node().setColor((.1, .1, .1, 1))
# add the newly created light to the lightAttrib
# showbase.render.setLight(self.ambientLight)
self.spotlight = None
numberOfPlayers = len(self.usersData)
for index, user in enumerate(self.usersData):
user.centipede = Centipede(showbase, index, numberOfPlayers,
self.addToCollisions)
if user.thisPlayer:
self.centipede = user.centipede
self.centipede.attachRing(showbase)
self.spotlight = self.centipede.head.attachNewNode(
PointLight("playerSpotlight"))
self.spotlight.setPos(LVector3(0, 0, 8))
# Now we create a spotlight. Spotlights light objects in a given cone
# They are good for simulating things like flashlights
self.spotlight.node().setAttenuation(
LVector3(.025, 0.0005, 0.0001))
self.spotlight.node().setColor((0.35, 0.35, .35, 1))
self.spotlight.node().setSpecularColor((0.01, 0.01, 0.01, 1))
showbase.render.setLight(self.spotlight)
self.perPixelEnabled = True
self.shadowsEnabled = True
#if self.spotlight:
# self.spotlight.node().setShadowCaster(True, 512, 512)
showbase.render.setShaderAuto()
self.foods = []
for i in range(self.gameData.maxFoods):
self.foods.append(Food(self.showbase, i, self.addToCollisions))
def make_traverser_handler(self):
base.cTrav = CollisionTraverser()
#base.mchandler = CollisionHandlerEvent()
#base.mchandler = CollisionHandlerPusher()
base.mchandler = PhysicsCollisionHandler()
base.mchandler.addInPattern('into-%in')
base.mchandler.addAgainPattern('%fn-again-%in')
base.mchandler.addOutPattern('out-%in')
base.mchandler.setStaticFrictionCoef(0.91)
base.mchandler.setDynamicFrictionCoef(0.91)
def __init__(self, entity):
self.entity = entity
self.setup_collision()
self.queue = CollisionHandlerQueue()
self.traverser = CollisionTraverser('Collision Traverser')
self.traverser.showCollisions(render)
self.traverser.add_collider(self.target_nodepath, self.queue)
base.taskMgr.add(self.collide, "Collision Task")
def __init__(self, camera, level):
self.camera = camera
self.level = level
self.handler = CollisionHandlerQueue()
self.traverser = CollisionTraverser('traverser')
pickerNode = CollisionNode('mouseRay')
pickerNP = self.camera.attachNewNode(pickerNode)
pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.pickerRay = CollisionRay()
pickerNode.addSolid(self.pickerRay)
self.traverser.addCollider(pickerNP, self.handler)
def setup_interactiongeometries(self):
"""
set up collision rays, spheres, and planes for mouse manipulation
:return: None
author: weiwei
date: 20161110
"""
# create a trackball ray and set its bitmask to 8
# the trackball ray must be a subnode of cam since we will
# transform the clicked point (in the view of the cam) to the world coordinate system
# using the ray
self.tracker_cn = CollisionNode("tracker")
self.tracker_ray = CollisionRay()
self.tracker_cn.addSolid(self.tracker_ray)
self.tracker_cn.setFromCollideMask(BitMask32.bit(8))
self.tracker_cn.setIntoCollideMask(BitMask32.allOff())
self.tracker_np = self.base.cam.attachNewNode(self.tracker_cn)
# create an inverted collision sphere and puts it into a collision node
# its bitmask is set to 8, and it will be the only collidable object at bit 8
self.trackball_cn = CollisionNode("trackball")
self.trackball_cn.addSolid(
CollisionSphere(self.lookatpos_pdv3[0], self.lookatpos_pdv3[1],
self.lookatpos_pdv3[2], self.camdist))
self.trackball_cn.setFromCollideMask(BitMask32.allOff())
self.trackball_cn.setIntoCollideMask(BitMask32.bit(8))
self.trackball_np = self.base.render.attachNewNode(self.trackball_cn)
# self.trackball_np.show()
# This creates a collision plane for mouse track
self.trackplane_cn = CollisionNode("trackplane")
self.trackplane_cn.addSolid(
CollisionPlane(
Plane(
Point3(-self.base.cam.getMat().getRow3(1)),
Point3(self.lookatpos_pdv3[0], self.lookatpos_pdv3[1],
0.0))))
self.trackplane_cn.setFromCollideMask(BitMask32.allOff())
self.trackplane_cn.setIntoCollideMask(BitMask32.bit(8))
self.trackplane_np = self.base.render.attachNewNode(self.trackplane_cn)
# self.trackplane_np.show()
# creates a traverser to do collision testing
self.ctrav = CollisionTraverser()
# creates a queue type handler to receive the collision event info
self.chandler = CollisionHandlerQueue()
# register the ray as a collider with the traverser,
# and register the handler queue as the handler to be used for the collisions.
self.ctrav.addCollider(self.tracker_np, self.chandler)
# create a pickerray
self.picker_cn = CollisionNode('picker')
self.picker_ray = CollisionRay()
self.picker_cn.addSolid(self.picker_ray)
self.picker_cn.setFromCollideMask(BitMask32.bit(7))
self.picker_cn.setIntoCollideMask(BitMask32.allOff())
self.picker_np = self.base.cam.attachNewNode(self.picker_cn)
self.ctrav.addCollider(self.picker_np, self.chandler)
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 __init__(self, name, model):
self.name = name
self.node = NodePath(name + "_character")
self.node.reparent_to(render)
self.model = model
self.model.reparent_to(self.node)
self.traverser = CollisionTraverser()
self.item_ray = self.ray("item", base.itemmask, point_b=(0, 1, 1))
self.movement = Vec3(0, 0, 0)
self.speed = 0.85
self.keys = ""
def setupMouseCollision(self):
self.mouseTraverser = CollisionTraverser()
self.mouseCollisionQueue = CollisionHandlerQueue()
self.mouseRay = CollisionRay()
self.mouseRay.setOrigin(self.pandaScene.camera.getPos(self.pandaScene.render))
self.mouseRay.setDirection(self.pandaScene.render.getRelativeVector(self.pandaScene.camera, Vec3(0,1,0)))
self.mouseNode = CollisionNode('mouseRay')
self.mouseNode.addSolid(self.mouseRay)
self.mouseNodePath = self.pandaScene.camera.attachNewNode(self.mouseNode)
self.mouseNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.mouseTraverser.addCollider(self.mouseNodePath, self.mouseCollisionQueue)
def __init__(self):
base.cTrav = CollisionTraverser()
base.pusher = CollisionHandlerPusher()
ConfigRender.__init__(self)
self.elapsedSeconds = 0
self.mapData = MapsModel()
self.gameData = GameModel('./saves/')
self.load_fonts()
# this needs to be called only when game starts
taskMgr.add(self.updateTime, 'updateTime')
def __init__(self):
"""Setup this app."""
ShowBase.__init__(self)
#Setup window
wnd_props = WindowProperties()
wnd_props.set_title("Neo Impressive Title")
#wnd_props.set_origin(0, 0)
wnd_props.set_size(1024, 768)
self.win.request_properties(wnd_props)
self.set_background_color(0, .5, 1, 1)
#Init GUI sub-system
self.gui = GUI(self)
self.gui.run()
#Init app state
self.state = APP_STATE_LOGO
self.logo_delay = 600
#Start title music
self.title_music = loader.loadMusic("./data/sounds/title.ogg")
self.title_music.set_loop(True)
self.title_music.play()
#Setup collision detection
self.cTrav = CollisionTraverser()
self.portal_handler = CollisionHandlerEvent()
self.portal_handler.add_in_pattern("%fn-entered-%in")
#Init other sub-systems
self.cam_mgr = CameraManager()
self.world_mgr = WorldManager()
#Setup lighting
self.ambient = AmbientLight("Ambient Light")
self.ambient.set_color(Vec4(.5, .5, .5, 1))
self.ambient_np = self.render.attach_new_node(self.ambient)
self.render.set_light(self.ambient_np)
self.sun = DirectionalLight("Sun")
self.sun_np = self.render.attach_new_node(self.sun)
self.sun_np.set_p(-135)
self.render.set_light(self.sun_np)
#Setup auto-shaders
self.render.set_shader_auto()
#Debug stats
#self.messenger.toggle_verbose()
PStatClient.connect()
def __init__(self):
# start Panda3d
base = ShowBase()
# CollisionTraverser instance must be attached to base,
# and must be called cTrav
base.cTrav = CollisionTraverser()
self.cHand = CollisionHandlerEvent()
self.cHand.addInPattern('into-%in')
# load smiley, which we will control
# notice this is a little trickery. If we parent everything except smiley
# to the camera, and the player is controlling the camera, then everything
# stays fixed in the same place relative to the camera, and when the camera
# moves, the player is given the illusion that he is moving smiley, rather than
# the camera and the rest of the scene.
self.smiley = base.loader.loadModel('smiley')
self.smiley.reparentTo(render)
self.smiley.setName('Smiley')
# Setup a collision solid for this model. Our initCollisionSphere method returns
# the cNodepath and the string representing it. We will use the cNodepath for
# adding to the traverser, and the string to accept it for event handling.
#sColl = self.initCollisionSphere(self.smiley)
sColl = self.initCollisionSphere(self.smiley, True)
print 'smiley', sColl[0]
print 'smiley', sColl[1]
# Add this object to the traverser.
base.cTrav.addCollider(sColl[0], self.cHand)
# load frowney
self.frowney = base.loader.loadModel('frowney')
self.frowney.setName('Frowney')
self.frowney.reparentTo(camera)
# Setup a collision solid for this model.
fColl = self.initCollisionSphere(self.frowney, True)
#print 'frowney', fColl[0]
#print 'frowney', fColl[1]
# Add this object to the traverser.
base.cTrav.addCollider(fColl[0], self.cHand)
# Accept the events sent by the collisions.
# smiley is the object we are 'moving', so by convention
# it is the from object.
# If we instead put smiley as the into object here,
# it would work fine, but then smiley would disappear
# when we collided them.
self.accept('into-' + fColl[1], self.collide)
# set the initial positions of smiley and frowney
self.set_initial_positions()
def initMouseToWorldCoordConversion(self):
self.picker = CollisionTraverser()
self.pq = CollisionHandlerQueue()
self.pickerNode = CollisionNode('mouseRay')
self.pickerNP = self.showBase.camera.attachNewNode(self.pickerNode)
self.pickerNode.setFromCollideMask(BitMask32.bit(1))
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
self.picker.addCollider(self.pickerNP, self.pq)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.traverser = CollisionTraverser()
self.queue = CollisionHandlerQueue()
self.picker_ray = CollisionRay()
self.picker_node = CollisionNode('mouse ray')
self.picker_node.add_solid(self.picker_ray)
self.picker_node.set_from_collide_mask(MOUSEOVER_MASK)
self.picker_node.set_into_collide_mask(0x0)
self.picker_node_path = NodePath(self.picker_node)
self.traverser.add_collider(self.picker_node_path, self.queue)
def __init__(self):
self.hitters = [
self.setup_collision_ray(offset, bitmask) for offset, bitmask in [
(-3, BM_LEFT),
(3, BM_RIGHT),
]
]
self.queue = CollisionHandlerQueue()
self.traverser = CollisionTraverser('Collision Traverser')
self.traverser.showCollisions(base.render)
for ray in self.hitters:
self.traverser.add_collider(ray, self.queue)
base.taskMgr.add(self.collide, "Collision Task")
def __init__(self):
super().__init__(
name = 'raycaster',
eternal = True
)
self._picker = CollisionTraverser() # Make a traverser
self._pq = CollisionHandlerQueue() # Make a handler
self._pickerNode = CollisionNode('raycaster')
self._pickerNP = self.attach_new_node(self._pickerNode)
self._collision_ray = CollisionRay() # Make our ray
self._pickerNode.addSolid(self._collision_ray)
self._picker.addCollider(self._pickerNP, self._pq)
self._pickerNP.show()
def __init__(self):
ShowBase.__init__(self)
self.keyMap = {
"up": False,
"down": False,
"left": False,
"right": False,
"shoot": False
}
self.base = base
self.boule_time = 0
base.setFrameRateMeter(True) # mesure le FPS
# Création du plateau de jeu
self.environment = loader.loadModel("./Environment/environment")
self.environment.reparentTo(render)
# Positionnement de la caméra
self.Cam_init()
# Réglages des éclairages
self.ambientLight = AmbientLight("ambient light")
self.Init_eclairage()
# Gestions des collisions avec les autres objets (MUR pour l'instant)
self.pusher = CollisionHandlerPusher()
# Pour la gestion de l'arbre de collisions
base.cTrav = CollisionTraverser()
# gestion des déplacements
self.Init_mvt()
# création du heros selon le modele ./fox/Fox
self.heros = Heros(self, Vec3(0, 0, 0), "./fox/Fox", {
"stand": "./fox/Fox-Idle_fp",
"walk": "./fox/Fox-Walk_fp"
}, 5, 10, "HEROS", 2)
self.heros.actor.reparentTo(render)
# création des objets de décors
self.tour1 = obj_inactifs(Vec3(12, 9, 1), "tour/tour", 0, "T1", 1)
self.tour1.obj.reparentTo(render)
self.tour2 = obj_inactifs(Vec3(-12, 9, 1), "tour/tour", 0, "T2", 1)
self.tour2.obj.reparentTo(render)
self.sorcier = obj_inactifs(Vec3(12, 9, 6), "sorcier/wizard", 130,
"SORCIER", 0.45)
self.sorcier.obj.reparentTo(render)
#init des armes
self.boule = Boule_feu(self)
# initialisation des déplacements
self.Init_mvt()
# initialisation des zones de collisions du decor
self.Init_coll()
# activation des évènements
self.updateTask = taskMgr.add(self.update, "update")
