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)
