def __init__(self, parent, res=(1024, 768)): self.parent = parent # Init pipe ShowBase() base.makeDefaultPipe() screen = (base.pipe.getDisplayWidth(), base.pipe.getDisplayHeight()) win = WindowProperties.getDefault() xsize = ConfigVariableInt("resx", res[0]).getValue() ysize = ConfigVariableInt("resy", res[1]).getValue() win.setSize(xsize, ysize) win.setFullscreen(False) base.openDefaultWindow(win)
def __init__(self): self.hasConfig = False # if exist load the config file if os.path.exists(prcFile): loadPrcFile(Filename.fromOsSpecific(prcFile)) self.hasConfig = True # set the variables using the config files content or set a default value self.UDPPORT = ConfigVariableInt('udp-port', '6002').getValue() self.TCPPORT = ConfigVariableInt('tcp-port', '6000').getValue() self.UDPPORTSERVER = ConfigVariableInt('udp-port-server', '6001').getValue() self.SERVERIP = ConfigVariableString('server-ip', '127.0.0.1').getValue() self.TIMEOUT = ConfigVariableInt('timeout-in-ms', '3000').getValue()
def __init__(self): self._doId2name2data = {} # maximum # of objects we will cache data for self._size = ConfigVariableInt('crdatacache-size', 10).getValue() assert self._size > 0 # used to preserve the cache size self._junkIndex = 0
def __init__(self): dcFileNames = ['../direct.dc'] # a distributed object of our game. self.distributedObject = None self.aiDGameObect = None ClientRepository.__init__( self, dcFileNames = dcFileNames, threadedNet = True) # Set the same port as configured on the server to be able to connect # to it tcpPort = ConfigVariableInt('server-port', 4400).getValue() # Set the IP or hostname of the server we want to connect to hostname = ConfigVariableString('server-host', '127.0.0.1').getValue() # Build the URL from the server hostname and port. If your server # uses another protocol then http you should change it accordingly. # Make sure to pass the connectMethod to the ClientRepository.__init__ # call too. Available connection methods are: # self.CM_HTTP, self.CM_NET and self.CM_NATIVE self.url = URLSpec('http://{}:{}'.format(hostname, tcpPort)) # Attempt a connection to the server self.connect([self.url], successCallback = self.connectSuccess, failureCallback = self.connectFailure)
def __init__(self): self._http_client = HTTPClient() max_http_requests = ConfigVariableInt('http-max-requests', 900).value self._request_allocator = UniqueIdAllocator(0, max_http_requests) self._poll_task = None self._requests = {}
def __init__(self): """ The AI Repository usually lives on a server and is responsible for server side logic that will handle game objects """ # List of all dc files that are of interest to this AI Repository dcFileNames = ['../direct.dc', 'sample.dc'] # Initialize the repository. We pass it the dc files and as this is an # AI repository the dcSuffix AI. This will make sure any later calls to # createDistributedObject will use the correct version. # The connectMethod ClientRepository.__init__(self, dcFileNames=dcFileNames, dcSuffix='AI', threadedNet=True) # Set the same port as configured on the server to be able to connect # to it tcpPort = ConfigVariableInt('server-port', 4400).getValue() # Set the IP or hostname of the server we want to connect to hostname = ConfigVariableString('server-host', '127.0.0.1').getValue() # Build the URL from the server hostname and port. If your server # doesn't use http you should change it accordingly. Make sure to pass # the connectMethod to the ClientRepository.__init__ call too. # Available connection methods are: # self.CM_HTTP, self.CM_NET and self.CM_NATIVE url = URLSpec('http://{}:{}'.format(hostname, tcpPort)) # Attempt a connection to the server self.connect([url], successCallback=self.connectSuccess, failureCallback=self.connectFailure)
def __init__(self): self.hasConfig = False # if exist load the config file if os.path.exists(prcFile): self.hasConfig = True loadPrcFile(Filename.fromOsSpecific(prcFile)) # set the variables using the config files content or set a default value self.MOTD = ConfigVariableString('motd', 'Welcome to net_core!').getValue() self.HOSTNAME = ConfigVariableString('hostname', '127.0.0.1').getValue() self.TCPPORT = ConfigVariableInt('tcp-port', '6000').getValue() self.BACKLOG = ConfigVariableInt('backlog', '10').getValue() self.UDPPORT = ConfigVariableInt('udp-port', '6001').getValue() self.ISPERSISTENT = ConfigVariableInt('isPersistent', '0').getValue()
def __init__(self): """initialise the server class""" print("SETUP SERVER") tcpPort = ConfigVariableInt("server-port", 4400) dcFileNames = [ "interfaces/direct.dc", "interfaces/gameRoom.dc", "interfaces/chat.dc" ] ServerRepository.__init__(self, tcpPort, dcFileNames=dcFileNames) print("SETUP SERVER DONE")
def __init__(self, namePrefix): self._namePrefix = namePrefix self._durationAverager = Averager('%s-durationAverager' % namePrefix) self._avgSession = None if TaskTracker.MinSamples is None: # number of samples required before spikes start getting identified TaskTracker.MinSamples = ConfigVariableInt( 'profile-task-spike-min-samples', 30).value # defines spike as longer than this multiple of avg task duration TaskTracker.SpikeThreshold = TaskProfiler.GetDefaultSpikeThreshold( )
def __init__(self): #setup logger self.logger = logging.getLogger('ClientLog') hdlr = logging.FileHandler('Client.log') formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s') hdlr.setFormatter(formatter) self.logger.addHandler(hdlr) self.logger.setLevel(logging.DEBUG) #PStatClient.connect() #menu data self.players = None self.active_games = None self.unaccepted_games = None self.waiting_games = None self.news_items = None self.levels = None self.game_id = None self.map = None self.budget = None self.game_name = None self.browser = None self.lobby = None #setup screen (initialize ShowBase to create window) self.screen = Screen(self, (980, 720)) self.rRegion = RocketRegion.make('main_menu', base.win) self.rContext = self.rRegion.getContext() ih = RocketInputHandler() base.mouseWatcher.attachNewNode(ih) self.rRegion.setInputHandler(ih) # Setup FSM self.fsm = AppFSM(self, 'AppFSM') # Init Network parameters server_ip = ConfigVariableString("server-ip", "127.0.0.1").getValue() server_port = ConfigVariableInt("server-port", "56005").getValue() ClientMsg.setupAddress(server_ip, server_port) ClientMsg.notify = self.logger # Initialize network communicator self.net_manager = Net(self) self.net_manager.startNet() base.accept('i', render.ls) # Start with Login screen self.fsm.request('Login')
def __init__(self): """initialise the server class""" # get the port number from the configuration file # if it doesn't exist, we use 4400 as the default tcpPort = ConfigVariableInt('server-port', 4400).getValue() # list of all needed .dc files dcFileNames = ['../direct.dc'] # initialise a threaded server on this machine with # the port number and the dc filenames ServerRepository.__init__(self, tcpPort, dcFileNames=dcFileNames, threadedNet=True)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.accept('discord-ready', self.on_discord_ready) self.accept('discord-disconnect', self.on_discord_disconnect) self.userExit = self.showbase_shutdown self.application_id = ConfigVariableString('discord-application-id', '').value self.steam_id = ConfigVariableString('discord-steam-id', '').value self.connection = DiscordConnection.get_global_ptr() self.connection.connect(self.application_id, self.steam_id) self.max_users = ConfigVariableInt('match-max-users', 4).value self.current_users = 1 self.taskMgr.add(self.update_discord_task, 'discord-update-task') self.accept('a', self.adjust_users, [1]) self.accept('z', self.adjust_users, [-1])
f = open(path+'config.txt', 'r') for line in f: if not line.startswith('#'): loadPrcFileData('',line) except IOError: print "No custom config file" from panda3d.core import WindowProperties from panda3d.core import ConfigVariableInt from panda3d.core import ConfigVariableBool from panda3d.core import ConfigVariableString config_nude=ConfigVariableInt('loverslab', 0) config_aa=ConfigVariableInt('multisamples', 0) buff_size=ConfigVariableInt('buffer-size', 1024) config_fulscreen=ConfigVariableBool('fullscreen') config_win_size=ConfigVariableInt('win-size', '640 480') config_autoshader=ConfigVariableBool('use-shaders', 0) config_bloom=ConfigVariableBool('bloom', 1) config_music=ConfigVariableInt('music-volume', '30') config_sfx=ConfigVariableInt('sound-volume', '100') config_safemode=ConfigVariableBool('safemode', 0) #keys config_forward=ConfigVariableString('key_forward', 'w|arrow_up') config_back=ConfigVariableString('key_back', 's|arrow_down') config_left=ConfigVariableString('key_left', 'a|arrow_left') config_right=ConfigVariableString('key_right', 'd|arrow_right') config_camera_left=ConfigVariableString('key_cam_left', 'q|delete') config_camera_right=ConfigVariableString('key_cam_right', 'e|page_down') config_action1=ConfigVariableString('key_action1', 'mouse1|enter') config_action2=ConfigVariableString('key_action2', 'mouse3|space') config_zoomin=ConfigVariableString('key_zoomin', 'wheel_up|r')
def execCommand(self, command, mwMgrId, avId, zoneId): length = ConfigVariableInt("ai-debug-length", 300) text = str(self.__execMessage(command))[:length.value] self.notify.info(text)
def getConfigInt(name, default): output = ConfigVariableInt(name, default).getValue() if RUNTYPE != 'python': if AppRunnerGlobal.appRunner.getTokenInt(name): output = AppRunnerGlobal.appRunner.getTokenInt(name) return output
except IOError: print("No config file, using default") try: f = open(path+'config.txt', 'r') for line in f: if not line.startswith('#'): loadPrcFileData('',line) except IOError: print("No custom config file") from panda3d.core import WindowProperties from panda3d.core import ConfigVariableInt from panda3d.core import ConfigVariableBool from panda3d.core import ConfigVariableString config_aa=ConfigVariableInt('multisamples', 0) buff_size=ConfigVariableInt('buffer-size', 1024) config_fulscreen=ConfigVariableBool('fullscreen') config_win_size=ConfigVariableInt('win-size', '640 480') config_autoshader=ConfigVariableBool('use-shaders', 0) config_bloom=ConfigVariableBool('bloom', 1) config_music=ConfigVariableInt('music-volume', '10') config_sfx=ConfigVariableInt('sound-volume', '100') config_safemode=ConfigVariableBool('safemode', 0) #keys config_menuitems=ConfigVariableString('key_menuitems', 'v') config_useitem=ConfigVariableString('key_useitem', 'u') config_nextitem=ConfigVariableString('key_nextitem', 'i') config_forward=ConfigVariableString('key_forward', 'w|arrow_up') config_back=ConfigVariableString('key_back', 's|arrow_down') config_left=ConfigVariableString('key_left', 'a|arrow_left')
def downloadContentsFile(self, http, redownload=False, hashVal=None): """ Downloads the contents.xml file for this particular host, synchronously, and then reads it. Returns true on success, false on failure. If hashVal is not None, it should be a HashVal object, which will be filled with the hash from the new contents.xml file.""" if self.hasCurrentContentsFile(): # We've already got one. return True if self.appRunner and self.appRunner.verifyContents == self.appRunner.P3DVCNever: # Not allowed to. return False rf = None if http: if not redownload and self.appRunner and self.appRunner.superMirrorUrl: # We start with the "super mirror", if it's defined. url = self.appRunner.superMirrorUrl + 'contents.xml' request = DocumentSpec(url) self.notify.info("Downloading contents file %s" % (request)) rf = Ramfile() channel = http.makeChannel(False) channel.getDocument(request) if not channel.downloadToRam(rf): self.notify.warning("Unable to download %s" % (url)) rf = None if not rf: # Then go to the main host, if our super mirror let us # down. url = self.hostUrlPrefix + 'contents.xml' # Append a uniquifying query string to the URL to force the # download to go all the way through any caches. We use the # time in seconds; that's unique enough. url += '?' + str(int(time.time())) # We might as well explicitly request the cache to be disabled # too, since we have an interface for that via HTTPChannel. request = DocumentSpec(url) request.setCacheControl(DocumentSpec.CCNoCache) self.notify.info("Downloading contents file %s" % (request)) statusCode = None statusString = '' for attempt in range( int(ConfigVariableInt('contents-xml-dl-attempts', 3))): if attempt > 0: self.notify.info("Retrying (%s)..." % (attempt, )) rf = Ramfile() channel = http.makeChannel(False) channel.getDocument(request) if channel.downloadToRam(rf): self.notify.info("Successfully downloaded %s" % (url, )) break else: rf = None statusCode = channel.getStatusCode() statusString = channel.getStatusString() self.notify.warning( "Could not contact download server at %s" % (url, )) self.notify.warning("Status code = %s %s" % (statusCode, statusString)) if not rf: self.notify.warning("Unable to download %s" % (url, )) try: # Something screwed up. if statusCode == HTTPChannel.SCDownloadOpenError or \ statusCode == HTTPChannel.SCDownloadWriteError: launcher.setPandaErrorCode(2) elif statusCode == 404: # 404 not found launcher.setPandaErrorCode(5) elif statusCode < 100: # statusCode < 100 implies the connection attempt itself # failed. This is usually due to firewall software # interfering. Apparently some firewall software might # allow the first connection and disallow subsequent # connections; how strange. launcher.setPandaErrorCode(4) else: # There are other kinds of failures, but these will # generally have been caught already by the first test; so # if we get here there may be some bigger problem. Just # give the generic "big problem" message. launcher.setPandaErrorCode(6) except NameError, e: # no launcher pass except AttributeError, e: self.notify.warning("%s" % (str(e), )) pass return False
def GetInt(sym, default=0): return ConfigVariableInt(sym, default, "DConfig", ConfigFlags.F_dconfig).value
from panda3d.core import ConfigVariableBool, ConfigVariableString, ConfigVariableInt # Server related config variables sv_max_clients = ConfigVariableInt("sv_max_clients", 24) sv_password = ConfigVariableString("sv_password", "") sv_minupdaterate = ConfigVariableInt("sv_minupdaterate", 1) sv_maxupdaterate = ConfigVariableInt("sv_maxupdaterate", 255) sv_tickrate = ConfigVariableInt("sv_tickrate", 66) # How many past snapshots do we save? sv_snapshot_history = ConfigVariableInt("sv_snapshot_history", 50) sv_port = ConfigVariableInt("sv_port", 27015) sv_alternateticks = ConfigVariableBool("sv_alternateticks", False)
def getInt(self, var, default): return ConfigVariableInt(var, default).getValue()
def _loadConfig (self): """ Loads network configuration defaults. """ self._portAddress = ConfigVariableInt("default-port", DEFAULT_PORT).getValue()
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." )
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()
tk = Tk() tk.title("Kettle3D Launcher") tk.wm_attributes("-topmost", 1) tk.configure(bg='#47ad73') canvas = Canvas(tk, width=500, height=500, bd=0, highlightthickness=0) canvas.pack() tk.update() # username_entry = None # world_entry = None llBtn = None cllBtn = None gllBtn = None title = ConfigVariableString('window-title', 'Kettle3D') fullscreen = ConfigVariableInt('fullscreen', settings["config"]["fullscreen"]) notify_level = ConfigVariableString('default-directnotify-level', settings['config']["log_level"]) c_notify_level = ConfigVariableString('notify-level', settings['config']["c++_log_level"]) glgsg_notify_level = ConfigVariableString('notify-level-glgsg', settings['config']['gl_log_level']) files = pickle.load(open(directory + normpath("assets/files.dat"), 'rb')) catchAllOutputLog.debug("The launcher window opened successfully.") fileManagerOutputLog.debug( "Have 2 files and 2 versions to check or download...") downloadfile = txtfile(path='lib/launcherbase.py', version=4)
#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.
try: f = open(path + 'autoconfig.txt', 'r') for line in f: if not line.startswith('#'): loadPrcFileData('', line) except IOError: print("No config file, using default") loadPrcFileData('', 'show-frame-rate-meter #f') #loadPrcFileData('','win-origin -2 -2') from panda3d.core import ConfigVariableInt from panda3d.core import ConfigVariableBool from panda3d.core import ConfigVariableString config_aa = ConfigVariableInt('multisamples', 0) config_fulscreen = ConfigVariableBool('fullscreen') config_win_size = ConfigVariableInt('win-size', '640 480') config_bloom = ConfigVariableBool('bloom', 1) config_safemode = ConfigVariableBool('safemode', 0) config_eye_enabled = ConfigVariableBool('eye_enabled', 0) config_music = ConfigVariableInt('music-volume', '30') config_sfx = ConfigVariableInt('sound-volume', '100') #keys config_forward = ConfigVariableString('key_forward', 'w|arrow_up') config_back = ConfigVariableString('key_back', 's|arrow_down') config_left = ConfigVariableString('key_left', 'a|arrow_left') config_right = ConfigVariableString('key_right', 'd|arrow_right') config_camera_left = ConfigVariableString('key_cam_left', 'q|delete') config_camera_right = ConfigVariableString('key_cam_right', 'e|page_down') config_action1 = ConfigVariableString('key_action1', 'mouse1|left_eye')
def writeConfig(self): """Save current config in the prc file or if no prc file exists create one. The prc file is set in the prcFile variable""" page = None # #TODO: add any configuration variable names that you have added # to the dictionaries in the next lines. Set the current # configurations value as value in this dictionary and it's # name as key. configVariables = { # set the window size in the config file "win-size": ConfigVariableString( "win-size", "{} {}".format(self.dispWidth, self.dispHeight)).getValue(), # set the default to fullscreen in the config file "fullscreen": "#t" if ConfigVariableBool("fullscreen", True).getValue() else "#f", # particles "particles-enabled": "#t" if self.particleMgrEnabled else "#f", # audio "audio-volume": str(round(self.musicManager.getVolume(), 2)), "audio-music-active": "#t" if self.musicActive else "#f", "audio-sfx-active": "#t" if self.sfxActive else "#f", # logging "notify-output": os.path.join(basedir, "game.log"), # window "framebuffer-multisample": "#t" if ConfigVariableBool("framebuffer-multisample").getValue() else "#f", "multisamples": str(ConfigVariableInt("multisamples", 8).getValue()), "texture-anisotropic-degree": str(ConfigVariableInt("texture-anisotropic-degree").getValue()), "textures-auto-power-2": "#t" if ConfigVariableBool("textures-auto-power-2", True).getValue() else "#f", # server connection "server-host": base.serverHost.getValue(), } page = None # Check if we have an existing configuration file if os.path.exists(prcFile): # open the config file and change values according to current # application settings page = loadPrcFile(Filename.fromOsSpecific(prcFile)) removeDecls = [] for dec in range(page.getNumDeclarations()): # Check if our variables are given. # NOTE: This check has to be done to not loose our base # or other manual config changes by the user if page.getVariableName(dec) in configVariables.keys(): removeDecls.append(page.modifyDeclaration(dec)) for dec in removeDecls: page.deleteDeclaration(dec) else: # Create a config file and set default values cpMgr = ConfigPageManager.getGlobalPtr() page = cpMgr.makeExplicitPage("Application Config") # always write custom configurations for key, value in configVariables.items(): page.makeDeclaration(key, value) # create a stream to the specified config file configfile = OFileStream(prcFile) # and now write it out page.write(configfile) # close the stream configfile.close()
from panda3d.core import ConfigVariableInt cl_cmdrate = ConfigVariableInt("cl_cmdrate", 30) cl_updaterate = ConfigVariableInt("cl_updaterate", 20)