View difference between Paste ID: PGWEhH59 and Pud7GLNb

 --[[
 
 engine.lua
-Version: 1.2
+Version: 1.3
 
 Author: MegaLoler
 Email: [email protected]
 
 A game engine for Love that manages game scenes and entities.
 
 If requires that you use the class.lua file:
 require("class.lua")
 
 Make sure you have this in your code:
 require("engine.lua")
 
 Create a game by creating a subclass of the Engine class.
 MyGame = engine.newClass(engine.Engine)
 
 Define the setup method:
 function MyGame:setup()
 	-- Initalize your game here.
 end
 
 Make sure to call the setGame function of your game class in your main.lua:
 MyGame:setGame()  -- This will make the game engine take over.
 
 Create a scene by subclassing the Entity class:
 TestScene = newClass(engine.Entity)
 
 Define the setup, update, draw, and any other methods that you wish:
 function TestScene:setup() ... end
 function TestScene:update(dt) ... end
 function TestScene:draw() ... end
 
 Call the setScene method somewhere in your game's setup method to set the inital scene on launch:
 self:setScene(TestScene) -- Pass the class itself, not an instance of it
 
 Add children entities to a scene or entity preferably in its setup method with the addChild method:
 local child = TestEntity:new(self.engine, self) -- Parameters are game engine and parent entity
 self:addChild(child)
 
 --]]
 
 require("class")
 
 engine = {} -- Engine package
 
 -- Love wrappers
 
 function love.load()
 	engine.game:load()
 end
 
 function love.quit()
 	engine.game:quit()
 end
 
 function love.focus(f)
 	engine.game:focus(f)
 end
 
 function love.keypressed(key, unicode)
 	engine.game:keypressed(key, unicode)
 end
 
 function love.keyreleased(key)
 	engine.game:keyreleased(key)
 end
 
 function love.mousepressed(x, y, button)
 	engine.game:mousepressed(x, y, button)
 end
 
 function love.mousereleased(x, y, button)
 	engine.game:mousereleased(x, y, button)
 end
 
 function love.update(dt)
 	engine.game:update(dt)
 end
 
 function love.draw()
 	engine.game:draw()
 end
 
 -- Engine class
 
 engine.Engine = newClass()
 
 function engine.Engine:init()
 	self:setSize()
 	self:setTitle()
 	self.focused = true
 	self.fading = false
