prototype/particular
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

removed middleclass

Browse Source
This commit is contained in:
Paul Liverman III 2015-11-24 15:01:56 -08:00
parent 472b4f2931
commit 28cb7c13fc
6 changed files with 56 additions and 230 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
src/Double.lua
View File

@ -1,22 +1,28 @@
local class = require "lib.middleclass"
local atan2 = math.atan2
local sin = math.sin
local cos = math.cos
local pi = math.pi
local lg = love.graphics
local sw = lg.getWidth()/2
local sh = lg.getHeight()/2
local set = setmetatable
local Element = require "Element"
local Double = class("Double")
local Double = {}
Double.static = {}
Double.static.threshold = 0.06
Double.static.maxCount = 500 --5000
Double.static.maxCount = 5000 --5000
Double.static.generated = 0
Double.static.count = 0
function Double:initialize(p1, p2)
function Double.initialize(p1, p2)
--if Double.static.count >= Double.static.maxCount then return nil end -- cancel over-generation
local self = {}
set(self, {__index = Double})
self.x = (p1.x + p2.x) / 2
self.y = (p1.y + p2.y) / 2
self.vx = (p1.vx + p2.vx) / 2
@ -31,12 +37,14 @@ function Double:initialize(p1, p2)
Double.static.generated = Double.static.generated + 1
Double.static.count = Double.static.count + 1
return self
end
function Double:update(dt)
-- if energy too high / too low, make an Element
if (self.energy >= 10) or (self.energy <= -20) then
return Element(self)
return Element.initialize(self)
end
self.energy = self.energy - dt/10
@ -51,11 +59,11 @@ function Double:draw()
local x = self.x + (1 * cos(self.angle))
local y = self.y + (1 * sin(self.angle))
lg.point(x + lg.getWidth()/2, y + lg.getHeight()/2)
lg.point(x + sw, y + sh)
local x = self.x + (1 * cos(self.angle + pi))
local y = self.y + (1 * sin(self.angle + pi))
lg.point(x + lg.getWidth()/2, y + lg.getHeight()/2)
lg.point(x + sw, y + sh)
end
return Double

12
src/Element.lua
View File

@ -1,13 +1,19 @@
local class = require "lib.middleclass"
local set = setmetatable
local Element = class("Element")
local Element = {}
Element.static = {}
Element.static.maxCount = 100 --1000
Element.static.generated = 0
Element.static.count = 0
function Element:initialize(double)
function Element.initialize(double)
-- DO SHIT BASED ON POSITIVE OR NEGATIVE
local self = {}
set(self, {__index = Element})
return self
end
return Element

18
src/Particle.lua
View File

@ -1,4 +1,3 @@
local class = require "lib.middleclass"
local random = math.random --TODO change out as needed later
local floor = math.floor
local pi2 = math.pi * 2
@ -6,20 +5,27 @@ local sin = math.sin
local cos = math.cos
local sqrt = math.sqrt
local lg = love.graphics
local sw = lg.getWidth()/2
local sh = lg.getHeight()/2
local set = setmetatable
local Particle = class("Particle")
local Particle = {}
local lifetimeRandomizer = love.math.newRandomGenerator(13) -- seeded instead of random, all types are set
Particle.static = {}
Particle.static.maxLifetime = 10 --NOTE can only used fixed "randomization" as long as maxLifetime is constant (because universe is random)
Particle.static.lifetimes = {}
Particle.static.maxCount = 1000 --10000
Particle.static.maxCount = 10000 --10000
Particle.static.generated = 0
Particle.static.count = 0
function Particle:initialize(radius, expansionRate)
function Particle.initialize(radius, expansionRate)
--if Particle.static.count >= Particle.static.maxCount then return nil end -- cancel over-generation of Particles
local self = {}
set(self, {__index = Particle})
-- this is because radius < 1 means that random() can't be used
if not (radius > 1) then
radius = 1
@ -44,6 +50,8 @@ function Particle:initialize(radius, expansionRate)
Particle.static.generated = Particle.static.generated + 1
Particle.static.count = Particle.static.count + 1
return self
end
function Particle:update(dt)
@ -59,7 +67,7 @@ end
function Particle:draw()
lg.setColor(255, 255, 255, 200)
lg.point(self.x + lg.getWidth()/2, self.y + lg.getHeight()/2)
lg.point(self.x + sw, self.y + sh)
end
function Particle:distanceTo(particle)

