framework.game.GameManager.__init__() - Code Metrics - Inspection of "Some viewport cleanups." - explosiveduck/ed2d - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 65d5d7...d03520 )

by Matthew

created 2016-02-26 05:42 UTC

framework.game.GameManager.init() B

↳ Parent: framework.game.GameManager

Complexity

Conditions

Size

Total Lines

160

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	3
dl	0
loc	160
rs	8.2857

How to fix Long Method

import random as rnd
from ed2d import window
from ed2d import sysevents
from ed2d.events import Events
from ed2d import context
from ed2d import timing
from ed2d import files
from ed2d import shaders
from ed2d.opengl import gl
from ed2d.opengl import pgl
from gem import vector
from gem import matrix
from ed2d import texture
from ed2d import mesh
from ed2d.physics import rectangle
from ed2d.physics import cmodel
from ed2d.physics import physobj
from ed2d.physics import physengine
from ed2d.physics import primitives
from ed2d.physics import gjk
from ed2d.csg import csg
from ed2d import view
from ed2d import text
from ed2d.scenegraph import SceneGraph
from ed2d import audio
from ed2d import cursor

class GameManager(object):
    ''' Entry point into the game, and manages the game in general '''
    def __init__(self):

        self.width = 800
        self.height = 600
        self.title = "ed2d"
        self.running = False

        self.fpsTimer = timing.FpsCounter()
        self.fpsEstimate = 0

        self.sysEvents = sysevents.SystemEvents()
        self.window = window.Window(self.title, self.width, self.height, window.WindowedMode)
        self.context = context.Context(3, 3, 2)
        self.context.window = self.window

        Events.add_listener(self.process_event)

        self.keys = []
        self.mouseButtons = []
        self.mousePosX = 0
        self.mousePosY = 0
        cursor.set_relative_mode(True)
        cursor.show_cursor()

        self.audio = audio.Audio()
        audioPath = files.resolve_path('data', 'sound', 'test.wav')
        self.audioFile = audio.AudioFile(audioPath)
        self.audioFile.play()
        print(self.audioFile.get_pos())
        print(self.audioFile.get_pos())

        gl.init()
        major = pgl.glGetInteger(gl.GL_MAJOR_VERSION)
        minor = pgl.glGetInteger(gl.GL_MINOR_VERSION)
        print('OpenGL Version: {}.{}'.format(major, minor))

        gl.glViewport(0, 0, self.width, self.height)

        # For CSG to work properly
        gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
        gl.glEnable(gl.GL_DEPTH_TEST)
        gl.glEnable(gl.GL_CULL_FACE)

        vsPath = files.resolve_path('data', 'shaders', 'main.vs')
        fsPath = files.resolve_path('data', 'shaders', 'main.fs')

        vertex = shaders.VertexShader(vsPath)
        fragment = shaders.FragmentShader(fsPath)
        self.program = shaders.ShaderProgram(vertex, fragment)
        self.program.use()

        self.vao = pgl.glGenVertexArrays(1)

        self.scenegraph = SceneGraph()

        # Load character image into new opengl texture
        imagePath = files.resolve_path('data', 'images', 'cubix.png')
        self.texAtlas = texture.Texture(imagePath, self.program)

        # Physics Test Scene
        # Create a physics engine
        self.physicsEngineTest = physengine.PhysEngine()

        # Player
        # Create a rectangle the long way, this will be the player
        self.cModelTestRect = rectangle.Rectangle(100.0, 100.0, width=32.0, height=32.0)
        self.cModelTestRect.update()

        # Creating a object steps:
        # Create a collision model object
        # Create a physics object to simulate
        # Create a mesh object to render
        self.cModelTest = cmodel.cModel(self.cModelTestRect)
        self.physicsObjectTest = physobj.PhysObj(self.cModelTest, vector.Vector(3, data=[0.0, 0.0, 1.0]))
        self.physicsEngineTest.addObject(self.physicsObjectTest)
        self.meshObjectTest = mesh.Mesh()
        playerACSG = csg.CSG().cube([0, 0, 0], [1, 1, 1])
        playerBCSG = csg.CSG().sphere([0, 0, 0], 1.35, 16, 8)
        playerACSG.setColor(0.5, 0.0, 1.0)
        playerBCSG.setColor(1.0, 1.0, 0.0)
        playerFCSG = playerACSG.subtract(playerBCSG) #change to subtract, union, intersect for different outcome
        self.meshObjectTest.fromCSG(playerFCSG)
        self.meshObjectTest.addProgram(self.program)
        self.meshObjectTest.addTexture(None)
        self.meshObjectTest.addPhysicsObject(self.physicsObjectTest)
        self.meshObjectTestID = self.scenegraph.establish(self.meshObjectTest)
        # End Player

        # Scene objects
        # For now store all the mesh objects in here
        # We need some sort of rendering engine class

        print(self.audioFile.get_pos())

        for i in range(20):
            xRND = rnd.randrange(1, (self.width-32))
            yRND = rnd.randrange(1, (self.height-32))
            # The creating object stuff from above... One Liner... Yes I know. :|
            self.physicsEngineTest.addObject(physobj.PhysObj(cmodel.cModel(rectangle.Rectangle(xRND, yRND, width=32.0, height=32.0)), vector.Vector(3, data=[0.0, 0.0, 1.0])))
            tempObj = self.physicsEngineTest.getObject(i+1)
            tempObj.getCollisionModel().getModel().scale(32, 32)
            tempObj.getCollisionModel().getModel().update()
            tempMesh = mesh.Mesh()
            tempMesh.fromData(data=[
             [0.0, 1.0, 0.0],
             [1.0, 1.0, 0.0],
             [0.0, 0.0, 0.0],
             [1.0, 0.0, 0.0]])
            #tempMesh.setColorAll(1.0, 0.0, 0.0)
            tempMesh.addProgram(self.program)
            tempMesh.addTexture(self.texAtlas)
            tempMesh.addPhysicsObject(tempObj)
            self.scenegraph.establish(tempMesh)

        # End Scene Objects



        # Create the collider
        gjkTest = gjk.GJK()

        # Box A and Box B collistion test, should return False
        # Substract the origins and add the two rectangles together to form a bigger one
        # If it include the origin, collision happens
        boxTestA = primitives.Box(vector.Vector(3, data=[50, 50, 49]), 1, 1, 1, matrix.Matrix(4))
        boxTestB = primitives.Box(vector.Vector(3, data=[50, 50, 51]), 2, 2, 2, matrix.Matrix(4))

        # Rectangle A and Rectangle B collision test, should return False
        # Substract the origins and add the two boxes together to form a bigger one
        # If it include the origin, collision happens
        rectTestA = primitives.Rectangle(vector.Vector(3, data=[10, 10, 0]), 2, 2, matrix.Matrix(4))
        rectTestB = primitives.Rectangle(vector.Vector(3, data=[50, 50, 50]), 2, 2, matrix.Matrix(4))

        # Circle A and Cirlce B collision test, should return False
        # Substract the origins and add the radii
        # If the new circle includes the origin, collision happens
        circleTestA = primitives.Circle(vector.Vector(3, data=[50, 50, 50]), 1)
        circleTestB = primitives.Circle(vector.Vector(3, data=[50, 50, 53]), 1)

        print("Box A and Box B collision:", gjkTest.intersects(boxTestA, boxTestB))
        print("Rect A and Rect B collision:", gjkTest.intersects(rectTestA, rectTestB))
        print("Circle A and Circle B collision:", gjkTest.intersects(circleTestA, circleTestB))

        # Circle A and Box/Rect B collision detection, 2D object with a 3D/2D object, it combines the two different shapes
        # If the new shape includes the origin, collision happens
        # Should return true because they are touching, if not interesting each other at a depth
        print("Circle A and Box B collision:", gjkTest.intersects(circleTestA, boxTestB))
        print("Circle A and Rect B collision:", gjkTest.intersects(circleTestA, rectTestB))


        self.view = view.View()
        self.ortho = matrix.orthographic(0.0, self.width, self.height, 0.0, -1.0, 1.0)
        self.view.new_projection('ortho', self.ortho)
        self.view.register_shader('ortho', self.program)

        self.loadText()

        glerr = gl.glGetError()
        if glerr != 0:
            print('GLError:', glerr)

    def loadText(self):
        vsPath = files.resolve_path('data', 'shaders', 'font.vs')
        fsPath = files.resolve_path('data', 'shaders', 'font.fs')

        vertex = shaders.VertexShader(vsPath)
        fragment = shaders.FragmentShader(fsPath)
        self.textProgram = shaders.ShaderProgram(vertex, fragment)

        fontPath = files.resolve_path('data', 'SourceCodePro-Regular.ttf')
        self.font = text.Font(12, fontPath)
        self.text = text.Text(self.textProgram, self.font)

        self.view.register_shader('ortho', self.textProgram)

    def resize(self, width, height):
        self.width = width
        self.height = height
        gl.glViewport(0, 0, self.width, self.height)
        self.ortho = matrix.orthographic(0.0, self.width, self.height, 0.0, -1.0, 1.0)
        self.view.set_projection('ortho', self.ortho)

    def process_event(self, event, data):
        if event == 'quit' or event == 'window_close':
            self.running = False
        elif event == 'window_resized':
            winID, x, y = data
            self.resize(x, y)
        elif event == 'mouse_move':
            print (data)

            if cursor.is_relative():
                xrel, yrel = data
                self.mousePosX += xrel
                self.mousePosY += yrel
            else:
                self.mousePosX, self.mousePosY = data
        elif event == 'key_down':
            if data[0] == 'r':
                cursor.set_relative_mode(True)
            elif data[0] == 'd':
                cursor.set_relative_mode(False)
            self.keys.append(data[0])
            print(self.keys)
        elif event == 'key_up':
            self.keys.remove(data[0])
        elif event == 'mouse_button_down':
            self.mouseButtons.append(data[0])
            print(self.mouseButtons)
        elif event == 'mouse_button_up':
            self.mouseButtons.remove(data[0])

    def update(self):
        self.scenegraph.update()

        # Translate and then update it, this can be handled better but for now, this will do
        self.physicsObjectTest.translate(self.mousePosX, self.mousePosY)

        # Disabled because it can get really annoying, really fast >:[
        # self.physicsEngineTest.simulate(self.fpsTimer.tickDelta)

    def render(self):
        gl.glClearColor(0.5, 0.5, 0.5, 1.0)
        gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
        gl.glEnable(gl.GL_BLEND)
        gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
        self.textProgram.use()
        self.text.draw_text(str(self.fpsEstimate) + ' FPS', 0, 10)

        self.program.use()
        gl.glBindVertexArray(self.vao)

        #self.meshObjectTest.render()

        self.scenegraph.render()

        gl.glBindVertexArray(0)

    def do_run(self):
        ''' Process a single loop '''
        self.sysEvents.process()
        self.update()
        self.render()
        self.window.flip()
        self.fpsTimer.tick()

        # print(self.audioFile.get_pos())
        if self.fpsTimer.fpsTime >= 2000:
            self.fpsEstimate = self.fpsTimer.get_fps()
            print("{:.2f} fps".format(self.fpsEstimate))

    def run(self):
        ''' Called from launcher doesnt exit until the game is quit '''
        self.running = True
        while self.running:
            self.do_run()
        self.audioFile.destroy()
        self.audio.destroy()