-	self.fade = 1
+	self.fade = 0
-	self.fadeSpeed = 0.5
+	self.fadeSpeed = 2
-	self.fadeColor = {255, 255, 255}
+	self:setFadeColor()
 	self:setScene(engine.Entity)
 end
 
 -- Sets the engine subclass to load
 
 function engine.Engine:setGame()
 	engine.game = self:new()
 end
 
 -- Engine methods
 
 function engine.Engine:setTitle(title)
 	self.title = title or "Game Engine"
 	love.graphics.setCaption(self.title)
 end
 
 function engine.Engine:setSize(width, height)
 	self.width = width or 640
 	self.height = height or 480
 	love.graphics.setMode(self.width, self.height)
 	if self.scene then self:positionScene() end
 end
 
 function engine.Engine:fadeToScene(scene, ...)
 	self.fadeTo = scene
 	self.fadeArgs = ...
 	self.fading = true
 end
 
 function engine.Engine:setFadeColor(color)
 	self.fadeColor = color or {0, 0, 0}
 end
 
 function engine.Engine:setScene(scene, ...)
 	if self.scene then self.scene:destroy() end
 	self.scene = scene:new(self)
 	self:positionScene()
 	self.scene:setup(...)
 end
 
 function engine.Engine:toggleFullscreen()
 	love.graphics.toggleFullscreen()
 end
 
 -- Wrapped Love functions
 
 function engine.Engine:load()
 	self:setup()
 end
 
 function engine.Engine:quit()
 end
 
 function engine.Engine:focus(f)
 	self.focused = f
 end
 
 function engine.Engine:keypressed(key, unicode)
 	self.scene:onkeypressed(key, unicode)
 end
 
 function engine.Engine:keyreleased(key)
 	self.scene:onkeyreleased(key)
 end
 
 function engine.Engine:mousepressed(x, y, button)
 	self.scene:onmousepressed(x, y, button)
 end
 
 function engine.Engine:mousereleased(x, y, button)
 	self.scene:onmousereleased(x, y, button)
 end
 
 function engine.Engine:update(dt)
 	if self.fading then
 		if self.fade >= 1 then
 			self.fade = 1
 			self.fading = false
 			self:setScene(self.fadeTo, self.fadeArgs)
 		else
 			self.fade = self.fade + self.fadeSpeed * dt
 			if self.fade > 1 then self.fade = 1 end
 		end
 	else
 		if self.fade <= 0 then
 			self.fade = 0
 		else
 			self.fade = self.fade - self.fadeSpeed * dt
 			if self.fade < 0 then self.fade = 0 end
 		end
 	end
 	self.scene:masterUpdate(dt)
 end
 
 function engine.Engine:draw()
 	self.scene:render()
 	love.graphics.setCanvas()
 	self.scene:postRender()
 	self:drawFade()
 end
 
 -- Private methods
 
 function engine.Engine:positionScene()
 	self.scene:setPosition(self.width / 2, self.height / 2)
 end
 
 function engine.Engine:drawFade()
 	love.graphics.setBlendMode("alpha")
 	love.graphics.setColor(self.fadeColor[1], self.fadeColor[2], self.fadeColor[3], (math.cos((1 - self.fade) * math.pi) + 1) * 127)
 	love.graphics.polygon("fill", 0, 0, self.width, 0, self.width, self.height, 0, self.height)
 end
 
 -- Virtual methods
 
 function engine.Engine:setup()
 end
 
 -- Entity class
 
 engine.Entity = newClass()
 
 function engine.Entity:init(engine, container)
 	self.engine = engine
 	self.container = container
 	self:setPosition()
 	self:setSize()
 	self:setOrientation()
 	self:setScale()
 	self:setColor()
 	self.backgroundAlpha = 255
 	self.alpha = 255
 	self:setBackgroundColor()
 	self.children = {}
 	self.selectable = false
 	self.selected = false
 	self.clearCanvas = true
 	self.hasBackground = false
 	self.staticDrawing = true
 	self.refreshRequested = true
 	self.tick = 0
 	self.time = 0
 end
 
 -- Entity methods
 
 function engine.Entity:addChild(child, ...)
 	table.insert(self.children, child)
 	child:setup(...)
 end
 
 function engine.Entity:removeChild(child)
 	table.remove(self.children, child)
 	child:destroy()
 end
 
 function engine.Entity:refresh()
 	self.refreshRequested = true
 end
 
 function engine.Entity:setColor(color)
 	self.color = color or {255, 255, 255}
 end
 
 function engine.Entity:setBackgroundColor(color)
 	local r, g, b = love.graphics.getBackgroundColor()
 	self.backgroundColor = color or {r, g, b}
 end
 
 function engine.Entity:setPosition(x, y)
 	local dx = self.engine.width / 2
 	local dy = self.engine.height / 2
 	if self.container then
 		dx = self.container.width / 2
 		dy = self.container.height / 2
 	end
 	self.x = x or dx
 	self.y = y or dy
 end
 
 function engine.Entity:move(x, y)
 	self.x = self.x + x
 	self.y = self.y + y
 end
 
 function engine.Entity:setOrigin(x, y)
 	self.originX = x or self.width / 2
 	self.originY = y or self.height / 2
 end
 
 function engine.Entity:setOrientation(r)
 	self.orientation = r or 0
 end
 
 function engine.Entity:setScale(x, y)
 	self.scaleX = x or 1
 	self.scaleY = y or 1
 end
 
 function engine.Entity:setSize(width, height)
 	self.width = width or self.engine.width
 	self.height = height or self.engine.height
 	self.canvas = love.graphics.newCanvas(self.width, self.height)
 	self:setOrigin()
 end
 
 function engine.Entity:masterUpdate(dt)
 	self.time = self.time + dt
 	for k, v in pairs(self.children) do
 		v:masterUpdate(dt)
 	end
 	self:update(dt)
 	self.tick = self.tick + 1
 end
 
 function engine.Entity:render()
 	if not self.staticDrawing or self.refreshRequested then
 		self.refreshRequested = false
 		love.graphics.setCanvas(self.canvas)
 		if self.clearCanvas then self.canvas:clear() end
 		if self.hasBackground then
 			love.graphics.setColor(self.backgroundColor[1], self.backgroundColor[2], self.backgroundColor[3], self.backgroundAlpha)
 			love.graphics.setBlendMode("alpha")
 			love.graphics.polygon("fill", 0, 0, self.width, 0, self.width, self.height, 0, self.height)
 		end
 
 		self:preDraw()
