some of this probably shouldn't be commited

src/Player.lua

@@ -0,0 +1,44 @@
+local class = require "lib.middleclass"
+local Ship = require "Ship"
+
+local Player = class('Player')
+
+function Player:initialize(Ship)
+	-- Ship
+	self.Ship = Ship or console.e("Player created with no Ship.")
+
+	-- TEMPORARY VALUES TO KEEP EVERYTHING FROM BREAKING RIGHT NOW
+	--Hull
+	self.image = self.Ship.Hull.image
+	self.imgHalfWidth = self.Ship.Hull.imgHalfWidth
+	self.imgHalfHeight = self.Ship.Hull.imgHalfHeight
+	self.imgScale = self.Ship.Hull.imgScale
+	--Shield
+	self.shieldhit = self.Ship.Shield.image
+	self.shieldHalfWidth = self.Ship.Shield.imgHalfWidth
+	self.shieldHalfHeight = self.Ship.Shield.imgHalfHeight
+	self.shieldScale = self.Ship.Shield.imgScale
+	--Engine
+	self.maximumSpeed = self.Ship.Engine.maximumSpeed
+	self.spaceDrag = self.Ship.Engine.spaceDrag
+	self.speedLowerLimit = self.Ship.Engine.speedLowerLimit
+	self.degreeLock = self.Ship.Engine.degreeLock
+	self.rotationImpulse = self.Ship.Engine.rotationImpulse
+	self.rotationDrag = self.Ship.Engine.rotationDrag
+	self.rotationLowerLimit = self.Ship.Engine.rotationLowerLimit
+	--Thrusters
+	self.forwardThrust = 2600
+	self.reverseThrust = 1300
+	self.sideThrust = 800
+	--Location
+	self.x = self.Ship.x
+	self.y = self.Ship.y
+	self.v = {
+		x = self.Ship.v.x,
+		y = self.Ship.v.y
+	}
+	self.currentRotation = self.Ship.currentRotation
+	self.rotationSpeed = self.Ship.rotationSpeed
+end
+
+return Player

src/Ship.lua

@@ -0,0 +1,60 @@
+local class = require "lib.middleclass"
+
+local Ship = class('Ship')
+
+function Ship:initialize(Hull, Shield, Engine, Thrusters, Location)
+	-- Location
+	self.x = Location.x or 0 and console.d("Ship created with incomplete location.")
+	self.y = Location.y or 0 and console.d("Ship created with incomplete location.")
+	self.v = {
+		x = Location.v.x or 0 and console.d("Ship created with incomplete location."),
+		y = Location.v.y or 0 and console.d("Ship created with incomplete location.")
+	}
+	self.currentRotation = Location.currentRotation or 0 and console.d("Ship created with incomplete location.")
+	self.rotationSpeed = Location.rotationSpeed or 0 and console.d("Ship created with incomplete location.")
+
+	-- Hull
+	self.Hull = Hull or console.e("Ship created with no Hull.")
+
+	-- Shield
+	self.Shield = Shield or nil and console.d("Ship created with no Shield.")
+
+	-- Engine
+	self.Engine = Engine or nil and console.e("Ship created with no Engine.")
+
+	-- Thrusters
+	self.Thrusters = Thrusters or {} and console.e("Ship created with no Thrusters.")
+end
+
+local directions = {
+	forward = -math.pi/2,
+	backward = math.pi/2,
+	left = math.pi,
+	right = 0
+}
+
+function Ship:accelerate(direction, dt)
+	-- get amount of thrust based on which Thrusters fire that way
+	local thrust = 0
+	for i=1,#self.Thrusters do
+		if self.Thrusters[i].direction == direction then
+			thrust = thrust + self.Thrusters[i].thrust
+		end
+	end
+
+	-- here is where we actually apply acceleration
+	self.v.x = self.v.x + thrust * math.cos(self.currentRotation - (self.currentRotation % self.Engine.degreeLock) + directions[direction]) * dt
+	self.v.y = self.v.y + thrust * math.sin(self.currentRotation - (self.currentRotation % self.Engine.degreeLock) + directions[direction]) * dt
+
+	-- check if above maximum speed and fix if needed
+	local magnitude = math.sqrt(self.v.x * self.v.x + self.v.y * self.v.y)
+	if magnitude > self.Engine.maximumSpeed then
+		-- do thrust backwards
+		local reverseDirection = math.tan(self.v.y, self.v.x) + math.pi
+		local reverseMagnitude = magnitude - self.Engine.maximumSpeed
+		self.v.x = self.v.x + reverseMagnitude * math.cos(reverseDirection) * dt
+		self.v.y = self.v.y + reverseMagnitude * math.sin(reverseDirection) * dt
+	end
+end
+
+return Ship

src/lib/middleclass.lua

@@ -0,0 +1,182 @@
+local middleclass = {
+  _VERSION     = 'middleclass v3.0.1',
+  _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 function _setClassDictionariesMetatables(aClass)
+  local dict = aClass.__instanceDict
+  dict.__index = dict
+
+  local super = aClass.super
+  if super then
+    local superStatic = super.static
+    setmetatable(dict, super.__instanceDict)
+    setmetatable(aClass.static, { __index = function(_,k) return dict[k] or superStatic[k] end })
+  else
+    setmetatable(aClass.static, { __index = function(_,k) return dict[k] end })
+  end
+end
+
+local function _setClassMetatable(aClass)
+  setmetatable(aClass, {
+    __tostring = function() return "class " .. aClass.name end,
+    __index    = aClass.static,
+    __newindex = aClass.__instanceDict,
+    __call     = function(self, ...) return self:new(...) end
+  })
+end
+
+local function _createClass(name, super)
+  local aClass = { name = name, super = super, static = {}, __mixins = {}, __instanceDict={} }
+  aClass.subclasses = setmetatable({}, {__mode = "k"})
+
+  _setClassDictionariesMetatables(aClass)
+  _setClassMetatable(aClass)
+
+  return aClass
+end
+
+local function _createLookupMetamethod(aClass, name)
+  return function(...)
+    local method = aClass.super[name]
+    assert( type(method)=='function', tostring(aClass) .. " doesn't implement metamethod '" .. name .. "'" )
+    return method(...)
+  end
+end
+
+local function _setClassMetamethods(aClass)
+  for _,m in ipairs(aClass.__metamethods) do
+    aClass[m]= _createLookupMetamethod(aClass, 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)
+
+Object.static.__metamethods = { '__add', '__call', '__concat', '__div', '__ipairs', '__le',
+                                '__len', '__lt', '__mod', '__mul', '__pairs', '__pow', '__sub',
+                                '__tostring', '__unm'}
+
+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)
+  _setClassMetamethods(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