def readerPollUntilEmpty(self, task):
while self.readerPollOnce():
pass
if not metadata.IS_PRODUCTION:
if ConfigVariableBool('simulated-latency', False).getValue():
latency = random.uniform(
ConfigVariableDouble('simulated-latency-min',
0.125).getValue(),
ConfigVariableDouble('simulated-latency-max',
0.15).getValue())
task.delayTime = latency
return task.again
return task.cont
class beastGlobals(DirectObject):
def __init__(self, base):
DirectObject.__init__(self)
self.base = base
'''
Setup point2d NodePath
'''
self.point2d = NodePath(PGTop('point2d'))
self.point2d.node().setMouseWatcher(self.base.mouseWatcherNode)
self.point2d.setDepthTest(False)
self.point2d.setDepthWrite(False)
self.point2d.setMaterialOff(True)
self.point2d.setTwoSided(True)
self.p2dTopLeft = self.point2d.attachNewNode('p2dTopLeft')
self.p2dTopRight = self.point2d.attachNewNode('p2dTopRight')
self.p2dTopCenter = self.point2d.attachNewNode('p2dTopCenter')
self.p2dCenterLeft = self.point2d.attachNewNode('p2dCenterLeft')
self.p2dCenterRight = self.point2d.attachNewNode('p2dCenterRight')
self.p2dBottomLeft = self.point2d.attachNewNode('p2dBottomLeft')
self.p2dBottomRight = self.point2d.attachNewNode('p2dBottomRight')
self.p2dBottomCenter = self.point2d.attachNewNode('p2dBottomCenter')
self.beastPointSize = ConfigVariableDouble('beast-point-size', 1.0).getValue()
self.beastPointSizeAuto = ConfigVariableBool('beast-point-size-auto', False).getValue()
self.beastRenderCache = ConfigVariableBool('beast-render-cache', True).getValue()
self.beastRenderDebug = ConfigVariableBool('beast-render-debug', False).getValue()
self.setPointSize(self.beastPointSize, update = False)
self.setPointSizeAuto(self.beastPointSizeAuto, update = False)
self.accept('window-event', self.windowEvent)
self.originalResolution = (float(self.base.win.getXSize()), float(self.base.win.getYSize()))
def __init__(self, taskMgr, base):
DirectObject.__init__(self)
self.taskMgr = taskMgr
self.base = base
self.setupPoint2d()
self.beastPointSize = ConfigVariableDouble('beast-point-size',
1.0).getValue()
self.beastPointSizeAuto = ConfigVariableBool('beast-point-size-auto',
False).getValue()
self.beastRenderBruteForce = ConfigVariableBool(
'beast-render-brute-force', False).getValue()
self.beastRenderDebug = ConfigVariableBool('beast-render-debug',
False).getValue()
self.setPointSize(self.beastPointSize, update=False)
self.setPointSizeAuto(self.beastPointSizeAuto, update=False)
self.accept('window-event', self.windowEvent)
self.originalResolution = (float(self.base.win.getXSize()),
float(self.base.win.getYSize()))
self.buffer = None
#- If bruteForce == False then we will setup beast frame rendering system
if self.beastRenderBruteForce == False:
self._setupTextureBuffer()
taskMgr.add(self.renderTask, 'beastRender', sort=-100000000)
self.windowEvent()
def __init__(self, world):
self.world = world
self.root = self.world.root.attach_new_node("player")
self.root_target = self.world.root.attach_new_node("player_target")
self.pivot = self.root.attach_new_node("player_pivot")
base.camera.reparent_to(self.pivot)
base.camera.set_z(1.7)
base.cam.node().get_lens().set_fov(90)
self.traverser = CollisionTraverser()
self.ray = setup_ray(
self.pivot,
self.traverser,
self.world.mask,
# ray ends well below feet to register downward slopes
(0, 0, 1),
(0, 0, -1))
self.xyh_inertia = Vec3(0, 0, 0)
h_acc = ConfigVariableDouble('mouse-accelleration', 0.1).get_value()
self.xyh_acceleration = Vec3(0.8, 0.8, h_acc)
self.friction = 0.15
self.torque = 0.5
self.last_up = Vec3(0, 0, 1)
# Collider for portals
csphere = CollisionSphere(0, 0, 1.25, 1.5)
cnode = CollisionNode('player')
cnode.add_solid(csphere)
cnode.set_from_collide_mask(0x2)
cnode.set_into_collide_mask(CollideMask.all_off())
self.collider = self.root.attach_new_node(cnode)
self.event_handler = CollisionHandlerEvent()
self.event_handler.add_in_pattern('into-%in')
self.traverser.add_collider(self.collider, self.event_handler)
self.collider.show()
self.teleported = False
base.input.set_mouse_relativity(True)
#from otp.ai.AIBaseGlobal import *
from direct.directnotify import DirectNotifyGlobal
from direct.showbase.DirectObject import DirectObject
from .ConnectionRepository import *
from panda3d.core import ConfigVariableDouble, ConfigVariableInt, ConfigVariableBool
ASYNC_REQUEST_DEFAULT_TIMEOUT_IN_SECONDS = 8.0
ASYNC_REQUEST_INFINITE_RETRIES = -1
ASYNC_REQUEST_DEFAULT_NUM_RETRIES = 0
if __debug__:
_overrideTimeoutTimeForAllAsyncRequests = ConfigVariableDouble(
"async-request-timeout", -1.0)
_overrideNumRetriesForAllAsyncRequests = ConfigVariableInt(
"async-request-num-retries", -1)
_breakOnTimeout = ConfigVariableBool("async-request-break-on-timeout",
False)
class AsyncRequest(DirectObject):
"""
This class is used to make asynchronos reads and creates to a database.
You can create a list of self.neededObjects and then ask for each to be
read or created, or if you only have one object that you need you can
skip the self.neededObjects because calling askForObject or createObject
will set the self.neededObjects value for you.
Once all the objects have been read or created, the self.finish() method
will be called. You may override this function to run your code in a
derived class.
fgd_files = ConfigVariableList(
"fgd-file", "List of FGD files that are to be loaded by the level editor")
default_material = ConfigVariableString(
"default-material",
#"materials/dev/dev_measuregeneric01.mat",
"maps/smiley.txo",
"The default material to use for solids")
default_point_entity = ConfigVariableString("default-point-entity",
"prop_static",
"The default point entity")
default_solid_entity = ConfigVariableString(
"default-solid-entity", "func_wall",
"The default solid/brush entity. Brushes that get tied to entities are this "
"entity by default.")
default_texture_scale = ConfigVariableDouble(
"default-texture-scale", 1.0, "The default texture scale for solid faces.")
default_lightmap_scale = ConfigVariableInt(
"default-lightmap-scale", 16,
"The default lightmap scale for solid faces. Lower value = more detailed")
default_prop_model = ConfigVariableString(
"default-prop-model", "models/misc/smiley.bam",
"The default model used when placing a prop_static or prop_dynamic entity."
)
from vehicle import TARGET_FLIGHT_HEIGHT
from vehicle import CLIMB_SPEED
from vehicle import HEIGHT_OVER_TARGET
from vehicle import HEIGHT_OVER_TARGET_PROJECTED
from vehicle import REPULSOR_POWER_FRACTION_NEEDED
from vehicle import GYRO_ROTATION
from vehicle import THRUSTER_HEATING
from vehicle import THRUSTER_COOLING
from keybindings import GE_CAMERA_MODE
from controller import DM_STUNT
from controller import DM_CRUISE
COCKPIT_CAMERA = 'fz_cockpit_camera'
first_person_fov = ConfigVariableDouble('first_person_fov', 90).value
third_person_fov = ConfigVariableDouble('third_person_fov', 60).value
class CameraModes(Enum):
FOLLOW = 1
FIXED = 2
COCKPIT = 3
# FIXME: To be merged with FOLLOW
# DIRECTION = 4
# MIXED = 5
def color_gradient(v):
red = v * 2
if red > 1.0:
from direct.showbase.ShowBase import ShowBase
base = ShowBase()
from panda3d.recastnavigation import RNNavMeshManager
nmMgr = RNNavMeshManager.get_global_ptr()
nmMgr.set_root_node_path(render)
nmMgr.get_reference_node_path().reparentTo(render)
nmMgr.start_default_update()
nmMgr.get_reference_node_path_debug().reparentTo(render)
base.nmMgr = nmMgr
from direct.distributed.ClockDelta import globalClockDelta
builtins.globalClockDelta = globalClockDelta
ConfigVariableDouble('decompressor-step-time').setValue(0.01)
ConfigVariableDouble('extractor-step-time').setValue(0.01)
from src.mod import ModGlobals
from src.mod.distributed.ModServerRepository import ModServerRepository
base.sr = ModServerRepository(7032, dcFileNames = ModGlobals.DCFileNames)
def __handleAIReady():
print("AI ready")
base.air.setInterestZones([ModGlobals.UberZoneId, ModGlobals.BattleZoneId])
from direct.distributed.TimeManagerAI import TimeManagerAI
tm = TimeManagerAI(base.air)
tm.generateWithRequiredAndId(ModGlobals.TimeManagerID, 0, ModGlobals.UberZoneId)
def makeBattle():
def GetDouble(sym, default=0.0):
return ConfigVariableDouble(sym, default, "DConfig", ConfigFlags.F_dconfig).value
from src.coginvasion.settings.Setting import SHOWBASE_PREINIT, SHOWBASE_POSTINIT
jsonFile = "settings.json"
sm = SettingsManager()
from src.coginvasion.globals import CIGlobals
CIGlobals.SettingsMgr = sm
sm.loadFile(jsonFile)
sm.doSunriseFor(sunrise=SHOWBASE_PREINIT)
from src.mod.ModBase import ModBase
base = ModBase()
sm.doSunriseFor(sunrise=SHOWBASE_POSTINIT)
ConfigVariableDouble('decompressor-step-time').setValue(0.01)
ConfigVariableDouble('extractor-step-time').setValue(0.01)
from direct.gui import DirectGuiGlobals
DirectGuiGlobals.setDefaultFontFunc(CIGlobals.getToonFont)
DirectGuiGlobals.setDefaultFont(CIGlobals.getToonFont())
DirectGuiGlobals.setDefaultRolloverSound(
loader.loadSfx("phase_3/audio/sfx/GUI_rollover.ogg"))
DirectGuiGlobals.setDefaultClickSound(
loader.loadSfx("phase_3/audio/sfx/GUI_create_toon_fwd.ogg"))
DirectGuiGlobals.setDefaultDialogGeom(
loader.loadModel("phase_3/models/gui/dialog_box_gui.bam"))
from src.coginvasion.nametag import NametagGlobals
NametagGlobals.setMe(base.cam)
NametagGlobals.setCardModel('phase_3/models/props/panel.bam')
"""DistributedSmoothNode module: contains the DistributedSmoothNode class"""
from panda3d.core import NodePath, ConfigVariableDouble
from panda3d.direct import SmoothMover
from .ClockDelta import *
from . import DistributedNode
from . import DistributedSmoothNodeBase
from direct.task.Task import cont
from direct.task.TaskManagerGlobal import taskMgr
from direct.showbase.PythonUtil import report
# This number defines our tolerance for out-of-sync telemetry packets.
# If a packet appears to have originated from more than MaxFuture
# seconds in the future, assume we're out of sync with the other
# avatar and suggest a resync for both.
MaxFuture = ConfigVariableDouble("smooth-max-future", 0.2)
# How frequently can we suggest a resynchronize with another client?
MinSuggestResync = ConfigVariableDouble("smooth-min-suggest-resync", 15)
# These flags indicate whether global smoothing and/or prediction is
# allowed or disallowed.
EnableSmoothing = ConfigVariableBool("smooth-enable-smoothing", True)
EnablePrediction = ConfigVariableBool("smooth-enable-prediction", True)
# These values represent the amount of time, in seconds, to delay the
# apparent position of other avatars, when non-predictive and
# predictive smoothing is in effect, respectively. This is in
# addition to the automatic delay of the observed average latency from
# each avatar, which is intended to compensate for relative clock
# skew.
def GetDefaultSpikeThreshold():
return ConfigVariableDouble('profile-task-spike-threshold', 5.).value
def __init__(self):
ShowBase.__init__(self)
FSM.__init__(self, "FSM-Game")
#
# BASIC APPLICATION CONFIGURATIONS
#
self.disableMouse()
self.setBackgroundColor(0, 0, 0)
self.camLens.setFov(75)
self.camLens.setNear(0.8)
# check if the config file hasn't been created
base.textWriteSpeed = 0.05
mute = ConfigVariableBool("audio-mute", False).getValue()
if mute:
self.disableAllAudio()
else:
self.enableAllAudio()
particles = ConfigVariableBool("particles-enabled", True).getValue()
if particles:
self.enableParticles()
base.textWriteSpeed = ConfigVariableDouble("text-write-speed",0.05).getValue()
base.controlType = ConfigVariableString("control-type", "Gamepad").getValue()
base.mouseSensitivity = ConfigVariableDouble("mouse-sensitivity",1.0).getValue()
if not os.path.exists(prcFile):
self.__writeConfig()
# set window properties
# clear all properties not previously set
self.win.clearRejectedProperties()
# setup new window properties
props = WindowProperties()
# Fullscreen
props.setFullscreen(True)
# window icon
print props.hasIconFilename()
props.setIconFilename(windowicon)
# get the displays width and height
w = self.pipe.getDisplayWidth()
h = self.pipe.getDisplayHeight()
# set the window size to the screen resolution
props.setSize(w, h)
# request the new properties
self.win.requestProperties(props)
atexit.register(self.__writeConfig)
# enable collision handling
base.cTrav = CollisionTraverser("base collision traverser")
base.pusher = CollisionHandlerPusher()
base.pusher.addInPattern('%fn-in-%in')
base.pusher.addOutPattern('%fn-out-%in')
self.menu = Menu()
self.options = OptionsMenu()
self.musicMenu = loader.loadMusic("MayanJingle6_Menu.ogg")
self.musicMenu.setLoop(True)
cm = CardMaker("menuFade")
cm.setFrameFullscreenQuad()
self.menuCoverFade = NodePath(cm.generate())
self.menuCoverFade.setTransparency(TransparencyAttrib.MAlpha)
self.menuCoverFade.setBin("fixed", 1000)
self.menuCoverFade.reparentTo(render2d)
self.menuCoverFade.hide()
self.menuCoverFadeOutInterval = Sequence(
Func(self.menuCoverFade.show),
LerpColorScaleInterval(
self.menuCoverFade,
1,
LVecBase4f(0.0,0.0,0.0,1.0),
LVecBase4f(0.0,0.0,0.0,0.0)),
Func(self.menuCoverFade.hide))
self.menuCoverFadeInInterval = Sequence(
Func(self.menuCoverFade.show),
LerpColorScaleInterval(
self.menuCoverFade,
1,
LVecBase4f(0.0,0.0,0.0,0.0),
LVecBase4f(0.0,0.0,0.0,1.0)),
Func(self.menuCoverFade.hide))
self.lerpAudioFadeOut = LerpFunc(
self.audioFade,
fromData=1.0,
toData=0.0,
duration=0.25,
extraArgs=[self.musicMenu])
self.fadeMusicOut = Sequence(
self.lerpAudioFadeOut,
Func(self.musicMenu.stop))
self.lerpAudioFadeIn = LerpFunc(
self.audioFade,
fromData=0.0,
toData=1.0,
duration=1,
extraArgs=[self.musicMenu])
self.fadeMusicIn = Sequence(
Func(self.musicMenu.play),
self.lerpAudioFadeIn)
self.seqFade = None
self.acceptAll()
self.request("Intro")
def __init__(self):
ShowBase.__init__(self)
FSM.__init__(self, "mainStateMachine")
# some basic enhancements
# window background color
self.setBackgroundColor(0, 0, 0)
# set antialias for the complete sceen to automatic
self.render.setAntialias(AntialiasAttrib.MAuto)
# shader generator
render.setShaderAuto()
# Enhance font readability
DGG.getDefaultFont().setPixelsPerUnit(100)
# hide the mouse cursor
hide_cursor()
#
# CONFIGURATION LOADING
#
# load given variables or set defaults
# check if audio should be muted
mute = ConfigVariableBool("audio-mute", False).getValue()
if mute:
self.disableAllAudio()
else:
self.enableAllAudio()
base.sfxManagerList[0].setVolume(
ConfigVariableDouble("audio-volume-sfx", 1.0).getValue())
base.difficulty = ConfigVariableInt("difficulty", 0).getValue()
def setFullscreen():
"""Helper function to set the window fullscreen
with width and height set to the screens size"""
# get the displays width and height
w = self.pipe.getDisplayWidth()
h = self.pipe.getDisplayHeight()
# set window properties
# clear all properties not previously set
base.win.clearRejectedProperties()
# setup new window properties
props = WindowProperties()
# Fullscreen
props.setFullscreen(True)
# set the window size to the screen resolution
props.setSize(w, h)
# request the new properties
base.win.requestProperties(props)
# check if the config file hasn't been created
if not os.path.exists(prcFile):
setFullscreen()
elif base.appRunner:
# When the application is started as appRunner instance, it
# doesn't respect our loadPrcFiles configurations specific
# to the window as the window is already created, hence we
# need to manually set them here.
for dec in range(mainConfig.getNumDeclarations()):
# check if we have the fullscreen variable
if mainConfig.getVariableName(dec) == "fullscreen":
setFullscreen()
# automatically safe configuration at application exit
base.exitFunc = self.__writeConfig
# due to the delayed window resizing and switch to fullscreen
# we wait some time until everything is set so we can savely
# proceed with other setups like the menus
if base.appRunner:
# this behaviour only happens if run from p3d files and
# hence the appRunner is enabled
taskMgr.doMethodLater(0.5,
self.postInit,
"post initialization",
extraArgs=[])
else:
self.postInit()
def getConfigDouble(name, default):
output = ConfigVariableDouble(name, default).getValue()
if RUNTYPE != 'python':
if AppRunnerGlobal.appRunner.getTokenFloat(name):
output = AppRunnerGlobal.appRunner.getTokenFloat(name)
return output
def getDefaultTimeslice():
# run for 1/2 millisecond per frame by default
# config is in milliseconds, this func returns value in seconds
return ConfigVariableDouble('job-manager-timeslice-ms', .5).value / 1000.