-	love.graphics.drawq(self.canvas, love.graphics.newQuad(0, 0, self.width, self.height, self.width, self.height), self.x, self.y , self.orientation, self.scaleX, self.scaleY, self.width / 2, self.height / 2)
+
 		for k, v in pairs(self.children) do
 			v:render()
 			love.graphics.setCanvas(self.canvas)
 			v:postRender()
 		end
 
 		self:draw()
 	end
 end
 
 function engine.Entity:postRender()
 	love.graphics.setBlendMode("alpha")
 	love.graphics.setColor(self.color[1], self.color[2], self.color[3], self.alpha)
 	love.graphics.drawq(self.canvas, love.graphics.newQuad(0, 0, self.width, self.height, self.width, self.height), self.x, self.y , self.orientation, self.scaleX, self.scaleY, self.originX, self.originY)
 end
 
 function engine.Entity:onkeypressed(key, unicode)
 	self:keypressed(key, unicode)
 	if self.selectedChild then self.selectedChild:onkeypressed(key, unicode) end
 end
 
 function engine.Entity:onkeyreleased(key)
 	self:keyreleased(key)
 	if self.selectedChild then self.selectedChild:onkeyreleased(key) end
 end
 
 function engine.Entity:onmousepressed(x, y, button)
 	local oldSelectedChild = self.selectedChild
 	self:mousepressed(x, y, button)
 	if self.selectedChild then self.selectedChild.selected = false end
 	self.selectedChild = self:getChildAtLocation(x, y)
 	if self.selectedChild and not self.selectedChild.selectable then self.selectedChild = nil end
 	if self.selectedChild then
 		self.selectedChild.selected = true
 		x, y = self:localCoordsToChildCoords(x, y, self.selectedChild)
 		self.selectedChild:onmousepressed(x, y, button)
 	end
 	if self.selectedChild ~= oldSelectedChild then
 		if oldSelectedChild then oldSelectedChild:focus(false) end
 		if self.selectedChild then self.selectedChild:focus(true) end
 	end
 end
 
 function engine.Entity:onmousereleased(x, y, button)
 	self:mousereleased(x, y, button)
 	if self.selectedChild then
 		x, y = self:localCoordsToChildCoords(x, y, self.selectedChild)
 		self.selectedChild:onmousereleased(x, y, button)
 		if self.selectedChild:inBounds(x, y) then self.selectedChild:mouseclicked(x, y, button) end
 	end
 end
 
 -- Private methods
 
 function engine.Entity:inBounds(x, y)
 	return x >= 0 and x < self.width and y >= 0 and y < self.height
 end
 
 function engine.Entity:getChildAtLocation(x, y)
 	for i = 1, #self.children do
 		local child = self.children[#self.children - (i - 1)]
 		local cx, cy = self:localCoordsToChildCoords(x, y, child)
-	x = x + child.width / 2
+
-	y = y + child.height / 2
+
 end
 
 function engine.Entity:localCoordsToChildCoords(x, y, child)
 	x = (x - child.x) / child.scaleX
 	y = (y - child.y) / child.scaleY
 
 	distance = math.sqrt((x * x) + (y * y))
 	angle = math.atan2(y, x) - child.orientation
 
 	x = math.cos(angle) * distance
 	y = math.sin(angle) * distance
 
 	x = x + child.originX
 	y = y + child.originY
 
 	return x, y
 end
 
 -- Virtual methods
 
 function engine.Entity:setup(...)
 end
 
 function engine.Entity:destroy()
 end
 
 function engine.Entity:focus(f)
 end
 
 function engine.Entity:keypressed(key, unicode)
 end
 
 function engine.Entity:keyreleased(key)
 end
 
 function engine.Entity:mousepressed(x, y, button)
 end
 
 function engine.Entity:mousereleased(x, y, button)
 end
 
 function engine.Entity:mouseclicked(x, y, button)
 end
 
 function engine.Entity:update(dt)
 end
 
 function engine.Entity:preDraw()
 end
 
 function engine.Entity:draw()
 end