27
src/Universe.lua
View File

@ -1,15 +1,21 @@
local class = require "lib.middleclass"
local random = math.random --TODO change out as needed later
local floor = math.floor
local lg = love.graphics
local lt = love.timer
local sw = lg.getWidth()/2
local sh = lg.getHeight()/2
local set = setmetatable
local Particle = require "Particle"
local Double = require "Double"
local Element = require "Element"
local Universe = class("Universe")
local Universe = {}
function Universe.initialize(expansionRate, maxRadius)
local self = {}
set(self, {__index = Universe})
function Universe:initialize(expansionRate, maxRadius)
self.expansionRate = expansionRate or 1
self.maxRadius = maxRadius or 500
self.particles = {}
@ -19,6 +25,8 @@ function Universe:initialize(expansionRate, maxRadius)
self.time = {
nextGeneration = random()
}
return self
end
function Universe:update(dt)
@ -30,7 +38,7 @@ function Universe:update(dt)
if self.time.nextGeneration <= 0 then
if Particle.static.count < Particle.static.maxCount then
for i = 1, floor(self.radius) do
local particle = Particle(self.radius, self.expansionRate)
local particle = Particle.initialize(self.radius, self.expansionRate)
self.particles[particle] = particle
end
end
@ -42,7 +50,7 @@ function Universe:update(dt)
for key2, particle2 in pairs(self.particles) do
if (particle:distanceTo(particle2) <= Double.static.threshold) and (particle ~= particle2) then
-- make a double!
local double = Double(particle, particle2)
local double = Double.initialize(particle, particle2)
self.doubles[double] = double
self.particles[key] = nil
self.particles[key2] = nil
@ -73,11 +81,12 @@ function Universe:draw()
end
lg.setColor(255, 255, 255, 50)
lg.circle("line", lg.getWidth()/2, lg.getHeight()/2, self.radius)
lg.circle("line", sw, sh, self.radius)
lg.setColor(255, 255, 255, 255)
lg.print("Particles: " .. Particle.static.count .. "/" .. Particle.static.generated, 2, 2)
lg.print("Doubles: " .. Double.static.count .. "/" .. Double.static.generated, 2, 14)
lg.print("Elements: " .. Element.static.count .. "/" .. Element.static.generated, 2, 26)
lg.print("FPS: " .. lt.getFPS(), 2, 2)
lg.print("Particles: " .. Particle.static.count .. "/" .. Particle.static.generated, 2, 14)
lg.print("Doubles: " .. Double.static.count .. "/" .. Double.static.generated, 2, 26)
lg.print("Elements: " .. Element.static.count .. "/" .. Element.static.generated, 2, 38)
end
return Universe

203
src/lib/middleclass.lua
View File

