GameManager.loadText() - Code Metrics - explosiveduck/ed2d - Measure and Improve Code Quality continuously with Scrutinizer

GameManager.loadText() A
last analyzed 2016-05-20 05:45 UTC

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	0	Features	1

Metric	Value
cc	1
dl	0
loc	13
rs	9.4285
c	3
b	0
f	1

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	View Code Duplication	def process_event(self, event, data):
		0 ignored issues – show Duplication introduced 2016-05-20 05:45 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
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	View Code Duplication	def do_run(self):
		0 ignored issues – show Duplication introduced 2016-05-20 05:45 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
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

GameManager.loadText() A last analyzed 2016-05-20 05:45 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

GameManager.loadText() A
last analyzed 2016-05-20 05:45 UTC