def _CreateProjectile(self, **kwargs): width = 4 height = -12 go = gameObject.GameObject(kwargs["callable"]) go.Type = "Projectile" go.name = kwargs["name"] go.transform.x = kwargs["transform"].x go.transform.y = kwargs["transform"].y go.transform.rotation = kwargs["transform"].rotation go.transform.speed = kwargs["transform"].speed go.transform.rotationSpeed = kwargs["transform"].rotationSpeed if kwargs["playerType"] is PlayerType.player1: go.Render = renderer.Renderer(width, height, None, go.transform, None, Qt.gray, go.Type) if kwargs["playerType"] is PlayerType.player2: go.Render = renderer.Renderer(width, height, None, go.transform, None, Qt.red, go.Type) if kwargs["playerType"] is PlayerType.player3: go.Render = renderer.Renderer(width, height, None, go.transform, None, Qt.green, go.Type) if kwargs["playerType"] is PlayerType.player4: go.Render = renderer.Renderer(width, height, None, go.transform, None, Qt.yellow, go.Type) self.SceneManager.scene.addItem(go.Render) go.Render.moveItem() go.Render.rotateItem() return go
def _CreteAsteroid(self, **kwargs): go = gameObject.GameObject(kwargs["callable"]) go.Type = "Asteroid" go.asteroidType = kwargs["asteroidType"] go.transform = transform.Transform() go.transform.x = kwargs["transform"].x go.transform.y = kwargs["transform"].y go.transform.speed = kwargs["transform"].speed go.transform.rotation = kwargs["transform"].rotation go.transform.rotationSpeed = kwargs["transform"].rotationSpeed if go.asteroidType is AsteroidType.large: go.sound = self.bigAsteroidExplosionSound go.radius = 40 image, path = self.itemFactory.getAsteroid(AsteroidType.large) go.Render = renderer.Renderer(80, 80, path, go.transform, image, None, go.Type) elif go.asteroidType is AsteroidType.medium: go.sound = self.mediumAsteroidExplosionSound go.radius = 25 go.transform.speed += 0.2 image, path = self.itemFactory.getAsteroid(AsteroidType.medium) go.Render = renderer.Renderer(50, 50, path, go.transform, image, None, go.Type) else: go.sound = self.smallAsteroidExplosionSound go.transform.speed += 0.4 go.radius = 15 image, path = self.itemFactory.getAsteroid(AsteroidType.small) go.Render = renderer.Renderer(30, 30, path, go.transform, image, None, go.Type) go.Render.setCacheMode(QGraphicsItem.DeviceCoordinateCache) self.SceneManager.scene.addItem(go.Render) return go
def __init__(self): super(Test, self).__init__() self.database = D.Database() cars, notcars = self.database.GetListOfImages() self.classifier = C.Classifier(cars, notcars, loadFromFile=True, database=self.database) self.renderer = R.Renderer() self.vehicleDetector = V.VehicleDetector()
def __init__(self): application = self #global initialization pyxel.init(255, 255, caption="Nearym Quest", scale=3) self.debugOverlay = False self.camera = Camera() self.streamingArea = Box() self.streamingArea.size = Vector2f(512, 512) self.streamingArea.center = Vector2f(0, 0) self.renderer = Renderer() self.physics = Physics() random.seed(0) # Event Manager self.inputManager = InputManager() self.inputManager.addInput( Input(InputType.BUTTON, InputNotify.PRESSED, [pyxel.KEY_F1], 'debug')) # world and player self.LoadMap() self.draw_count = 0 # has to be completely at the end of init pyxel.run(self.update, self.draw)
def __init__(self): self.player_class = 0 self.player_id = None self.player_x = 300 self.player_y = 300 self.player_lead_x_change = 0 self.player_lead_y_change = 0 self.previous_x = 0 self.previous_y = 0 #Server response flag self.is_registered = False #self.ammo = ammo self.time_lasted = 0 self.average_performance = 0 #Feature variables self.health = 100 self.score = 0 #measures endurance against remaining health self.class_packs = 0 #measures agility self.out_of_bounds_OR_game_over = 0 #apply game rules, violation of which will cost something #resourcefulness #ammo and shields self.renderer = Renderer.Renderer()
def __init__(self): super(VehicleDetector, self).__init__() # Sliding windows self.yStart = 400 self.yStop = 650 self.x_overlap = 0.65 self.y_overlap = 0.75 # Filter self.filterThreshold = 2 self.filter = F.Filter(self.filterThreshold) # Print summary to check correct parameters self.Summary() # Sub-components self.renderer = R.Renderer() self.database = D.Database() cars, notcars = self.database.GetListOfImages() self.classifier = C.Classifier(cars, notcars, loadFromFile=True, database=self.database) # Output video parameters self.outputToImages = 0 self.outputVideoName = self.database.GetOutputVideoPath() # Train classifier ? self.trainClassifier = 1 # TODO: implement the loading # Bounding boxes self.bboxes = self.LoadSlidingWindows()
def main(): randy = Renderer() polyCube = Cube() polyCube.build_polygon_mesh() randy.render(polyCube.mesh, 512, "polyCube.jpg") triangleCube = Cube() triangleCube.build_triangle_mesh(4000) randy.render(triangleCube.mesh, 1080, "HDcube.jpg") polyCylinder = Cylinder() polyCylinder.build_polygon_mesh() randy.render(polyCylinder.mesh, 512, "polyCylinder.jpg") triangleCylinder = Cylinder() triangleCylinder.build_triangle_mesh(4000) randy.render(triangleCylinder.mesh, 1080, "HDcylinder.jpg") polySphere = Sphere() polySphere.build_polygon_mesh() randy.render(polySphere.mesh, 512, "polySphere") triangleSphere = Sphere() triangleSphere.build_triangle_mesh(4000) randy.render(triangleSphere.mesh, 1080, "HDSphere")
def resetBoard(): nonlocal board1, renderer, controller, count, srcTile, desTile, ID, currentTile \ ,displayHover, currentSide, wep_sniper, wep_assault, wep_shotgun, soldiers f = open("map.txt") tiles = {} for line in f.readlines(): cols = line.split() passable = (cols[2] == "True") tiles[(int(cols[0]), int(cols[1]))] = board.Tile( (int(cols[0]), int(cols[1])), passable, int(cols[3]), int(cols[4]), int(cols[5]), int(cols[6])) #print(tiles) board1 = board.Board(15, 20, tiles) for i in range(0, board1.width): for j in range(0, board1.height): exec( compile( open("soldier.txt", "rb").read(), "soldier.txt", 'exec')) # exec(compile(open("map.txt", "rb").read(), "map.txt", 'exec')) print("HI!") renderer = Renderer.Renderer(board1, screen) controller = Controller.Controller() count = 0 srcTile = None desTile = None ID = None currentTile = None displayHover = 0 currentSide = 0
def main(pattern_file, img_file): pattern = cv2.imread('pattern.png', 0) # trainImage matcher = cm.CorrespondenceMatcher(pattern) estimator = pe.ProjectionEstimator() renderer = rr.Renderer() print("loading image " + img_file) query = cv2.imread(img_file, 0) # queryImage q_h, q_w = query.shape[:2] p_h, p_w = pattern.shape[:2] print("finding homography for " + img_file) h = matcher.find_homography(query) print("homography matrix " + str(h)) print("finding extrinsic camera parameter for " + img_file) rx, ry, rz, px, py, pz, residual = estimator.compute_extrinsic( h, p_w, q_w, FOCAL_LENGTH, PATTERN_SIZE) print("rotation: " + str([rx, ry, rz])) print("position: " + str([px, py, pz])) print("parameter residual " + str(residual)) print("rendering result generated from pattern " + pattern_file + " and image " + img_file) renderer.render(img_file, rx, ry, rz, px, py, pz)
def __init__(self, direction, speed, socket_data_list): self.socket_data_list = socket_data_list self.color = red self.direction = direction self.speed = speed self.damage_point = gameObject.damage_point self.top_attack_startx = 0 self.bottom_attack_startx = 0 self.left_attack_starty = 0 self.right_attack_starty = 0 self.x = 0 self.y = 0 self.end_x = 0 self.end_y = 0 self.isActive = True self.renderer = Renderer.Renderer() self.aum = AUM.AttackUnitMover() self.aum.initialize(self) self.top_side_attack_config = [] #configuration for top attack self.left_side_attack_config = [] #configuration for left attack self.bottom_side_attack_config = [] #configuration for bottom attack self.right_side_attack_config = [] #configuration for right attack self.create_attack_start_list() #initializes attack data from server self.create_attack_config() #populates attack config lists
def resize(self, event): size = (event.width, event.height) self.image = Image.new('RGBA', size) self._computeBands(size) self.display() self.renderer = Renderer.Renderer(self.master, self.image, self.colorspace.hasAlpha) self.config(image=self.renderer)
def __init__(self): # We create a MainWindow object and initialise with the UI from PMainWindowUi self.app = QtGui.QApplication(sys.argv) self.MainWindow = QtGui.QMainWindow() self.ui_m = MainWindowUi.Ui_MainWindow() self.ui_m.setupUi(self.MainWindow) # We connect all the buttons to their respective callback functions, called when the 'clicked' event is generated self.ui_m.pushButton.clicked.connect(self.openLoadStackDialog) self.ui_m.pushButton_2.clicked.connect(self.cutObj) self.ui_m.pushButton_3.clicked.connect(self.setSliceResolution) self.ui_m.pushButton_4.clicked.connect(self.changeColorMap) self.ui_m.pushButton_5.clicked.connect(self.takeSnapshot) #self.ui_m.pushButton_6.clicked.connect(self.saveAsVTKObj) self.ui_m.pushButton_7.clicked.connect(self.record) self.ui_m.pushButton_8.clicked.connect(self.removePoint) self.ui_m.pushButton_9.clicked.connect(self.addPoint) self.ui_m.pushButton_10.clicked.connect(self.renderV) #self.ui_m.pushButton_11.clicked.connect(self.openVTKObj) self.ui_m.pushButton_12.clicked.connect(self.changeBGColor) self.ui_m.pushButton_13.clicked.connect(self.resetCamera) self.ui_m.pushButton_11.clicked.connect(self.alignPlaneToX) self.ui_m.pushButton_14.clicked.connect(self.alignPlaneToZ) self.ui_m.pushButton_15.clicked.connect(self.alignPlaneToY) # Below are the toggle buttons self.ui_m.radioButton.toggled.connect(self.toggleOutline) self.ui_m.radioButton_2.toggled.connect(self.togglePlane) self.ui_m.radioButton_3.toggled.connect(self.toggleClippingBox) self.ui_m.radioButton_4.toggled.connect(self.toggleVolume) self.ui_m.radioButton_5.toggled.connect(self.toggleSlice) self.ui_m.radioButton_6.toggled.connect(self.toggleAlignedPlane) self.ui_m.horizontalSlider.valueChanged.connect(self.valueChangeSlider) # These are the 'Clip' and 'Set' (set slice reolution) buttons which are initially disabled, enabled only when the Plane Widget is active self.ui_m.pushButton_2.setEnabled(False) self.ui_m.pushButton_3.setEnabled(False) self.ui_m.pushButton_10.setEnabled(False) self.ui_m.pushButton_11.setEnabled(False) self.ui_m.pushButton_14.setEnabled(False) self.ui_m.pushButton_15.setEnabled(False) self.ui_m.horizontalSlider.setEnabled(False) self.Dialog = QtGui.QDialog() self.ui_l = Ui_Dialog() self.ui_l.setupUi(self.Dialog) self.pRenderer = Renderer.Renderer() self.pRenderer.renderBlank(self.ui_m.qvtkWidget) self.MainWindow.show() self.pCutObj = CutObj.CutObj() self.histWidg = HistogramWidget.HistogramWidget() self.loadStack = LoadStack.LoadStack(self) sys.exit(self.app.exec_())
def render_scene(self, dimensions, image_name): to_canvas = TransformationFactory.to_canvas(dimensions) randy = Renderer(dimensions) # initialize renderer print("Rendering...") # TO VIEW SPACE scene_edges = [] scene_faces = [] for model in self.scene.models: for face in model.faces: scene_faces.append( Face(face.v1, face.v2, face.v3, random_color())) print("faces in scene: {}".format(len(scene_faces))) scene_faces = transform_faces(scene_faces, self.to_view_space) print("basis swap to camera complete") # RENDER BEFORE CULLING self.render_face_edges(scene_faces, dimensions, image_name + "_beforeCulling", [self.to_screen_space, to_canvas]) # CULLING before_filter = len(scene_faces) culled_faces = [] for face in scene_faces: if not face.should_cull(): culled_faces.append(face) difference = before_filter - len(culled_faces) print(str(difference) + " FACES CULLED") # TO SCREEN SPACE scene_faces = transform_faces(culled_faces, self.to_screen_space) # RENDER AFTER CULLING self.render_face_edges(scene_faces, dimensions, image_name + "_afterCulling", [to_canvas]) # TODO: Clipping scene_faces = clip(scene_faces) self.render_face_edges(scene_faces, dimensions, image_name + "_afterClipping", [to_canvas]) # TODO: RENDER HERE scene_faces = transform_faces(scene_faces, to_canvas) for face in scene_faces: randy.rasterize(face) randy.save(image_name + "_afterRasterizing") # TODO: Rasterize # TODO: Z-Buffer print("image saved!")
def __init__(self): self.running = True self.screen = pg.display.set_mode( (SCREENWIDTH, SCREENHEIGHT), pg.DOUBLEBUF | pg.RESIZABLE | pg.HWSURFACE) self.env = Environment3() self.camera = Camera(SCREENWIDTH, SCREENHEIGHT, THETA_W, THETA_H, NEAR, FAR, self.env.sectors[0], self.env, False) self.renderer = Renderer()
def __init__(self, game: GameMain, city: City) -> None: super().__init__(game) self.city = city game.city = self.city game.city_size = self.city.size self.eye_pos = ( [int(i / self.game.renderer.tile_size) for i in self.game.center]) game.renderer = Renderer(game, self.city, self.eye_pos) self.iso_eye_pos = ( [int(i) for i in game.renderer.cart2iso(self.eye_pos)])
def DrawOnDC(self, dc): decorator = self.pref.decorator if self.pref.labelVerses else SongDecorator( ) r = Renderer(self.pref.format, decorator, self.pref.notations) start, end = self.text.GetSelection() if start == end: w, h = r.Render(self.text.GetText(), dc) else: w, h = r.Render(self.text.GetText(), dc, self.text.LineFromPosition(start), self.text.LineFromPosition(end)) return w, h
def init(self, stateManager): self.player = Player(0, 0, -1.0, 0.0, 0.0, 0.66) self.map = Map("level1.png", self.player) self.oldMapPos = (int(self.player.posX), int(self.player.posY)) self.renderer = Renderer(stateManager.display, self.player, self.map) # Mouse for FPS pygame.event.set_grab(True) pygame.mouse.set_visible(False) # Play music if Settings.MUSIC: pygame.mixer.music.load("Resources/Sounds/Music/turmoil.ogg") pygame.mixer.music.play(-1)
def start(): win_offset_y = 25 os.environ['SDL_VIDEO_WINDOW_POS'] = str(0) + "," + str(win_offset_y) pygame.init() info_obj = pygame.display.Info() #print(info_obj) screen_dim = Vec2d(int(info_obj.current_w), int(info_obj.current_h - win_offset_y)) em = EventManager.EventManager() game_engine = GameEngine.GameEngine(em, screen_dim) renderer = Renderer.Renderer(em, game_engine, screen_dim) controller = Controller.Controller(em, game_engine) game_engine.run()
def OnExportAsHtml(self, evt): n = self.AskExportFileName(_("HTML file"), "html") if n is not None: h = HtmlExporter(self.pref.format) r = Renderer(self.pref.format, h, self.pref.notations) start, end = self.text.GetSelection() if start == end: r.Render(self.text.GetText(), None) else: r.Render(self.text.GetText(), None, self.text.LineFromPosition(start), self.text.LineFromPosition(end)) with open(n, "w", encoding='utf-8') as f: f.write(h.getHtml()) f.close()
def render_edges(self, scene_edges, dimensions, image_name, transformations): randy = Renderer(dimensions) for t in transformations: scene_edges = transform_edges(scene_edges, t) for edge in scene_edges: p0 = edge[0] p1 = edge[1] randy.drawLine(p0[0], p0[1], p1[0], p1[1]) # draw line # TODO: RENDER HERE randy.save(image_name) # create, write, and save image file
def game_start(args): engine = g.GameEngine(int(args.size)) re = None num_games = int(args.number) num_humans = int(args.humans) board_size = int(args.size) gui = int(args.graphical) if gui: re = r.Renderer(engine) re.window_setup(500, 500) for i in range(num_games): winner, num_moves = play_game(engine, num_humans, re, FIRST_AI, SECOND_AI, board_size) print('Player', i, 'won in', num_moves, 'moves.')
def __init__(self, direction, speed): self.color = red self.direction = direction self.speed = speed self.x = 0 self.y = 0 self.end_x = 0 self.end_y = True self.isActive = True self.renderer = Renderer.Renderer() self.aum = AUM.AttackUnitMover() self.top_side_attack_config = [] self.left_side_attack_config = [] self.bottom_side_attack_config = [] self.right_side_attack_config = [] self.create_attack_config()
def __init__(self): self.player_id = None self.player_x = 300 self.player_y = 300 self.player_lead_x_change = 0 self.player_lead_y_change = 0 self.player_class = 0.14026667 #self.ammo = ammo self.time_lasted = 0 self.average_performance = 0 #Possible Feature variables self.health = 100 self.score = 0 #measures endurance self.class_packs = 0 #measures agility #apply game rules, violation of which will cost something #resourcefulness #ammo and shields self.renderer = Renderer.Renderer()
def _CreateSpaceShip(self, **kwargs): go = gameObject.GameObject(kwargs["callable"]) go.Type = "Spaceship" go.transform = transform.Transform() go.name = kwargs["name"] go.playerType = kwargs["playerType"] if go.playerType is PlayerType.player1: go.shootSound = self.shootSound1 elif go.playerType is PlayerType.player2: go.shootSound = self.shootSound2 elif go.playerType is PlayerType.player3: go.shootSound = self.shootSound3 else: go.shootSound = self.shootSound4 go.destroySound = self.spaceshipExplosionSound image, path = self.itemFactory.getPlayer(kwargs["playerType"]) go.Render = renderer.Renderer(80, 100, path, go.transform, image, None, go.Type) go.Render.setZValue(1) self.SceneManager.scene.addItem(go.Render) return go
def __init__(self, window, x, y, width, height, camera=None): ''' Constructor window - a pyglet window object x , y - position of bottom left corner of Frame in the window width, height - width and height of the frame camera - a camera object (default: will create a camera object for you) ''' # Let's make these part of the interface why not # I'm sure this won't bite me in the ass later </irony> self.x = x self.y = y self.width = width self.height = height AbstractFrame.__init__(self, window) self._drawables = [] self._window = window if camera == None: camera = Camera.Camera(window) self._camera = camera self._renderer = Renderer.Renderer(self.Window(), camera, self) self._renderer.Redraw()
def main(): """this function is called when the program starts. it initializes everything it needs, then runs in a loop until the function returns.""" #Initialize Everything pygame.init() pygame.display.set_caption('XCom - the Unknown Noob') pygame.mouse.set_visible(1) tiles = [] papixel = pygame.Surface((60,60)) papixel.fill((255, 0, 0)) wep_assault = soldier.Weapon("Assault Rifle", 3, 5, 3, [25,20,18,16,14,12,10,8,6,4,2,0]) for i in range(0,6): for j in range(0,6): unit = soldier.Soldier("Julian", copy.copy(wep_assault), (5,5)) unit.set_image(papixel) tile = board.Tile(coords=(i,j),unit = unit) tiles.append(tile) board1 = board.Board(10,15,tiles=tiles) renderer = Renderer.Renderer(board1) try: while 1: event = pygame.event.wait() if event.type == pygame.QUIT: break if event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE or event.unicode == 'q': break if pygame.mouse.get_pressed()[0]: print ("You have opened a chest!") renderer.render() pygame.display.flip() finally: pygame.quit()
def _CreateFireRateSpeedUp(self, **kwargs): go = gameObject.GameObject() go.Type = "FireRateSpeedUp" go.transform = transform.Transform() go.transform.x = kwargs["transform"].x go.transform.y = kwargs["transform"].y go.transform.speed = kwargs["transform"].speed go.transform.rotation = kwargs["transform"].rotation go.transform.rotationSpeed = kwargs["transform"].rotationSpeed go.sound = self.fireRateUpSound image, path = self.itemFactory.getFireRateSpeedUp() go.Render = renderer.Renderer(50, 50, transform=go.transform, type=go.Type, path=path, image=image, color=None) go.Render.setCacheMode(QGraphicsItem.DeviceCoordinateCache) self.SceneManager.scene.addItem(go.Render) return go
def __init__(self, master=None, color=None, colorspace=None, minBandWidth=7, **kw): kw['padx'] = 0 kw['pady'] = 0 apply(Tkinter.Label.__init__, (self, master), kw) self.image = Image.new('RGBA', (1, 1)) if colorspace is None: colorspace = globals['DefaultColorSpace']() if color is None: color = colorspace.defaultColor self.rgba = colorspace.toRGBA(color) self.colorspace = colorspace self.currentColor = self.colorspace.fromRGBA(self.rgba) if colorspace.grayLevel(color) < 0.5: self.highlight = Ink.Gray(1) else: self.highlight = Ink.Gray(0) # Note that we cannot use setColorspace since we # are not ready to update the display yet. self.master = master self.minBandWidth = minBandWidth self.renderer = Renderer.Renderer(self, self.image, self.colorspace.hasAlpha) self.config(image=self.renderer) self.bind('<Configure>', self.resize) self.bind('<ButtonPress-1>', self.buttonDown) self.bind('<B1-Motion>', self.buttonDrag) self.bind('<B1-ButtonRelease>', self.buttonUp) self.animateAfter = None self.animating = 0
def __init__(self, parent, sf, notations, sd=SongDecorator(), embedded=False): object.__init__(self) show_link = not embedded and platform.system() != 'Linux' self.link = None if show_link: self.main_panel = wx.Window(parent) bSizer = wx.BoxSizer(wx.VERTICAL) self.link = wx.adv.HyperlinkCtrl( self.main_panel, 0, _("Copy formatted song to clipboard"), '') tt = wx.ToolTip( _("Copy formatted song to clipboard, so that it can be pasted in any program and printed" )) self.link.SetToolTip(tt) bSizer.Add(self.link, 0, wx.EXPAND) parent = self.main_panel self.panel = wx.ScrolledWindow(parent, style=wx.BORDER_DOUBLE) self.panel.SetBackgroundStyle(wx.BG_STYLE_CUSTOM) self.pixedScrolled = 10 self.panel.SetScrollbars(self.pixedScrolled, self.pixedScrolled, 0, 0) self.panel.Bind(wx.EVT_PAINT, self.OnPaint, self.panel) self.panel.SetBackgroundColour(wx.WHITE) self.text = "" if show_link: bSizer.Add(self.panel, 1, wx.EXPAND) else: self.main_panel = self.panel #SongFormat self.renderer = Renderer(sf, sd, notations) if show_link: self.main_panel.SetSizer(bSizer) self.main_panel.Layout()
def startGame(self): if self._debugMode: print("Initializing game...") self._running = True self._mainWindow = tk.Tk() self._mainWindow.protocol("WM_DELETE_WINDOW", self.stopGame) self._mainWindow.title(self._title) self._mainWindow.resizable(0, 0) self._renderer = Renderer(self) self._gameInput = Input(self) try: self._mainCanvas = tk.Canvas(self._mainWindow, width=self._size[0], height=self._size[1], borderwidth=0) self._mainCanvas.pack() self._mainCanvas.update() except: self._mainWindow = None if self._debugMode: print("!!! Unexpected error occurred on startGame.") raise if self._debugMode: print("Game running...") lastTimer = self.getTimeMicros() lastTime = lastTimer renderDelta = 0 updateDelta = 0 frames = 0 updates = 0 microPerRender = 1000000 / self._targetFPS microPerUpdate = 1000000 / self._targetUPS while self._running: timeNow = self.getTimeMicros() timeDelta = (timeNow - lastTime) renderDelta += timeDelta updateDelta += timeDelta lastTime = timeNow if updateDelta > microPerUpdate: updateDelta -= microPerUpdate updates += 1 if self._currentScene is not None: self._gameScenes[self._currentScene].onUpdate( self._gameInput, timeDelta / 1000000.0) self._gameInput._update() if not self._vSync or renderDelta > microPerRender: renderDelta -= microPerRender frames += 1 if self._currentScene is not None: self._renderer.clearAll(self._gameBG) self._gameScenes[self._currentScene].onRender( self._renderer, renderDelta) if self._showFPS: self._renderer.setColor(Color(255, 255, 255)) self._renderer.drawString((10, 5), self._infoText, tk.NW, tk.LEFT) self.sleep(self._idleTime) if self.getTimeMicros() - lastTimer >= 1000000: self._PSInfo = [frames, updates, timeDelta / 1000.0] self._infoText = "%d FPS, %d UPS [%0.2fms]" % ( frames, updates, timeDelta / 1000.0) if self._debugMode: print(self._infoText) frames = 0 updates = 0 lastTimer = self.getTimeMicros() if self._currentScene is not None: self._gameScenes[self._currentScene].onExit() tk.sys.exit(0)