def disconnect(self): if (self.__connection != None): __tello = None __commanding = False __connection = None notify = DirectNotify().newCategory("") notify.warning("Disonnected!") else: notify = DirectNotify().newCategory("") notify.warning("You are not connected to a drone yet") exit()
def connect(self): if (self.__connection == None): notify = DirectNotify().newCategory("") notify.warning("(Connection placeholder)") self.__connection = "placeholder" notify = DirectNotify().newCategory("") notify.warning("Connected!") #Note: Connecting to the drone will be considered successful for tests else: notify = DirectNotify().newCategory("") notify.warning("Oops, something went wrong connecting the socket") exit()
def __init__(self, parent, newGame, device, devices): self._parent = parent self._notify = DirectNotify().newCategory("Menu") self._notify.info("New Menu-Object created: %s" %(self)) self.device = device #The keybord self.devices = devices #For Wii time.sleep(1) #Bad Hack to make sure that the Key isn't pressed. self.device.boost = False #Bad Hack to make sure that the Key isn't .setColor(self.colorA)pressed. self.newGame = newGame self.track = [] #Wiimotes self.wiimoteX = [] #Font self.font = DynamicTextFont(FONT) self.font.setRenderMode(TextFont.RMSolid) self.CONF_PATH = "user/config.ini" self._conf = settings.Settings() self._conf.loadSettings(self.CONF_PATH) taskMgr.add(self.input, 'input')
def __init__(self, *args, **kwds): ''' ''' self.points = [] self.name = "street part" self.author = "Rage Tracks Team" self.mirrored = True self.texcoords = [] for arg in args: if type(arg) == Vec2: self.points.append(arg) if "name" in list(kwds.keys()): self.name = str(kwds["name"]) if "author" in list(kwds.keys()): self.author = str(kwds["author"]) if "mirrored" in list(kwds.keys()): self.mirrored = bool(kwds["mirrored"]) # if the points should be mirrored, we'll do it if self.mirrored: self.mirrorPoints() self._notify = DirectNotify().newCategory("TrackGen3D") self._notify.info("New StreetData-Object created: %s" % (self))
def __init__(self, camera, parent): """Arguments: camera -- Camera to be used parent -- Aeroplane which the camera should follow """ self.notifier = DirectNotify().newCategory("azure-camera") self.camera = camera self.parent = parent # This gets replaced by a NodePath with all available cameras as # children and plane node as parent in createCamNodes() self.cameras = None #if parent.__class__.__name__ is not "Aeroplane": if not isinstance(self.parent, Aeroplane): raise ParamError, "Parent must be an Aeroplane instance, " + \ "but is %s" % type(self.parent) FSM.__init__(self, "PlaneCamera: %s" % self.parent.name) DirectObject.__init__(self) self.cameras = self.parent.node.find("cameras") if self.cameras.isEmpty(): self.createCamNodes() self.updateCamArray() self.sideview_direction = 0 # Set up the default camera self.setView("ThirdPerson")
class DistributedMinigameStation(DistributedGroupStation, MinigameStation.MinigameStation, DistributedObject): notify = DirectNotify().newCategory("DistributedMinigameStation") def __init__(self, cr): try: self.DistributedMinigameStation_initialized return except: self.DistributedMinigameStation_initialized = 1 MinigameStation.MinigameStation.__init__(self) DistributedObject.__init__(self, cr) return def setStation(self, game): self.generateStation(game) def headOff(self, zone, laffMeter): if self.camIval: self.camIval.finish() self.camIval = None self.deleteStationAbortGui() requestStatus = { 'zoneId': zone, 'hoodId': self.cr.playGame.hood.hoodId, 'where': 'minigame', 'avId': base.localAvatar.doId, 'loader': 'minigame', 'shardId': None, 'wantLaffMeter': laffMeter } self.cr.playGame.getPlace().fsm.request('teleportOut', [requestStatus]) Sequence(Wait(3.0), Func(self.d_leaving)).start()
def __init__(self): #create a new notify category self._notify = DirectNotify().newCategory("CamMovement") self._notify.info("Put some informational text here.") self._notify.debug("Put some informational text here.") self._notify.warning("Put some informational text here.") self._notify.error( "Put some informational text here.") #raise an exeption
def setup(name='Server Name'): log = DirectNotify().newCategory("Allegiance-Server-" + name) log.debug("Loading space drive") spacedrive.init(run_server=True, run_client=False, log_level='debug', window_title='Allegiance 2') log.info("Setting up server network") spacedrive.init_server_net(NetworkSystem, port=47624)
def down(self, distance): self.__commandCheck() if (distance > 500 or distance < 20): #print("Error Line ",self.__get_linenumber,": Please enter amount between 1 and 3600 ") notify = DirectNotify().newCategory("") notify.warning( "Error: For 'down' please enter amount between 20 and 500 ") exit() distance = distance / 10 newz = self.__z - distance if (newz < 10): notify = DirectNotify().newCategory("") notify.warning("Error: You cannot go lower than takeoff distance ") exit() seq = self.droneActor.posInterval(distance / 5, Point3(self.__x, self.__y, newz)) self.__z = newz self.__overallSequence.append(seq)
def land(self): if (self.__z == 0): notify = DirectNotify().newCategory("") notify.warning("The drone has already landed") exit() self.__commandCheck() seq = self.droneActor.posInterval(self.__z / 5, Point3(self.__x, self.__y, 0)) self.__z = 0 self.__overallSequence.append(seq)
def takeoff(self): if (self.__z != 0): notify = DirectNotify().newCategory("") notify.warning("The drone has already taken off") exit() self.__commandCheck() seq = self.droneActor.posInterval( 2, Point3(self.__x, self.__y, self.__z + 10)) self.__z = self.__z + 10 self.__overallSequence.append(seq)
def __init__(self): ''' ''' self._notify = DirectNotify().newCategory("Input") self._notify.info("New Keyboard-Object created: %s" % (self)) base.buttonThrowers[0].node().setButtonUpEvent("button-up") base.buttonThrowers[0].node().setButtonDownEvent("button") base.accept("button-up", self.setKey, [False]) base.accept("button", self.setKey, [True]) self.keys = {}
def __init__(self, gui=None, out_file=None): self.notify = DirectNotify().newCategory('a4p') self.gui = gui self.out_file = None if out_file: self.out_file = open(path + out_file, 'a') self.out_file.write('---<Opening file on: ' + str(datetime.now()) + ' >---\n') self.debug('Logger is now logging') self.debug('Logger gui is ' + str(gui)) self.debug('Logger out_file is ' + str(out_file))
def __init__(self): ''' this class is able to load and save the application's settings ''' self._notify = DirectNotify().newCategory("Settings") self._notify.info("New Settings-Object created: %s" % (self)) self.width = 800 self.height = 600 self.antialias = False self.fullscreen = False self._input_settings = {"keyboard": {}, "joysticks": {}}
def cw(self, amount): self.__commandCheck() if (amount > 3600 or amount < 1): #print("Error Line ",self.__get_linenumber,": Please enter amount between 1 and 3600 ") notify = DirectNotify().newCategory("MyCategory") notify.warning( "Error: For 'cw' please enter amount between 1 and 3600 ") exit() seq = self.droneActor.hprInterval(amount / 45, Vec3(amount, 0, 0)) self.__heading = self.__heading + amount while (self.__heading > 360): self.__heading = self.__heading - 360 self.__overallSequence.append(seq)
def __init__(self, camera): ''' ''' self._notify = DirectNotify().newCategory("PlayerCam") self._notify.info("New PlayerCam-Object created: %s" % (self)) self._position = Vec3(0, -20, 5) self._camera = camera self._vehicle_direction = Vec3(0, 0, 0) # the direction the object is moving self._nodepath = None self._distance = 0.7 self._cam_node = NodePath() self._vehicle = None
def __init__(self): ShowBase.__init__(self) # Load the environment model. self.scene = self.loader.loadModel("models/environment") # Reparent the model to render. self.scene.reparentTo(self.render) # Apply scale and position transforms on the model. self.scene.setScale(0.25, 0.25, 0.25) self.scene.setPos(-8, 42, 0) self.accept('a', self.printRepeat) self.py3notify = DirectNotify().newCategory("Python3_main")
def __init__(self, res, x, y, z=200, player_count=1, street_data=""): ''' ''' self._notify = DirectNotify().newCategory("TrackGen3D") self._notify.info("New Track3D-Object created: %s" % (self)) # street_data = (Vec2(4.0,4.0), Vec2(10.0,10.0), Vec2(10.0,0.0), Vec2(4.0,0.0), Vec2(0.0,-1.0)) # street_data = StreetData(Vec2(15.0,1.0), Vec2(15.0,-5.0), Vec2(0.0,-5.0), mirrored=True) #, Vec2(15.0,0.0) self.street_data = StreetData() # self.street_data.readFile("data/road/road01.xml") # self.street_data.readFile("data/road/tube.xml") if street_data == "": datas = ["road01", "tube"] street_data = datas[random.randint(0, len(datas) - 1)] self.street_data.readFile("data/road/" + street_data + ".xml") self.streetTextrange = 0.0 self.track = Track(x, y, z) self.track.generateTestTrack(player_count) # self.track.generateTrack(player_count) self.track_points = self.track.getInterpolatedPoints(res) self.varthickness = [] # Generate the Vector for thickness of the road self.generateNormals() # for i in range(len(self.track_points)-1): # if i == 0: # self.varthickness.append(self.calcTheVector(self.track_points[i],self.track_points[i],self.track_points[i+1])) #First # continue # self.varthickness.append(self.calcTheVector(self.track_points[i-1],self.track_points[i],self.track_points[i+1])) # self.varthickness.append(self.calcTheVector(self.track_points[len(self.track_points)-2],self.track_points[len(self.track_points)-1],self.track_points[len(self.track_points)-1])) #Last ## # Normalizing the Vector # for i in self.varthickness: # i.normalize() ## # print self.varthickness[-1] # print self.varthickness[0] # print self.varthickness[1] # print self.varthickness[2] # Spin the last 100 Points a litte bit to Vec3(-1,0,0) for i in range(-100, 1): # print self.varthickness[i] * (-i / 100), self.varthickness[i] , ((i* -1) / 100.0), i # print ((i* -1) / 100.0), self.varthickness[i], self.varthickness[i] * ((i* -1) / 100.0) self.varthickness[i] = self.varthickness[i] * (((i + 1) * -1) / 100.0) + Vec3(-1, 0, 0) self.normals[i] = self.normals[i] * (((i + 1) * -1) / 100.0) + Vec3(0, 0, 1) self.varthickness[i].normalize() self.normals[i].normalize()
def __init__(self, cam_count=0): ''' @param cam_count: (int) number of cameras which should be added ''' self._notify = DirectNotify().newCategory("SplitScreen") self._notify.info("New SplitScreen-Object created: %s" % (self)) self.regions = [] # the regions the screen is separated into self.cameras = [] # the cameras (empty ones are None) self.filters = [] # the shader filters applied to each camera self.cameraPosPre = [] # the position of the cameras before change self.steps = 1 self.shaders_on = False if cam_count > 0: # add cameras, if needed self.addCameras(cam_count)
def __init__(self, *args, **kwds): ''' ''' self.points = [] self.name = "special street part" self._notify = DirectNotify().newCategory("TrackGen") for arg in args: if type(arg) == Vec2: self.points.append(arg) if "filename" in list(kwds.keys()): self.readFile(str(kwds["filename"])) if "name" in list(kwds.keys()): self.name = str(kwds["name"])
def setup(): log = DirectNotify().newCategory("Allegiance-Client") log.debug("Loading space drive") spacedrive.init(run_server=False, run_client=True, log_level='debug', window_title='Allegiance 2') log.info('Setting up graphics') #spacedrive.init_graphics(debug_mouse=False) log.info("Setting up client gui") spacedrive.init_gui() spacedrive.base.wireframe = False spacedrive.base.accept("f3", toggleSceneWireframe) spacedrive.gui_system.setup_screen(MainMenu()) log.info("Setting up client network") spacedrive.init_server_net(NetworkSystem)
def __init__(self, size_x, size_y, max_height=2300): ''' the constructor creates an empty track @param size_x: (int) maximum x-coordinates @param size_y: (int) maximum y-coordinates @param max_height: (int) maximum z-coordinates ''' # self.setSize(size_x, size_y, max_height) # self.setSize(8000, 8000, 1000) self.setSize(1600, 1600, 800) self.points = [] self.curve = None self._notify = DirectNotify().newCategory("TrackGen") self._notify.info("New Track-Object created: %s" % (self)) self.prefabs = glob.glob("data/road/parts/*.xml")
def __init__(self, number, ode_world, ode_space, device=None, camera=None): ''' ''' self._notify = DirectNotify().newCategory("Player") self._notify.info("New Player-Object created: %s" % (self)) self._ode_world = ode_world self._ode_space = ode_space self._number = number self._camera = camera self._vehicle = vehicle.Vehicle(self._ode_world, self._ode_space) # the properties of the vehicle self._device = device # The input device # self._osd_health = OnscreenText(text = "100", pos = ((self._number*0.2)-1,0.9)) self._position = 0 self._pre_position = 0 self._rank = 0 self._lap = 1 self._time = 0
def __init__(self, parent): self._notify = DirectNotify().newCategory("Menu") self._notify.info("New Menu-Object created: %s" %(self)) #Font self.font = DynamicTextFont(FONT) self.font.setRenderMode(TextFont.RMSolid) self.KEY_DELAY = 0.15 self.player_buttonpressed = [] self._parent = parent self._players = parent.players self._devices = parent.devices taskMgr.add(self.fetchAnyKey, "fetchAnyKey")
def forward(self, distance): self.__commandCheck() if (distance > 500 or distance < 20): #print("Error Line ",self.__get_linenumber,": Please enter amount between 1 and 3600 ") notify = DirectNotify().newCategory("") notify.warning( "Error: For 'forwards' please enter amount between 20 and 500 " ) exit() distance = distance / 10 newx = (distance * math.cos(self.__heading)) + self.__x newy = (distance * math.sin(self.__heading)) + self.__y seq = self.droneActor.posInterval(distance / 5, Point3(newx, newy, self.__z)) self.__x = newx self.__y = newy self.__overallSequence.append(seq)
def __init__(self, ode_world, ode_space, name="standard"): ''' ''' self._notify = DirectNotify().newCategory("Vehicle") self._notify.info("New Vehicle-Object created: %s" % (self)) self._ode_world = ode_world self._ode_space = ode_space self._model = None self._physics_model = None self._physics_mass = None self._collision_model = None self._speed = 0.0 # the actual speed of the vehicle (forward direction) self._direction = Vec3(0, 0, 0) # the direction the car is heading self._boost_direction = Vec3(0, 0, 0) self._boost_strength = 10.0 # the boost propertys of the vehicle self._control_strength = 1.5 # impact on the steering behaviour self._grip_strength = 0.5 # impact on the steering behaviour self._track_grip = 0.8 # impact on the steering behaviour self._energy = 100.0 self._armor = 100.0 self._max_energy = 100.0 self._max_armor = 100.0 self._weight = 10.0 self._description = "The best vehicle ever" self._name = "The flying egg" self._brake_strength = 10.0 self._hit_ground = True self._model_loading = False self._blowout = [] self._blowout_on = False self._streetnormal = Vec3(0, 0, 1) # set up the propertys of the vehicle that schould be loaded # the methods get called because the data is immutable and # wouldnt get updated when calling the objects directly # the last entry is the function to convert the string self._tags = [["name", self.setName, str], ["description", self.setDescription, str], ["control_strength", self.setControlStrength, float], ["grip_strength", self.setGripStrength, float], ["track_grip", self.setTrackGrip, float], ["max_energy", self.setMaxEnergy, float], ["max_armor", self.setMaxArmor, float], ["weight", self.setWeight, float], ["brake_strength", self.setBrakeStrength, float], ["boost_strength", self.setBoostStrength, float]]
class CEFClientHandler(object): """ A custom client handler for CEFPython that processes callbacks from the browser to Panda """ notify = DirectNotify().newCategory('PandaChromiumManager') def __init__(self, browser, texture): self._browser = browser self._texture = texture @property def browser(self): return self._browser @property def texture(self): return self._texture def OnPaint(self, browser, element_type, dirty_rects, paint_buffer, width, height): img = self.texture.modify_ram_image() if element_type == cefpython.PET_VIEW: img.set_data( paint_buffer.GetString(mode="rgba", origin="bottom-left")) else: raise CEFClientException("Unknown elemenet_type: %s" % element_type) def GetViewRect(self, browser, rect_out): width = self.texture.getXSize() height = self.texture.getYSize() rect_out.extend([0, 0, width, height]) return True def GetScreenPoint(self, browser, viewX, viewY, screenCoordinates): return False def OnLoadEnd(self, browser, frame, http_code): return def OnLoadError(self, browser, frame, error_code, error_text_out, failed_url): raise CEFClientException( 'Failed to load; %s %s %s %s %s' % (browser, frame, error_code, error_text_out, failed_url))
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 __init__(self, device, settings): ''' ''' self._notify = DirectNotify().newCategory("Input") self._notify.info("New Input-Object created: %s" % (self)) self.device = device self.directions = [0, 0] # x and y movement self.boost = False # Button for boosting self.use_item = False # Button for using items self.escape = False # if this is a Joystick, look if there are Settings for Joysticks with this name if type(self.device) == joystickdevice.JoystickDevice: if self.device.getName() in settings["joysticks"]: self.settings = settings["joysticks"][self.device.getName()] else: self.settings = {} self._setStandardSettings() # Keyboard settings are always available elif type(self.device) == keyboarddevice.KeyboardDevice: #self.settings = settings["keyboard"] self.settings = {} self.settings["boost"] = "space" self.settings["use_item"] = "lalt" self.settings["up"] = "arrow_up" self.settings["down"] = "arrow_down" self.settings["left"] = "arrow_left" self.settings["right"] = "arrow_right" self.settings["escape"] = "escape" self.device.keys[self.settings["up"]] = False self.device.keys[self.settings["down"]] = False self.device.keys[self.settings["left"]] = False self.device.keys[self.settings["right"]] = False self.device.keys[self.settings["boost"]] = False self.device.keys[self.settings["use_item"]] = False self.device.keys[self.settings["escape"]] = False elif type(self.device) == wiidevice.WiiDevice: pass #Think isn't necessary by Wiimotes
class ChromiumNode(NodePath): """ Custom Panda3D Node that contains a card for displaying a browser """ notify = DirectNotify().newCategory('ChromiumNode') def __init__(self, name=None, navigation_url=None, browser_settings=None): if name is None: name = self.__class__.__name__ NodePath.__init__(self, name) self._chrome_texture = ChromiumTexture( '%s-ChromiumBrowserTexture' % name, navigation_url=navigation_url, browser_settings=browser_settings) card_maker = CardMaker('chromebrowser2d') card_maker.set_frame(-0.75, 0.75, -0.75, 0.75) self._card = self.attach_new_node(card_maker.generate()) self._card.set_texture(self._chrome_texture) @property def chrome_texture(self): return self._chrome_texture @property def card(self): return self._card @classmethod def load_from_file(cls, path, name=None, browser_settings=None): """ Loads a HTML file into the texture used by the ChromiumNode """ uri = create_uri_from_file(path) return cls(name=name, navigation_url=uri, browser_settings=browser_settings)