1			import random as rnd
2			from ed2d import window
3			from ed2d import sysevents
4			from ed2d.events import Events
5			from ed2d import context
6			from ed2d import timing
7			from ed2d import files
8			from ed2d import shaders
9			from ed2d.opengl import gl
10			from ed2d.opengl import pgl
11			from gem import vector
12			from gem import matrix
13			from ed2d import texture
14			from ed2d import mesh
15			from ed2d.physics import rectangle
16			from ed2d.physics import cmodel
17			from ed2d.physics import physobj
18			from ed2d.physics import physengine
19			from ed2d.physics import primitives
20			from ed2d.physics import gjk
21			from ed2d.csg import csg
22			from ed2d import view
23			from ed2d import text
24			from ed2d.scenegraph import SceneGraph
25			from ed2d import audio
26			from ed2d import cursor
27
28			class GameManager(object):
29			''' Entry point into the game, and manages the game in general '''
30			def __init__(self):
31
32			self.width = 800
33			self.height = 600
34			self.title = "ed2d"
35			self.running = False
36
37			self.fpsTimer = timing.FpsCounter()
38			self.fpsEstimate = 0
39
40			self.sysEvents = sysevents.SystemEvents()
41			self.window = window.Window(self.title, self.width, self.height, window.WindowedMode)
42			self.context = context.Context(3, 3, 2)
43			self.context.window = self.window
44
45			Events.add_listener(self.process_event)
46
47			self.keys = []
48			self.mouseButtons = []
49			self.mousePosX = 0
50			self.mousePosY = 0
51			cursor.set_relative_mode(True)
52			cursor.show_cursor()
53
54			self.audio = audio.Audio()
55			audioPath = files.resolve_path('data', 'sound', 'test.wav')
56			self.audioFile = audio.AudioFile(audioPath)
57			self.audioFile.play()
58			print(self.audioFile.get_pos())
59			print(self.audioFile.get_pos())
60
61			gl.init()
62			major = pgl.glGetInteger(gl.GL_MAJOR_VERSION)
63			minor = pgl.glGetInteger(gl.GL_MINOR_VERSION)
64			print('OpenGL Version: {}.{}'.format(major, minor))
65
66			gl.glViewport(0, 0, self.width, self.height)
67
68			# For CSG to work properly
69			gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
70			gl.glEnable(gl.GL_DEPTH_TEST)
71			gl.glEnable(gl.GL_CULL_FACE)
72
73			vsPath = files.resolve_path('data', 'shaders', 'main.vs')
74			fsPath = files.resolve_path('data', 'shaders', 'main.fs')
75
76			vertex = shaders.VertexShader(vsPath)
77			fragment = shaders.FragmentShader(fsPath)
78			self.program = shaders.ShaderProgram(vertex, fragment)
79			self.program.use()
80
81			self.vao = pgl.glGenVertexArrays(1)
82
83			self.scenegraph = SceneGraph()
84
85			# Load character image into new opengl texture
86			imagePath = files.resolve_path('data', 'images', 'cubix.png')
87			self.texAtlas = texture.Texture(imagePath, self.program)
88
89			# Physics Test Scene
90			# Create a physics engine
91			self.physicsEngineTest = physengine.PhysEngine()
92
93			# Player
94			# Create a rectangle the long way, this will be the player
95			self.cModelTestRect = rectangle.Rectangle(100.0, 100.0, width=32.0, height=32.0)
96			self.cModelTestRect.update()
97
98			# Creating a object steps:
99			# Create a collision model object
100			# Create a physics object to simulate
101			# Create a mesh object to render
102			self.cModelTest = cmodel.cModel(self.cModelTestRect)
103			self.physicsObjectTest = physobj.PhysObj(self.cModelTest, vector.Vector(3, data=[0.0, 0.0, 1.0]))
104			self.physicsEngineTest.addObject(self.physicsObjectTest)
105			self.meshObjectTest = mesh.Mesh()
106			playerACSG = csg.CSG().cube([0, 0, 0], [1, 1, 1])
107			playerBCSG = csg.CSG().sphere([0, 0, 0], 1.35, 16, 8)
108			playerACSG.setColor(0.5, 0.0, 1.0)
109			playerBCSG.setColor(1.0, 1.0, 0.0)
110			playerFCSG = playerACSG.subtract(playerBCSG) #change to subtract, union, intersect for different outcome
111			self.meshObjectTest.fromCSG(playerFCSG)
112			self.meshObjectTest.addProgram(self.program)
113			self.meshObjectTest.addTexture(None)
114			self.meshObjectTest.addPhysicsObject(self.physicsObjectTest)
115			self.meshObjectTestID = self.scenegraph.establish(self.meshObjectTest)
116			# End Player
117
118			# Scene objects
119			# For now store all the mesh objects in here
120			# We need some sort of rendering engine class
121
122			print(self.audioFile.get_pos())
123
124			for i in range(20):
125			xRND = rnd.randrange(1, (self.width-32))
126			yRND = rnd.randrange(1, (self.height-32))
127			# The creating object stuff from above... One Liner... Yes I know. :\|
128			self.physicsEngineTest.addObject(physobj.PhysObj(cmodel.cModel(rectangle.Rectangle(xRND, yRND, width=32.0, height=32.0)), vector.Vector(3, data=[0.0, 0.0, 1.0])))
129			tempObj = self.physicsEngineTest.getObject(i+1)
130			tempObj.getCollisionModel().getModel().scale(32, 32)
131			tempObj.getCollisionModel().getModel().update()
132			tempMesh = mesh.Mesh()
133			tempMesh.fromData(data=[
134			[0.0, 1.0, 0.0],
135			[1.0, 1.0, 0.0],
136			[0.0, 0.0, 0.0],
137			[1.0, 0.0, 0.0]])
138			#tempMesh.setColorAll(1.0, 0.0, 0.0)
139			tempMesh.addProgram(self.program)
140			tempMesh.addTexture(self.texAtlas)
141			tempMesh.addPhysicsObject(tempObj)
142			self.scenegraph.establish(tempMesh)
143
144			# End Scene Objects
145
146
147
148			# Create the collider
149			gjkTest = gjk.GJK()
150
151			# Box A and Box B collistion test, should return False
152			# Substract the origins and add the two rectangles together to form a bigger one
153			# If it include the origin, collision happens
154			boxTestA = primitives.Box(vector.Vector(3, data=[50, 50, 49]), 1, 1, 1, matrix.Matrix(4))
155			boxTestB = primitives.Box(vector.Vector(3, data=[50, 50, 51]), 2, 2, 2, matrix.Matrix(4))
156
157			# Rectangle A and Rectangle B collision test, should return False
158			# Substract the origins and add the two boxes together to form a bigger one
159			# If it include the origin, collision happens
160			rectTestA = primitives.Rectangle(vector.Vector(3, data=[10, 10, 0]), 2, 2, matrix.Matrix(4))
161			rectTestB = primitives.Rectangle(vector.Vector(3, data=[50, 50, 50]), 2, 2, matrix.Matrix(4))
162
163			# Circle A and Cirlce B collision test, should return False
164			# Substract the origins and add the radii
165			# If the new circle includes the origin, collision happens
166			circleTestA = primitives.Circle(vector.Vector(3, data=[50, 50, 50]), 1)
167			circleTestB = primitives.Circle(vector.Vector(3, data=[50, 50, 53]), 1)
168
169			print("Box A and Box B collision:", gjkTest.intersects(boxTestA, boxTestB))
170			print("Rect A and Rect B collision:", gjkTest.intersects(rectTestA, rectTestB))
171			print("Circle A and Circle B collision:", gjkTest.intersects(circleTestA, circleTestB))
172
173			# Circle A and Box/Rect B collision detection, 2D object with a 3D/2D object, it combines the two different shapes
174			# If the new shape includes the origin, collision happens
175			# Should return true because they are touching, if not interesting each other at a depth
176			print("Circle A and Box B collision:", gjkTest.intersects(circleTestA, boxTestB))
177			print("Circle A and Rect B collision:", gjkTest.intersects(circleTestA, rectTestB))
178
179
180			self.view = view.View()
181			self.ortho = matrix.orthographic(0.0, self.width, self.height, 0.0, -1.0, 1.0)
182			self.view.new_projection('ortho', self.ortho)
183			self.view.register_shader('ortho', self.program)
184
185			self.loadText()
186
187			glerr = gl.glGetError()
188			if glerr != 0:
189			print('GLError:', glerr)
190
191			def loadText(self):
192			vsPath = files.resolve_path('data', 'shaders', 'font.vs')
193			fsPath = files.resolve_path('data', 'shaders', 'font.fs')
194
195			vertex = shaders.VertexShader(vsPath)
196			fragment = shaders.FragmentShader(fsPath)
197			self.textProgram = shaders.ShaderProgram(vertex, fragment)
198
199			fontPath = files.resolve_path('data', 'SourceCodePro-Regular.ttf')
200			self.font = text.Font(12, fontPath)
201			self.text = text.Text(self.textProgram, self.font)
202
203			self.view.register_shader('ortho', self.textProgram)
204
205			def resize(self, width, height):
206			self.width = width
207			self.height = height
208			gl.glViewport(0, 0, self.width, self.height)
209			self.ortho = matrix.orthographic(0.0, self.width, self.height, 0.0, -1.0, 1.0)
210			self.view.set_projection('ortho', self.ortho)
211
212			def process_event(self, event, data):
213			if event == 'quit' or event == 'window_close':
214			self.running = False
215			elif event == 'window_resized':
216			winID, x, y = data
217			self.resize(x, y)
218			elif event == 'mouse_move':
219			print (data)
220
221			if cursor.is_relative():
222			xrel, yrel = data
223			self.mousePosX += xrel
224			self.mousePosY += yrel
225			else:
226			self.mousePosX, self.mousePosY = data
227			elif event == 'key_down':
228			if data[0] == 'r':
229			cursor.set_relative_mode(True)
230			elif data[0] == 'd':
231			cursor.set_relative_mode(False)
232			self.keys.append(data[0])
233			print(self.keys)
234			elif event == 'key_up':
235			self.keys.remove(data[0])
236			elif event == 'mouse_button_down':
237			self.mouseButtons.append(data[0])
238			print(self.mouseButtons)
239			elif event == 'mouse_button_up':
240			self.mouseButtons.remove(data[0])
241
242			def update(self):
243			self.scenegraph.update()
244
245			# Translate and then update it, this can be handled better but for now, this will do
246			self.physicsObjectTest.translate(self.mousePosX, self.mousePosY)
247
248			# Disabled because it can get really annoying, really fast >:[
249			# self.physicsEngineTest.simulate(self.fpsTimer.tickDelta)
250
251			def render(self):
252			gl.glClearColor(0.5, 0.5, 0.5, 1.0)
253			gl.glClear(gl.GL_COLOR_BUFFER_BIT \| gl.GL_DEPTH_BUFFER_BIT)
254			gl.glEnable(gl.GL_BLEND)
255			gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
256			self.textProgram.use()
257			self.text.draw_text(str(self.fpsEstimate) + ' FPS', 0, 10)
258
259			self.program.use()
260			gl.glBindVertexArray(self.vao)
261
262			#self.meshObjectTest.render()
263
264			self.scenegraph.render()
265
266			gl.glBindVertexArray(0)
267
268			def do_run(self):
269			''' Process a single loop '''
270			self.sysEvents.process()
271			self.update()
272			self.render()
273			self.window.flip()
274			self.fpsTimer.tick()
275
276			# print(self.audioFile.get_pos())
277			if self.fpsTimer.fpsTime >= 2000:
278			self.fpsEstimate = self.fpsTimer.get_fps()
279			print("{:.2f} fps".format(self.fpsEstimate))
280
281			def run(self):
282			''' Called from launcher doesnt exit until the game is quit '''
283			self.running = True
284			while self.running:
285			self.do_run()
286			self.audioFile.destroy()
287			self.audio.destroy()
288

explosiveduck / ed2d

Push — master ( 65d5d7...d03520 )

framework.game.GameManager.__init__() B

Complexity

Size

Duplication

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

framework.game.GameManager.init() B