def updateDrawbridges(self): for drawbridge in self.drawbridges: if self.hp <= 0: if base.options.getSpecialEffectsSetting() >= base.options.SpecialEffectsHigh: smokeEffect = SmokeExplosion.getEffect() if smokeEffect: smokeEffect.reparentTo(render) smokeEffect.setPos(drawbridge, 0, 0, 0) smokeEffect.spriteScale = 1.0 smokeEffect.play() posHprIval = LerpPosHprInterval(drawbridge, 1.0, Vec3(drawbridge.getX(), drawbridge.getY(), drawbridge.getZ() - 130.0), Vec3(drawbridge.getH(), drawbridge.getP() - 360.0, drawbridge.getR() + 15)) posHprIval.start() continue
def updateDrawbridges(self): for drawbridge in self.drawbridges: if self.hp <= 0: if base.options.getSpecialEffectsSetting( ) >= base.options.SpecialEffectsHigh: smokeEffect = SmokeExplosion.getEffect() if smokeEffect: smokeEffect.reparentTo(render) smokeEffect.setPos(drawbridge, 0, 0, 0) smokeEffect.spriteScale = 1.0 smokeEffect.play() posHprIval = LerpPosHprInterval( drawbridge, 1.0, Vec3(drawbridge.getX(), drawbridge.getY(), drawbridge.getZ() - 130.0), Vec3(drawbridge.getH(), drawbridge.getP() - 360.0, drawbridge.getR() + 15)) posHprIval.start()
def startCrashEffect(self): if not self.getLocationSeeker() or self.crashBegun: return self.cleanupCrashIval() self.crashBegun = True if self.crashSite is None: self.crashSite = loader.loadModel('phase_6/models/props/piano.bam') self.crashSite.setScale(0.5) self.crashSite.setTransparency(TransparencyAttrib.MAlpha) self.crashSite.setColorScale(1.0, 1.0, 1.0, 0.25) self.crashSite.reparentTo(render) self.crashSiteGag = self.crashSite.find('**/crashed_piano') self.crashSiteGag.setTransparency(TransparencyAttrib.MAlpha) self.crashSiteShadow = self.crashSite.find('**/shadow_crack') # Clean up the collision nodes. for node in self.crashSite.findAllMatches('**/*coll*'): node.removeNode() self.crashSite.show() dropShadow = self.getLocationSeeker().getDropShadow() if not dropShadow: return location = self.getLocationSeeker().getDropShadow().getPos(render) self.crashSite.setPos(location.getX(), location.getY(), location.getZ()) self.crashEndPos = self.crashSiteShadow.getPos() self.crashStartPos = Point3(self.crashEndPos.getX(), self.crashEndPos.getY(), self.crashEndPos.getZ() + 8.5) self.crashSiteIval = Sequence( Func(self.crashSiteShadow.hide), Func(self.crashSiteGag.headsUp, base.localAvatar), Parallel( Sequence( LerpPosHprInterval(self.crashSiteGag, duration=0.75, pos=self.crashEndPos, startPos=self.crashStartPos, startHpr=Point3(0.0, 15.0, 21.30), hpr=Point3(0.0, 0.0, 0.0)), Func(self.crashSiteShadow.show)), ), LerpColorScaleInterval(self.crashSiteShadow, duration=0.75, colorScale=Vec4(1.0, 1.0, 1.0, 0.0), startColorScale=Vec4(1.0, 1.0, 1.0, 1.0)), Func(self.crashSiteShadow.hide), Func(self.crashSiteShadow.setColorScale, 1.0, 1.0, 1.0, 1.0)) self.crashSiteIval.loop()
def move(self, task): diffPos = self.target.getPos() - self.entity.getPos() diffH = (self.target.getH() - self.entity.getH()) % 360 if diffPos.lengthSquared() < 0.001 and -0.1 < diffH < 0.1: if self.isMoving: self.model.stop() self.model.pose("walk", 5) self.isMoving = False else: if not self.isMoving: self.model.loop("run") self.isMoving = True interval = LerpPosHprInterval( self.entity, duration=task.getDelay(), pos=self.target.getPos(), hpr=self.target.getHpr(), name="Character[" + str(self.id) + "].move.interval", ) interval.start() return task.again
def startgame(self): # Transition to the game start state taskMgr.add(self.transition, 'transition') interval = LerpPosHprInterval(self.boxnode, TRANSITIONPERIOD, Point3(0, 0, 0), Point3(0, 0, 0), other=self.worldnode, blendType='easeInOut') interval.start()
class Bot(object): def __init__(self, team, position, direction): self._orders = Actions.DoNothing self._hp = 5 self._death_played = False self._interval = None self.kills = 0 self.team = team self._model = NodePath('bot') self._model.reparentTo(render) self._model.setPos(position) self._model.setHpr(direction, 0, 0) self._model.setColorScale(*self.team) self._model.setScale(.2, .2, .2) # Load the animations self._actor = Actor("models/RockGolem", { 'idle': 'models/RockGolem-idle', 'walk': 'models/RockGolem-walk', 'reverse-walk': 'models/RockGolem-walk', 'punch': 'models/RockGolem-punch', 'death': 'models/RockGolem-death', 'throw': 'models/RockGolem-throw', }) self._actor.setPlayRate(2.65, 'walk') self._actor.setPlayRate(-2.65, 'reverse-walk') self._actor.setPlayRate(4, 'punch') self._actor.setPlayRate(5.25, 'throw') self._actor.setBlend(frameBlend=True) self._actor.reparentTo(self._model) self._actor.loop('idle') self._actor.setH(180) # Floating Label text = TextNode('node name') text.setText(self.__class__.__name__) text.setAlign(TextNode.ACenter) self._name_label = self._model.attachNewNode(text) self._name_label.setBillboardPointEye() self._name_label.setPos(Vec3(0, 0, 6)) self._name_label.setScale(3, 3, 3) # Debug Field of View Cones # fov = make_fov() # fov.reparentTo(self._model) def update(self, tick_number, visible_objects): return Actions.DoNothing def get_position(self): """Return a rounded version of the position vector.""" p = self._model.getPos() return Vec3(round(p.x, 0), round(p.y, 0), round(p.z, 0)) def get_direction(self): """Return a rounded version of the direction vector.""" v = render.getRelativeVector(self._model, Vec3(0, 1, 0)) v.normalize() return Vec3(round(v.x, 0), round(v.y, 0), round(v.z, 0)) def get_name(self): return self.__class__.__name__ def _get_orders(self, tick_number, visible_objects): # If the health is too low, die. if self._hp <= 0: self._orders = Actions.Suicide return # noinspection PyBroadException try: self._orders = self.update(tick_number, visible_objects) except Exception as e: print(type(self), e) self._orders = None def _execute_orders(self, tick_length, battle): # Pre-calculate some useful things new_pos = self.get_position() new_dir = self._model.getHpr() # TODO: Getting rounding errors here velocity = self.get_direction() # If we're outside of the arena, take damage ARENA_SIZE = 13 if new_pos.length() > ARENA_SIZE: battle.announce("{} fled the battle!".format(self.get_name())) self.take_damage(999) # Execute the order if self._orders == Actions.MoveForward: new_pos += velocity self.safe_loop('walk') elif self._orders == Actions.MoveBackward: new_pos -= velocity self.safe_loop('reverse-walk') elif self._orders == Actions.StrafeLeft: v = render.getRelativeVector(self._model, Vec3(-1, 0, 0)) v.normalize() v = Vec3(round(v.x, 0), round(v.y, 0), round(v.z, 0)) new_pos += v self.safe_loop('walk') elif self._orders == Actions.StrafeRight: v = render.getRelativeVector(self._model, Vec3(1, 0, 0)) v.normalize() v = Vec3(round(v.x, 0), round(v.y, 0), round(v.z, 0)) new_pos += v self.safe_loop('walk') elif self._orders == Actions.TurnLeft: new_dir.x += 90 self.safe_loop('walk') elif self._orders == Actions.TurnAround: new_dir.x += 180 self.safe_loop('walk') elif self._orders == Actions.TurnRight: new_dir.x -= 90 self.safe_loop('walk') elif self._orders == Actions.Punch: self.punch(battle) elif self._orders == Actions.DoNothing: self.safe_loop('idle') elif self._orders == Actions.Suicide: self._hp = 0 battle.announce("{} killed itself.".format(self.get_name())) self.take_damage(999) else: # Bad orders detected! Kill this bot. self._hp = 0 battle.announce("{} made an illegal move and died.".format(self.get_name())) self.take_damage(999) # Animate the motion if self._hp <= 0: return self._interval = LerpPosHprInterval( self._model, tick_length-0.05, new_pos, new_dir) self._interval.start() def safe_loop(self, animation): if self._death_played: return if self._actor.getCurrentAnim() != animation: self._actor.loop(animation) def punch(self, battle): if not self._death_played: self._actor.play('punch') hazard = self.get_direction() + self.get_position() bot = battle.get_object_at_position(hazard) if isinstance(bot, Bot): bot.take_damage(5) # TODO: This is fun as 1 if bot._hp > 0: return if bot.team == self.team: message = "{self} killed its teammate {target}!" self.kills -= 1 else: message = "{self} just pwned {target}!" self.kills += 1 battle.announce(message.format(self=self.get_name(), target=bot.get_name()), color=self.team, sfx="Ownage" if self.kills == 1 else None) if self.kills == 2: battle.announce("{} is ON FIRE!".format(self.get_name()), color=(1.0, 0.5, 0.0, 1.0), sfx="DoubleKill") elif self.kills == 3: battle.announce("{} is UNSTOPPABLE!".format(self.get_name()), color=(1.0, 0.5, 0.0, 1.0), sfx="TripleKill") elif self.kills == 4: battle.announce("{} is DOMINATING!".format(self.get_name()), color=(1.0, 0.5, 0.0, 1.0), sfx="Dominating") elif self.kills > 4: battle.announce("{} is GODLIKE!".format(self.get_name()), color=(1.0, 0.5, 0.0, 1.0), sfx="Godlike") def take_damage(self, amount): self._hp -= amount if self._hp <= 0: self._name_label.hide() if self._interval: self._interval.pause() if not self._death_played: self._actor.play('death') self._death_played = True def delete(self): self._model.removeNode() self._actor.cleanup() self._name_label.removeNode()
def _execute_orders(self, tick_length, battle): # Pre-calculate some useful things new_pos = self.get_position() new_dir = self._model.getHpr() # TODO: Getting rounding errors here velocity = self.get_direction() # If we're outside of the arena, take damage ARENA_SIZE = 13 if new_pos.length() > ARENA_SIZE: battle.announce("{} fled the battle!".format(self.get_name())) self.take_damage(999) # Execute the order if self._orders == Actions.MoveForward: new_pos += velocity self.safe_loop('walk') elif self._orders == Actions.MoveBackward: new_pos -= velocity self.safe_loop('reverse-walk') elif self._orders == Actions.StrafeLeft: v = render.getRelativeVector(self._model, Vec3(-1, 0, 0)) v.normalize() v = Vec3(round(v.x, 0), round(v.y, 0), round(v.z, 0)) new_pos += v self.safe_loop('walk') elif self._orders == Actions.StrafeRight: v = render.getRelativeVector(self._model, Vec3(1, 0, 0)) v.normalize() v = Vec3(round(v.x, 0), round(v.y, 0), round(v.z, 0)) new_pos += v self.safe_loop('walk') elif self._orders == Actions.TurnLeft: new_dir.x += 90 self.safe_loop('walk') elif self._orders == Actions.TurnAround: new_dir.x += 180 self.safe_loop('walk') elif self._orders == Actions.TurnRight: new_dir.x -= 90 self.safe_loop('walk') elif self._orders == Actions.Punch: self.punch(battle) elif self._orders == Actions.DoNothing: self.safe_loop('idle') elif self._orders == Actions.Suicide: self._hp = 0 battle.announce("{} killed itself.".format(self.get_name())) self.take_damage(999) else: # Bad orders detected! Kill this bot. self._hp = 0 battle.announce("{} made an illegal move and died.".format(self.get_name())) self.take_damage(999) # Animate the motion if self._hp <= 0: return self._interval = LerpPosHprInterval( self._model, tick_length-0.05, new_pos, new_dir) self._interval.start()
def __init__(self): load_prc_file_data( "", """ win-size 1680 1050 window-title P3D Space Tech Demo Skybox Test 1 show-frame-rate-meter #t framebuffer-multisample 1 multisamples 4 view-frustum-cull 0 textures-power-2 none hardware-animated-vertices #t gl-depth-zero-to-one true clock-frame-rate 60 interpolate-frames 1 cursor-hidden #t fullscreen #f """) # Initialize the showbase super().__init__() gltf.patch_loader(self.loader) props = WindowProperties() props.set_mouse_mode(WindowProperties.M_relative) base.win.request_properties(props) base.set_background_color(0.5, 0.5, 0.8) self.camLens.set_fov(80) self.camLens.set_near_far(0.01, 90000) self.camLens.set_focal_length(7) self.camera.set_pos(-300, -300, 0) # ConfigVariableManager.getGlobalPtr().listVariables() # point light generator for x in range(0, 3): plight_1 = PointLight('plight') # add plight props here plight_1_node = self.render.attach_new_node(plight_1) # group the lights close to each other to create a sun effect plight_1_node.set_pos(random.uniform(-21, -20), random.uniform(-21, -20), random.uniform(20, 21)) self.render.set_light(plight_1_node) # point light for volumetric lighting filter plight_1 = PointLight('plight') # add plight props here plight_1_node = self.render.attach_new_node(plight_1) # group the lights close to each other to create a sun effect plight_1_node.set_pos(random.uniform(-21, -20), random.uniform(-21, -20), random.uniform(20, 21)) self.render.set_light(plight_1_node) scene_filters = CommonFilters(base.win, base.cam) scene_filters.set_bloom() scene_filters.set_high_dynamic_range() scene_filters.set_exposure_adjust(0.6) scene_filters.set_gamma_adjust(1.1) # scene_filters.set_volumetric_lighting(plight_1_node, 32, 0.5, 0.7, 0.1) # scene_filters.set_blur_sharpen(0.9) # scene_filters.set_ambient_occlusion(32, 0.05, 2.0, 0.01, 0.000002) self.accept("f3", self.toggle_wireframe) self.accept("escape", sys.exit, [0]) exponential_fog = Fog('world_fog') exponential_fog.set_color(0.6, 0.7, 0.7) # this is a very low fog value, set it higher for a greater effect exponential_fog.set_exp_density(0.00009) # self.render.set_fog(exponential_fog) self.game_start = 0 skybox = self.loader.load_model('skyboxes/40k_test.gltf') skybox.reparent_to(self.camera) skybox.setCompass() skybox.setBin("background", 1) skybox.setDepthWrite(False) aster_bool = False # add some asteroids for x in range(100): ran_pos = Vec3(random.uniform(-300, 300), random.uniform(-300, 300), random.uniform(-300, 300)) if not aster_bool: asteroid = self.loader.load_model('models/asteroid_1.gltf') aster_bool = True if aster_bool: asteroid = self.loader.load_model('models/asteroid_2.gltf') aster_bool = False asteroid.reparent_to(self.render) asteroid.set_pos(ran_pos) asteroid.set_scale(random.uniform(0.1, 10)) a_pos = asteroid.get_pos() ran_inter = random.uniform(-20, 20) ran_h = random.uniform(-180, 180) asteroid.set_h(ran_h) a_rotate = LerpPosHprInterval(asteroid, 100, (a_pos[0] + ran_inter, a_pos[1] + ran_inter, a_pos[2] + ran_inter), (360, 360, 0)).loop() # load the scene shader scene_shader = Shader.load(Shader.SL_GLSL, "shaders/simplepbr_vert_mod_1.vert", "shaders/simplepbr_frag_mod_1.frag") self.render.set_shader(scene_shader) self.render.set_antialias(AntialiasAttrib.MMultisample) scene_shader = ShaderAttrib.make(scene_shader) scene_shader = scene_shader.setFlag(ShaderAttrib.F_hardware_skinning, True) # directly make a text node to display text text_2 = TextNode('text_2_node') text_2.set_text("P3D Space Tech Demo Skybox Test") text_2_node = self.aspect2d.attach_new_node(text_2) text_2_node.set_scale(0.04) text_2_node.set_pos(-1.4, 0, 0.8) # import font and set pixels per unit font quality nunito_font = self.loader.load_font('fonts/Nunito/Nunito-Light.ttf') nunito_font.set_pixels_per_unit(100) nunito_font.set_page_size(512, 512) # apply font text_2.set_font(nunito_font) text_2.set_text_color(0.1, 0.1, 0.1, 1) # 3D player movement system begins self.keyMap = { "left": 0, "right": 0, "forward": 0, "backward": 0, "run": 0, "jump": 0, "up": 0, "down": 0 } def setKey(key, value): self.keyMap[key] = value # define button map self.accept("a", setKey, ["left", 1]) self.accept("a-up", setKey, ["left", 0]) self.accept("d", setKey, ["right", 1]) self.accept("d-up", setKey, ["right", 0]) self.accept("w", setKey, ["forward", 1]) self.accept("w-up", setKey, ["forward", 0]) self.accept("s", setKey, ["backward", 1]) self.accept("s-up", setKey, ["backward", 0]) self.accept("lshift", setKey, ["up", 1]) self.accept("lshift-up", setKey, ["up", 0]) self.accept("lcontrol", setKey, ["down", 1]) self.accept("lcontrol-up", setKey, ["down", 0]) self.accept("space", setKey, ["jump", 1]) self.accept("space-up", setKey, ["jump", 0]) # disable mouse self.disable_mouse() # the player movement speed self.inc_var = 1 self.max_speed_inc = 0.02 self.max_abs_speed = 0.2 self.inertia_x = 0 self.inertia_y = 0 self.inertia_z = 0 def move(Task): if self.game_start > 0: # get mouse data mouse_watch = base.mouseWatcherNode if mouse_watch.has_mouse(): pointer = base.win.get_pointer(0) mouseX = pointer.get_x() mouseY = pointer.get_y() # screen sizes window_Xcoord_halved = base.win.get_x_size() // 2 window_Ycoord_halved = base.win.get_y_size() // 2 # mouse speed mouseSpeedX = 0.2 mouseSpeedY = 0.2 # maximum and minimum pitch maxPitch = 90 minPitch = -50 # cam view target initialization camViewTarget = LVecBase3f() # clock dt = globalClock.get_dt() if base.win.movePointer(0, window_Xcoord_halved, window_Ycoord_halved): p = 0 if mouse_watch.has_mouse(): # calculate the pitch of camera p = self.camera.get_p() - ( mouseY - window_Ycoord_halved) * mouseSpeedY # sanity checking if p < minPitch: p = minPitch elif p > maxPitch: p = maxPitch if mouse_watch.has_mouse(): # directly set the camera pitch self.camera.set_p(p) camViewTarget.set_y(p) # rotate the self.player's heading according to the mouse x-axis movement if mouse_watch.has_mouse(): h = self.camera.get_h() - ( mouseX - window_Xcoord_halved) * mouseSpeedX if mouse_watch.has_mouse(): # sanity checking if h < -360: h += 360 elif h > 360: h -= 360 self.camera.set_h(h) camViewTarget.set_x(h) if self.inertia_x > self.max_abs_speed: self.inertia_x = self.max_abs_speed if self.inertia_y > self.max_abs_speed: self.inertia_y = self.max_abs_speed if self.inertia_z > self.max_abs_speed: self.inertia_z = self.max_abs_speed if self.keyMap["right"]: if self.inertia_x > 0: self.inertia_x += self.inc_var * dt else: self.inertia_x = self.max_speed_inc self.camera.set_x(self.camera, self.inertia_x) if self.keyMap["left"]: if self.inertia_x < 0: self.inertia_x -= self.inc_var * dt else: self.inertia_x = -self.max_speed_inc self.camera.set_x(self.camera, self.inertia_x) if self.keyMap["forward"]: # print(self.inertia_y) if self.inertia_y > 0: self.inertia_y += self.inc_var * dt else: self.inertia_y = self.max_speed_inc self.camera.set_y(self.camera, self.inertia_y) if self.keyMap["backward"]: if self.inertia_y < 0: self.inertia_y -= self.inc_var * dt else: self.inertia_y = -self.max_speed_inc self.camera.set_y(self.camera, self.inertia_y) if self.keyMap["up"]: if self.inertia_z > 0: self.inertia_z += self.inc_var * dt else: self.inertia_z = self.max_speed_inc self.camera.set_z(self.camera, self.inertia_z) if self.keyMap["down"]: if self.inertia_z < 0: self.inertia_z -= self.inc_var * dt else: self.inertia_z = -self.max_speed_inc self.camera.set_z(self.camera, self.inertia_z) else: self.camera.set_x(self.camera, self.inertia_x) self.camera.set_y(self.camera, self.inertia_y) self.camera.set_z(self.camera, self.inertia_z) return Task.cont def update(Task): if self.game_start < 1: self.game_start = 1 return Task.cont self.task_mgr.add(move) self.task_mgr.add(update)
def SetupModel(self, VUTProject): source = osr.SpatialReference() source.ImportFromEPSG(4326) target = osr.SpatialReference() target.ImportFromEPSG(int(self.OutEPSG)) transform = osr.CoordinateTransformation(source, target) BBxMin = float(self.VRTBoundingBox.split(':')[0].split(',')[0]) BByMin = float(self.VRTBoundingBox.split(':')[0].split(',')[1]) BBxMax = float(self.VRTBoundingBox.split(':')[1].split(',')[0]) BByMax = float(self.VRTBoundingBox.split(':')[1].split(',')[1]) XLenght = BBxMax - BBxMin YLenght = BByMax - BByMin NewBBxMax = BBxMax + XLenght / 2 NewBBxMin = BBxMin - XLenght / 2 NewBByMax = BByMax + YLenght / 2 NewBByMin = BByMin - YLenght / 2 pointMax = ogr.Geometry(ogr.wkbPoint) pointMax.AddPoint(NewBBxMax, NewBByMax) pointMax.Transform(transform) pointMin = ogr.Geometry(ogr.wkbPoint) pointMin.AddPoint(NewBBxMin, NewBByMin) pointMin.Transform(transform) self.BoundingBoxStr = '-te ' + str(pointMin.GetX()) + ' ' + str( pointMin.GetY()) + ' ' + str(pointMax.GetX()) + ' ' + str( pointMax.GetY()) + ' ' self.Moves = Sequence() Line = LineSegs('Path') with open(VUTProject, 'r') as File: Counter = 0 i = 0 PrevCourse = None PrevPos = None PrevHPr = None for line in File: if Counter < 6: pass else: line = line.split() lat = float(line[0]) lon = float(line[1]) ele = float(line[2]) course = float(line[4]) pitch = float(line[5]) roll = float(line[6]) if course < 180: course = -course elif course > 180: course = abs(course - 360) point = ogr.Geometry(ogr.wkbPoint) point.AddPoint(lon, lat) point.Transform(transform) if i == 0: FirstPos = (point.GetX() - self.Origin[0], point.GetY() - self.Origin[1], ele) FirstHpr = (course, pitch, roll) self.cam.setPos(FirstPos) self.cam.setHpr(FirstHpr) Line.move_to(point.GetX() - self.Origin[0], point.GetY() - self.Origin[1], ele) elif i == 1: self.Moves.append( LerpPosHprInterval( self.cam, 1, (point.GetX() - self.Origin[0], point.GetY() - self.Origin[1], ele), (fitDestAngle2Src(PrevCourse, course), pitch, roll), startPos=FirstPos, startHpr=FirstHpr, name='Interval', other=self.render)) Line.draw_to(point.GetX() - self.Origin[0], point.GetY() - self.Origin[1], ele) else: self.Moves.append( LerpPosHprInterval( self.cam, 1, (point.GetX() - self.Origin[0], point.GetY() - self.Origin[1], ele), (fitDestAngle2Src(PrevCourse, course), pitch, roll), startPos=PrevPos, startHpr=PrevHPr, name='Interval', other=self.render)) Line.draw_to(point.GetX() - self.Origin[0], point.GetY() - self.Origin[1], ele) i = i + 1 PrevCourse = course PrevPos = (point.GetX() - self.Origin[0], point.GetY() - self.Origin[1], ele) PrevHPr = (course, pitch, roll) Counter = Counter + 1 Line.setColor(1, 0.5, 0.5, 1) Line.setThickness(3) node = Line.create(False) nodePath = self.render.attachNewNode(node)