@ -1,203 +0,0 @@
local middleclass = {
_VERSION = 'middleclass v3.2.0',
_DESCRIPTION = 'Object Orientation for Lua',
_URL = 'https://github.com/kikito/middleclass',
_LICENSE = [[
MIT LICENSE
Copyright (c) 2011 Enrique García Cota
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
]]
}
local _metamethods = {}
for m in ([[ add band bor bxor bnot call concat div eq
gc ipairs idiv le len lt metatable mod mode
mul pairs pow shl shr sub tostring unm ]]):gmatch("%S+") do
_metamethods['__' .. m] = true
end
local function _setClassDictionariesMetatables(aClass)
local dict = aClass.__instanceDict
dict.__index = dict
local super = aClass.super
if super then
local superStatic = super.static
setmetatable(dict, { __index = super.__instanceDict })
setmetatable(aClass.static, { __index = function(_,k) return rawget(dict,k) or superStatic[k] end })
else
setmetatable(aClass.static, { __index = function(_,k) return dict[k] end })
end
end
local function _propagateMetamethod(aClass, name, f)
for subclass in pairs(aClass.subclasses) do
if not subclass.__metamethods[name] then
subclass.__instanceDict[name] = f
_propagateMetamethod(subclass, name, f)
end
end
end
local function _updateClassDict(aClass, key, value)
if _metamethods[key] then
if value == nil then
aClass.__metamethods[key] = nil
if aClass.super then
value = aClass.super.__instanceDict[key]
end
else
aClass.__metamethods[key] = true
end
_propagateMetamethod(aClass, key, value)
end
aClass.__instanceDict[key] = value
end
local function _setClassMetatable(aClass)
setmetatable(aClass, {
__tostring = function() return "class " .. aClass.name end,
__index = aClass.static,
__newindex = _updateClassDict,
__call = function(self, ...) return self:new(...) end
})
end
local function _createClass(name, super)
local aClass = { name = name, super = super, static = {}, __mixins = {}, __instanceDict = {}, __metamethods = {} }
aClass.subclasses = setmetatable({}, {__mode = "k"})
_setClassDictionariesMetatables(aClass)
_setClassMetatable(aClass)
return aClass
end
local function _setSubclassMetamethods(aClass, subclass)
for m in pairs(_metamethods) do
subclass.__instanceDict[m] = aClass.__instanceDict[m]
end
end
local function _setDefaultInitializeMethod(aClass, super)
aClass.initialize = function(instance, ...)
return super.initialize(instance, ...)
end
end
local function _includeMixin(aClass, mixin)
assert(type(mixin)=='table', "mixin must be a table")
for name,method in pairs(mixin) do
if name ~= "included" and name ~= "static" then aClass[name] = method end
end
if mixin.static then
for name,method in pairs(mixin.static) do
aClass.static[name] = method
end
end
if type(mixin.included)=="function" then mixin:included(aClass) end
aClass.__mixins[mixin] = true
end
local Object = _createClass("Object", nil)
function Object.static:allocate()
assert(type(self) == 'table', "Make sure that you are using 'Class:allocate' instead of 'Class.allocate'")
return setmetatable({ class = self }, self.__instanceDict)
end
function Object.static:new(...)
local instance = self:allocate()
instance:initialize(...)
return instance
end
function Object.static:subclass(name)
assert(type(self) == 'table', "Make sure that you are using 'Class:subclass' instead of 'Class.subclass'")
assert(type(name) == "string", "You must provide a name(string) for your class")
local subclass = _createClass(name, self)
_setSubclassMetamethods(self, subclass)
_setDefaultInitializeMethod(subclass, self)
self.subclasses[subclass] = true
self:subclassed(subclass)
return subclass
end
function Object.static:subclassed(other) end
function Object.static:isSubclassOf(other)
return type(other) == 'table' and
type(self) == 'table' and
type(self.super) == 'table' and
( self.super == other or
type(self.super.isSubclassOf) == 'function' and
self.super:isSubclassOf(other)
)
end
function Object.static:include( ... )
assert(type(self) == 'table', "Make sure you that you are using 'Class:include' instead of 'Class.include'")
for _,mixin in ipairs({...}) do _includeMixin(self, mixin) end
return self
end
function Object.static:includes(mixin)
return type(mixin) == 'table' and
type(self) == 'table' and
type(self.__mixins) == 'table' and
( self.__mixins[mixin] or
type(self.super) == 'table' and
type(self.super.includes) == 'function' and
self.super:includes(mixin)
)
end
function Object:initialize() end
function Object:__tostring() return "instance of " .. tostring(self.class) end
function Object:isInstanceOf(aClass)
return type(self) == 'table' and
type(self.class) == 'table' and
type(aClass) == 'table' and
( aClass == self.class or
type(aClass.isSubclassOf) == 'function' and
self.class:isSubclassOf(aClass)
)
end
function middleclass.class(name, super, ...)
super = super or Object
return super:subclass(name, ...)
end
middleclass.Object = Object
setmetatable(middleclass, { __call = function(_, ...) return middleclass.class(...) end })
return middleclass

4
src/main.lua
View File

@ -1,11 +1,9 @@
local lg = love.graphics
local lm = love.math
--NOTE math.random seed has not been set, this means every run should be the same (except for potential hardware differences)
local Universe = require "Universe"
--local Particle = require "Particle"
local universe = Universe(10, 300)
local universe = Universe.initialize() --Universe.initialize(10, 300)
function love.update(dt)
universe:update(dt)