lots of rewrite

old/main.lua

@@ -0,0 +1,157 @@
+local bsg = require "ships.bsg"
+local viper = require "ships.viper"
+
+local lg = love.graphics
+
+local images = {}
+local ships = {}
+
+local hx, hy = lg.getWidth() / 2, lg.getHeight() / 2
+
+local scale = 8
+
+local selected
+
+function love.load()
+    lg.setDefaultFilter("linear", "nearest", 1)
+    images.bsg = lg.newImage('img/bsg.png')
+    images.viper = lg.newImage('img/viper.png')
+    lg.setPointSize(10)
+    lg.setPointStyle("rough")
+
+    ships[1] = bsg()
+    for i=1,8 do
+        local v = viper()
+        table.insert(ships, v)
+        ships[1]:dock(v, i)
+    end
+end
+
+local timer = 0
+function love.update(dt)
+    timer = timer + dt
+    if timer >= 33 then
+        timer = timer - 33
+    end
+end
+
+local function drawClock(x, y, r)
+    local time = math.floor(33 - timer)
+    if time == 0 then time = 33 end
+
+    local maxTime = 33
+
+    local segments = 33
+    local segmentRadius = math.pi*2 / segments
+    local dividerRadius = segmentRadius / 2
+    --local time = 33
+
+    lg.setColor(255, 102, 0)
+    for i=1,time do
+        lg.arc("fill", x, y, r, (i-1)*segmentRadius - math.pi/2, i*segmentRadius - dividerRadius - math.pi/2)
+    end
+    lg.setColor(0, 0, 0)
+    lg.circle("fill", x, y, r/1.15)
+
+    -- this looks cool and all, but it is the same function as the outer ring
+    -- instead, use this internal space for displaying things like fuel and water and supplies
+    --[[
+    segments = 12
+    segmentRadius = math.pi*2 / segments
+    dividerRadius = segmentRadius / segments * 2
+    time = math.floor(time/maxTime * segments) --33 -> 12   percentage = time/maxTime..multiply this by 12
+
+    lg.setColor(255, 102, 0)
+    for i=1,time do
+        lg.arc("fill", x, y, r/1.5, (i-1)*segmentRadius - math.pi/2, i*segmentRadius - dividerRadius - math.pi/2)
+    end
+    lg.setColor(0, 0, 0)
+    lg.circle("fill", x, y, r/2)
+    --]]
+
+    --tmp, really each color-dependent section should do this itself!
+    lg.setColor(255, 255, 255)
+end
+
+local drawWheel = require "wheel";
+
+function love.draw()
+    lg.translate(hx, hy)
+
+    for i=1,#ships do
+        lg.draw(images[ships[i].img], ships[i].x * scale, ships[i].y * scale, ships[i].rotation, scale, scale, ships[i].ox, ships[i].oy)
+    end
+
+    if selected then
+        lg.setColor(220, 180, 0)
+        lg.point(selected.x * scale, selected.y * scale)
+        lg.setColor(255, 255, 255)
+    end
+
+    --drawClock(-355, -145, 120)
+    drawWheel(-355, -145, 120, timer)
+end
+
+function love.keypressed(key, unicode)
+    if key == "escape" then
+        love.event.quit()
+    end
+end
+
+local function pointInRadius(x, y, cx, cy, r)
+    cx = cx * scale + hx
+    cy = cy * scale + hy
+    local dx = x - cx
+    local dy = y - cy
+    return r * scale >= math.sqrt(dx * dx + dy * dy)
+end
+
+local function pointInAABB(x, y, cx, cy, s, r)
+    -- THIS IS HORRIBLY WRONG, FIX IT LATER
+    --[[
+    var x=((objects[i].x-objects[renderId].x)*Math.cos(rot)-(objects[i].y-objects[renderId].y)*Math.sin(rot))*scaleFactor;
+    var y=((objects[i].x-objects[renderId].x)*Math.sin(rot)+(objects[i].y-objects[renderId].y)*Math.cos(rot))*scaleFactor;
+    ]]
+    local nx = (x - cx) * math.cos(r) - (y - cy) * math.sin(r)
+    local ny = (x - cx) * math.sin(r) + (y - cy) * math.cos(r)
+    x = nx
+    y = ny
+    cx = cx * scale + hx
+    cy = cy * scale + hy
+    return x >= cx - s.w * scale / 2 and x <= cx + s.w * scale / 2 and y >= cy - s.h * scale / 2 and y <= cy + s.h * scale / 2
+end
+
+function love.mousepressed(x, y, button)
+    if button == "l" then
+        if selected then
+            -- find out where this actually is, now the ship selected is ordered to move to this point
+            selected.ship:moveTo(x * scale + hx, y * scale + hy)
+        else
+            for i=1,#ships do
+                if ships[i].selection.r then
+                    if pointInRadius(x, y, ships[i].x, ships[i].y, ships[i].selection.r) then
+                        -- selected
+                        -- NOW CHECK IF HAS NODES AND IF WE ARE SELECTING A SHIP ON A NODE!
+                        selected = {}
+                        selected.ship = ships[i]
+                        selected.x = ships[i].x
+                        selected.y = ships[i].y
+                    end
+                else
+                    if pointInAABB(x, y, ships[i].x, ships[i].y, ships[i].selection, ships[i].rotation) then
+                        -- we are selecting it!
+                        -- NOW CHECK IF HAS NODES AND IF WE ARE SELECTING A SHIP ON A NODE!
+                        selected = {}
+                        selected.ship = ships[i]
+                        selected.x = ships[i].x
+                        selected.y = ships[i].y
+                    end
+                end
+            end
+        end
+    elseif button == "wd" then
+        scale = scale * 1.1
+    elseif button == "wu" then
+        scale = scale * 0.9
+    end
+end

src/lib/inspect.lua

@@ -0,0 +1,327 @@
+local inspect ={
+  _VERSION = 'inspect.lua 3.0.0',
+  _URL     = 'http://github.com/kikito/inspect.lua',
+  _DESCRIPTION = 'human-readable representations of tables',
+  _LICENSE = [[
+    MIT LICENSE
+
+    Copyright (c) 2013 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.
+  ]]
+}
+
+inspect.KEY       = setmetatable({}, {__tostring = function() return 'inspect.KEY' end})
+inspect.METATABLE = setmetatable({}, {__tostring = function() return 'inspect.METATABLE' end})
+
+-- Apostrophizes the string if it has quotes, but not aphostrophes
+-- Otherwise, it returns a regular quoted string
+local function smartQuote(str)
+  if str:match('"') and not str:match("'") then
+    return "'" .. str .. "'"
+  end
+  return '"' .. str:gsub('"', '\\"') .. '"'
+end
+
+local controlCharsTranslation = {
+  ["\a"] = "\\a",  ["\b"] = "\\b", ["\f"] = "\\f",  ["\n"] = "\\n",
+  ["\r"] = "\\r",  ["\t"] = "\\t", ["\v"] = "\\v"
+}
+
+local function escape(str)
+  local result = str:gsub("\\", "\\\\"):gsub("(%c)", controlCharsTranslation)
+  return result
+end
+
+local function isIdentifier(str)
+  return type(str) == 'string' and str:match( "^[_%a][_%a%d]*$" )
+end
+
+local function isSequenceKey(k, length)
+  return type(k) == 'number'
+     and 1 <= k
+     and k <= length
+     and math.floor(k) == k
+end
+
+local defaultTypeOrders = {
+  ['number']   = 1, ['boolean']  = 2, ['string'] = 3, ['table'] = 4,
+  ['function'] = 5, ['userdata'] = 6, ['thread'] = 7
+}
+
+local function sortKeys(a, b)
+  local ta, tb = type(a), type(b)
+
+  -- strings and numbers are sorted numerically/alphabetically
+  if ta == tb and (ta == 'string' or ta == 'number') then return a < b end
+
+  local dta, dtb = defaultTypeOrders[ta], defaultTypeOrders[tb]
+  -- Two default types are compared according to the defaultTypeOrders table
+  if dta and dtb then return defaultTypeOrders[ta] < defaultTypeOrders[tb]
+  elseif dta     then return true  -- default types before custom ones
+  elseif dtb     then return false -- custom types after default ones
+  end
+
+  -- custom types are sorted out alphabetically
+  return ta < tb
+end
+
+local function getNonSequentialKeys(t)
+  local keys, length = {}, #t
+  for k,_ in pairs(t) do
+    if not isSequenceKey(k, length) then table.insert(keys, k) end
+  end
+  table.sort(keys, sortKeys)
+  return keys
+end
+
+local function getToStringResultSafely(t, mt)
+  local __tostring = type(mt) == 'table' and rawget(mt, '__tostring')
+  local str, ok
+  if type(__tostring) == 'function' then
+    ok, str = pcall(__tostring, t)
+    str = ok and str or 'error: ' .. tostring(str)
+  end
+  if type(str) == 'string' and #str > 0 then return str end
+end
+
+local maxIdsMetaTable = {
+  __index = function(self, typeName)
+    rawset(self, typeName, 0)
+    return 0
+  end
+}
+
+local idsMetaTable = {
+  __index = function (self, typeName)
+    local col = setmetatable({}, {__mode = "kv"})
+    rawset(self, typeName, col)
+    return col
+  end
+}
+
+local function countTableAppearances(t, tableAppearances)
+  tableAppearances = tableAppearances or setmetatable({}, {__mode = "k"})
+
+  if type(t) == 'table' then
+    if not tableAppearances[t] then
+      tableAppearances[t] = 1
+      for k,v in pairs(t) do
+        countTableAppearances(k, tableAppearances)
+        countTableAppearances(v, tableAppearances)
+      end
+      countTableAppearances(getmetatable(t), tableAppearances)
+    else
+      tableAppearances[t] = tableAppearances[t] + 1
+    end
+  end
+
+  return tableAppearances
+end
+
+local copySequence = function(s)
+  local copy, len = {}, #s
+  for i=1, len do copy[i] = s[i] end
+  return copy, len
+end
+
+local function makePath(path, ...)
+  local keys = {...}
+  local newPath, len = copySequence(path)
+  for i=1, #keys do
+    newPath[len + i] = keys[i]
+  end
+  return newPath
+end
+
+local function processRecursive(process, item, path)
+  if item == nil then return nil end
+
+  local processed = process(item, path)
+  if type(processed) == 'table' then
+    local processedCopy = {}
+    local processedKey
+
+    for k,v in pairs(processed) do
+      processedKey = processRecursive(process, k, makePath(path, k, inspect.KEY))
+      if processedKey ~= nil then
+        processedCopy[processedKey] = processRecursive(process, v, makePath(path, processedKey))
+      end
+    end
+
+    local mt  = processRecursive(process, getmetatable(processed), makePath(path, inspect.METATABLE))
+    setmetatable(processedCopy, mt)
+    processed = processedCopy
+  end
+  return processed
+end
+
+
+-------------------------------------------------------------------
+
+local Inspector = {}
+local Inspector_mt = {__index = Inspector}
+
+function Inspector:puts(...)
+  local args   = {...}
+  local buffer = self.buffer
+  local len    = #buffer
+  for i=1, #args do
+    len = len + 1
+    buffer[len] = tostring(args[i])
+  end
+end
+
+function Inspector:down(f)
+  self.level = self.level + 1
+  f()
+  self.level = self.level - 1
+end
+
+function Inspector:tabify()
+  self:puts(self.newline, string.rep(self.indent, self.level))
+end
+
+function Inspector:alreadyVisited(v)
+  return self.ids[type(v)][v] ~= nil
+end
+
+function Inspector:getId(v)
+  local tv = type(v)
+  local id = self.ids[tv][v]
+  if not id then
+    id              = self.maxIds[tv] + 1
+    self.maxIds[tv] = id
+    self.ids[tv][v] = id
+  end
+  return id
+end
+
+function Inspector:putKey(k)
+  if isIdentifier(k) then return self:puts(k) end
+  self:puts("[")
+  self:putValue(k)
+  self:puts("]")
+end
+
+function Inspector:putTable(t)
+  if t == inspect.KEY or t == inspect.METATABLE then
+    self:puts(tostring(t))
+  elseif self:alreadyVisited(t) then
+    self:puts('<table ', self:getId(t), '>')
+  elseif self.level >= self.depth then
+    self:puts('{...}')
+  else
+    if self.tableAppearances[t] > 1 then self:puts('<', self:getId(t), '>') end
+
+    local nonSequentialKeys = getNonSequentialKeys(t)
+    local length            = #t
+    local mt                = getmetatable(t)
+    local toStringResult    = getToStringResultSafely(t, mt)
+
+    self:puts('{')
+    self:down(function()
+      if toStringResult then
+        self:puts(' -- ', escape(toStringResult))
+        if length >= 1 then self:tabify() end
+      end
+
+      local count = 0
+      for i=1, length do
+        if count > 0 then self:puts(',') end
+        self:puts(' ')
+        self:putValue(t[i])
+        count = count + 1
+      end
+
+      for _,k in ipairs(nonSequentialKeys) do
+        if count > 0 then self:puts(',') end
+        self:tabify()
+        self:putKey(k)
+        self:puts(' = ')
+        self:putValue(t[k])
+        count = count + 1
+      end
+
+      if mt then
+        if count > 0 then self:puts(',') end
+        self:tabify()
+        self:puts('<metatable> = ')
+        self:putValue(mt)
+      end
+    end)
+
+    if #nonSequentialKeys > 0 or mt then -- result is multi-lined. Justify closing }
+      self:tabify()
+    elseif length > 0 then -- array tables have one extra space before closing }
+      self:puts(' ')
+    end
+
+    self:puts('}')
+  end
+end
+
+function Inspector:putValue(v)
+  local tv = type(v)
+
+  if tv == 'string' then
+    self:puts(smartQuote(escape(v)))
+  elseif tv == 'number' or tv == 'boolean' or tv == 'nil' then
+    self:puts(tostring(v))
+  elseif tv == 'table' then
+    self:putTable(v)
+  else
+    self:puts('<',tv,' ',self:getId(v),'>')
+  end
+end
+
+-------------------------------------------------------------------
+
+function inspect.inspect(root, options)
+  options       = options or {}
+
+  local depth   = options.depth   or math.huge
+  local newline = options.newline or '\n'
+  local indent  = options.indent  or '  '
+  local process = options.process
+
+  if process then
+    root = processRecursive(process, root, {})
+  end
+
+  local inspector = setmetatable({
+    depth            = depth,
+    buffer           = {},
+    level            = 0,
+    ids              = setmetatable({}, idsMetaTable),
+    maxIds           = setmetatable({}, maxIdsMetaTable),
+    newline          = newline,
+    indent           = indent,
+    tableAppearances = countTableAppearances(root)
+  }, Inspector_mt)
+
+  inspector:putValue(root)
+
+  return table.concat(inspector.buffer)
+end
+
+setmetatable(inspect, { __call = function(_, ...) return inspect.inspect(...) end })
+
+return inspect

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

src/main.lua

@@ -1,95 +1,49 @@
-local bsg = require "ships.bsg"
+--tmp
-local viper = require "ships.viper"
+local inspect = require "lib.inspect"
 
 local lg = love.graphics
 
-local images = {}
-local ships = {}
-
 local hx, hy = lg.getWidth() / 2, lg.getHeight() / 2
-
 local scale = 8
 
+local images = {}
+local fleet = {}
+
+local bsg = require "ships.bsg"
+local viper = require "ships.viper"
+
+--tmp
 local selected
 
 function love.load()
     lg.setDefaultFilter("linear", "nearest", 1)
     images.bsg = lg.newImage('img/bsg.png')
     images.viper = lg.newImage('img/viper.png')
+    --tmp
     lg.setPointSize(10)
     lg.setPointStyle("rough")
 
-    ships[1] = bsg()
+    fleet[1] = bsg()
     for i=1,8 do
         local v = viper()
-        table.insert(ships, v)
+        table.insert(fleet, v)
-        ships[1]:dock(v, i)
+        fleet[1]:dock(v, i)
     end
 end
 
-local timer = 0
-function love.update(dt)
-    timer = timer + dt
-    if timer >= 33 then
-        timer = timer - 33
-    end
-end
-
-local function drawClock(x, y, r)
-    local time = math.floor(33 - timer)
-    if time == 0 then time = 33 end
-
-    local maxTime = 33
-
-    local segments = 33
-    local segmentRadius = math.pi*2 / segments
-    local dividerRadius = segmentRadius / 2
-    --local time = 33
-
-    lg.setColor(255, 102, 0)
-    for i=1,time do
-        lg.arc("fill", x, y, r, (i-1)*segmentRadius - math.pi/2, i*segmentRadius - dividerRadius - math.pi/2)
-    end
-    lg.setColor(0, 0, 0)
-    lg.circle("fill", x, y, r/1.15)
-
-    -- this looks cool and all, but it is the same function as the outer ring
-    -- instead, use this internal space for displaying things like fuel and water and supplies
-    --[[
-    segments = 12
-    segmentRadius = math.pi*2 / segments
-    dividerRadius = segmentRadius / segments * 2
-    time = math.floor(time/maxTime * segments) --33 -> 12   percentage = time/maxTime..multiply this by 12
-
-    lg.setColor(255, 102, 0)
-    for i=1,time do
-        lg.arc("fill", x, y, r/1.5, (i-1)*segmentRadius - math.pi/2, i*segmentRadius - dividerRadius - math.pi/2)
-    end
-    lg.setColor(0, 0, 0)
-    lg.circle("fill", x, y, r/2)
-    --]]
-
-    --tmp, really each color-dependent section should do this itself!
-    lg.setColor(255, 255, 255)
-end
-
-local drawWheel = require "wheel";
-
 function love.draw()
     lg.translate(hx, hy)
 
-    for i=1,#ships do
+    lg.setColor(255, 255, 255)
-        lg.draw(images[ships[i].img], ships[i].x * scale, ships[i].y * scale, ships[i].rotation, scale, scale, ships[i].ox, ships[i].oy)
+    for i=1,#fleet do
+        lg.draw(images[fleet[i].img], fleet[i].x * scale, fleet[i].y * scale, fleet[i].rotation, scale, scale, fleet[i].ox, fleet[i].oy)
     end
 
+    --tmp
     if selected then
         lg.setColor(220, 180, 0)
         lg.point(selected.x * scale, selected.y * scale)
-        lg.setColor(255, 255, 255)
     end
-
-    --drawClock(-355, -145, 120)
-    drawWheel(-355, -145, 120, timer)
 end
 
 function love.keypressed(key, unicode)
@@ -97,61 +51,3 @@ function love.keypressed(key, unicode)
         love.event.quit()
     end
 end
-
-local function pointInRadius(x, y, cx, cy, r)
-    cx = cx * scale + hx
-    cy = cy * scale + hy
-    local dx = x - cx
-    local dy = y - cy
-    return r * scale >= math.sqrt(dx * dx + dy * dy)
-end
-
-local function pointInAABB(x, y, cx, cy, s, r)
-    -- THIS IS HORRIBLY WRONG, FIX IT LATER
-    --[[
-    var x=((objects[i].x-objects[renderId].x)*Math.cos(rot)-(objects[i].y-objects[renderId].y)*Math.sin(rot))*scaleFactor;
-    var y=((objects[i].x-objects[renderId].x)*Math.sin(rot)+(objects[i].y-objects[renderId].y)*Math.cos(rot))*scaleFactor;
-    ]]
-    local nx = (x - cx) * math.cos(r) - (y - cy) * math.sin(r)
-    local ny = (x - cx) * math.sin(r) + (y - cy) * math.cos(r)
-    x = nx
-    y = ny
-    cx = cx * scale + hx
-    cy = cy * scale + hy
-    return x >= cx - s.w * scale / 2 and x <= cx + s.w * scale / 2 and y >= cy - s.h * scale / 2 and y <= cy + s.h * scale / 2
-end
-
-function love.mousepressed(x, y, button)
-    if button == "l" then
-        if selected then
-            -- find out where this actually is, now the ship selected is ordered to move to this point
-            selected.ship:moveTo(x * scale + hx, y * scale + hy)
-        else
-            for i=1,#ships do
-                if ships[i].selection.r then
-                    if pointInRadius(x, y, ships[i].x, ships[i].y, ships[i].selection.r) then
-                        -- selected
-                        -- NOW CHECK IF HAS NODES AND IF WE ARE SELECTING A SHIP ON A NODE!
-                        selected = {}
-                        selected.ship = ships[i]
-                        selected.x = ships[i].x
-                        selected.y = ships[i].y
-                    end
-                else
-                    if pointInAABB(x, y, ships[i].x, ships[i].y, ships[i].selection, ships[i].rotation) then
-                        -- we are selecting it!
-                        -- NOW CHECK IF HAS NODES AND IF WE ARE SELECTING A SHIP ON A NODE!
-                        selected = {}
-                        selected.ship = ships[i]
-                        selected.x = ships[i].x
-                        selected.y = ships[i].y
-                    end
-                end
-            end
-        end
-    elseif button == "wd" then
-        scale = scale * 1.1
-    elseif button == "wu" then
-        scale = scale * 0.9
-    end
-end

src/ships/Node.lua

@@ -1,11 +1,35 @@
-return function(x, y, rotation)
+local class = require "lib.middleclass"
-    local self = {}
 
+local Node = class('Node')
+
+function Node:initialize(x, y, rotation)
     self.x = x or 0
     self.y = y or 0
     self.rotation = rotation or 0
 
-    self.docked = false
+    self.dockedShip = false
-
-    return self
 end
+
+--TODO docking needs to check distance between ships and only allow
+--     docking when close enough
+function Node:dock(Ship)
+    if self.dockedShip or Ship.dockedTo then
+        error("Attempted to dock to Node with something already docked to it!")
+    else
+        self.dockedShip = Ship
+        Ship.dockedTo = self
+
+        Ship:setPosition(self.x, self.y, self.rotation)
+    end
+end
+
+function Node:undock()
+    if not self.dockedShip then
+        error("Attempted to undock a ship from a Node with no docked ship.")
+    else
+        self.dockedShip.dockedTo = false
+        self.dockedShip = false
+    end
+end
+
+return Node

src/ships/Resources.lua

@@ -0,0 +1,50 @@
+local class = require "lib.middleclass"
+
+local Resources = class('Resources')
+
+function Resources:initialize()
+    self.ammo = 0
+    self.fuel = 0
+    self.supplies = 0
+    self.water = 0
+    self.food = 0
+    self.metal = 0
+    self.ore = 0
+    self.crew = 0
+
+    self.missiles = 0
+    self.nukes = 0
+
+    self.maxAmmo = 0
+    self.maxFuel = 0
+    self.maxSupplies = 0
+    self.maxWater = 0
+    self.maxFood = 0
+    self.maxMetal = 0
+    self.maxOre = 0
+    self.maxCrew = 0
+
+    self.ammoUse = 0
+    self.fuelUseIdle = 0
+    self.fuelUseMoving = 0
+    self.fuelUseJump = 0
+    self.suppliesUse = 0
+    self.waterUse = 0
+    self.foodUse = 0
+    self.metalUse = 0
+    self.oreUse = 0
+    self.crewUse = 0
+end
+
+function Resources:maxEverything()
+    self.ammo = self.maxAmmo
+    self.fuel = self.maxFuel
+    self.supplies = self.maxSupplies
+    self.water = self.maxWater
+    self.food = self.maxFood
+    self.metal = self.maxMetal
+    self.ore = self.maxOre
+    self.crew = self.maxCrew
+end
+
+return Resources

src/ships/Ship.lua

@@ -0,0 +1,84 @@
+local class = require "lib.middleclass"
+
+local Resources = require "ships.Resources"
+
+local Ship = class('Ship')
+
+function Ship:initialize(x, y, rotation)
+    self.img = ""
+    --offsets
+    self.ox = 0
+    self.oy = 0
+
+    self.x = x or 0
+    self.y = y or 0
+    self.destination = {
+        x = x or 0,
+        y = y or 0
+    }
+    self.rotation = rotation or 0
+
+    self.selection = {}
+
+    self.node = {}
+
+    self.dockedTo = false
+
+    self.Resources = Resources()
+end
+
+function Ship:dock(targetShip, nodeIndex)
+    if self.node[nodeIndex] then
+        self.node[nodeIndex]:dock(targetShip)
+    else
+        error("Ship attempted to dock to non-existent Node.")
+    end
+end
+
+function Ship:undock(nodeIndex)
+    if self.node[nodeIndex] then
+        self.node[nodeIndex]:undock()
+    else
+        --find which node "nodeIndex" is docked to
+        for i=1,#self.node do
+            if self.node[i].dockedShip == nodeIndex then
+                self.node[i]:undock()
+                return
+            end
+        end
+        error("Ship attempted to undock from non-existent Node.")
+    end
+end
+
+function Ship:dockTo(targetShip, nodeIndex)
+    if targetShip.node[nodeIndex] then
+        targetShip.node[nodeIndex]:dock(self)
+    else
+        error("Ship attempted to dock to non-existent Node.")
+    end
+end
+
+function Ship:undockFromParent()
+    self.dockedTo:undock(self)
+end
+
+function Ship:setPosition(x, y, rotation)
+    self.x = x or self.x
+    self.y = y or self.y
+    self.rotation = rotation or self.rotation
+end
+
+function Ship:moveTo(x, y)
+    if self.dockedTo then
+        self:undockFromParent()
+    end
+    self.destination.x = x
+    self.destination.y = y
+end
+
+function Ship:update(dt)
+    --check our speed, see how far along the "line" we can go, go there
+    -- if reached destination ... WELL SHIT DEST NEEDS TO BE ABLE TO KNOW IF IS SHIP OR WHATEVER
+end
+
+return Ship

src/ships/bsg.lua

@@ -1,18 +1,21 @@
-local Node = require "ships.Node"
+math.randomseed(os.time())
+math.random() math.random()
 
+local class = require "lib.middleclass"
+
+local Ship = require "ships.Ship"
+local Node = require "ships.Node"
 local ninety = 90 * math.pi / 180
 
-return function(x, y, rotation)
+local BSG = class('BSG', Ship)
-    local self = {}
 
+function BSG:initialize(x, y, rotation)
+    Ship.initialize(self, x, y, rotation)
     self.img = "bsg"
+    --offsets
     self.ox = 31.5
     self.oy = 67
 
-    self.x = x or 0
-    self.y = y or 0
-    self.rotation = rotation or 0
-
     --[[
     self.selection = {
         w = 54,
@@ -34,33 +37,50 @@ return function(x, y, rotation)
         Node(-23, 16.5, -ninety)
     }
 
-    self.dock = function(self, ship, node)
+    self.Resources.maxAmmo = 1000000
-        if self.node[node].docked or ship.isDocked then return false end
+    self.Resources.maxFuel = 1300000
+    self.Resources.maxSupplies = 40000
+    --what the fuck are jp's ?
+    -- http://www.traditionaloven.com/culinary-arts/cooking/shortening/convert-japanese-cup-measure-of-shortening-to-fluid-ounce-floz-shortening.html
+    -- From show "10 mil JPs water lost, almost 60%"
+    self.Resources.maxWater = 16000000
+    self.Resources.maxFood = 51000
+    self.Resources.maxMetal = 80000
+    --self.Resources.maxOre = 0
+    self.Resources.maxCrew = 5100
 
-        ship.x = self.node[node].x
+    self.Resources.ammo = math.random(100, 1300)
-        ship.y = self.node[node].y
+    self.Resources.fuel = math.random(496000, 512000)
-        ship.rotation = self.node[node].rotation
+    self.Resources.supplies = math.random(18000,21000)
+    self.Resources.water = math.random(14186500, 14989900)
+    self.Resources.food = math.random(34700, 39200)
+    self.Resources.metal = math.random(19200,21600)
+    --self.Resources.ore = 0
+    self.Resources.crew = math.random(2870, 2960)
 
-        self.node[node].docked = ship
+    self.Resources.missiles = math.random(5, 11)
-        ship.isDocked = true
+    --self.Resources.nukes = 0
-        ship.dockedTo = self
+
-        ship.dockedNode = node
+    --self.Resources.ammoUse = 0
-        return true
+    -- a year is 31,556,900 seconds
+    -- for 17 mil water to last ?
+    --  How about 1 water per second?
+    --   195 days
+    self.Resources.fuelUseIdle = 0.04
+    self.Resources.fuelUseMoving = 0.54
+    self.Resources.fuelUseJump = 4000
+    self.Resources.suppliesUse = 0.0013
+    self.Resources.waterUse = 1
+    -- 45k civs = 82+85+119+304 (590) tons food
+    -- 2.5 mil JPs water
+    --   these are per week numbers
+    --    604800 seconds, 4.13 water per second
+    -- 1 ton = 2000 pounds
+    --  1180000 pounds / sec = 1.95 food per second
+    self.Resources.foodUse = 0.099
+    --self.Resources.metalUse = 0.002 -- this # assumes normal repairs, which I'm ignoring for this
+    --self.Resources.oreUse = 0
+    --self.Resources.crewUse = 0
 end
 
-    self.undock = function(self, node)
+return BSG
-        if not self.node[node].docked then return false end
-
-        local ship = self.node[node].docked
-        ship.isDocked = false
-        ship.dockedTo = false
-        ship.dockedNode = false
-        self.node[node].docked = false
-
-        return ship
-    end
-
-    self.moveTo = function() end
-
-    return self
-end

src/ships/viper.lua

@@ -1,20 +1,16 @@
-return function(x, y, rotation)
+local class = require "lib.middleclass"
-    local self = {}
 
+local Ship = require "ships.Ship"
+
+local Viper = class('Viper', Ship)
+
+function Viper:initialize(x, y, rotation)
+    Ship.initialize(self, x, y, rotation)
     self.img = "viper"
+    --offsets
     self.ox = 4.5
     self.oy = 7.5
 
-    self.x = x or 0
-    self.y = y or 0
-    self.rotation = rotation or 0
-
-    self.destination = {
-        x = x or 0,
-        y = y or 0
-    }
-    self.isMoving = false
-
     --[[
     self.selection = {
         w = 9,
@@ -25,24 +21,15 @@ return function(x, y, rotation)
         r = 5
     }
 
-    --self.node = false
+    self.Resources.maxAmmo = 1800 --10 shots per second? 5s per barrel
-    self.isDocked = false
+    self.Resources.maxFuel = 30000 --86400s = 1day, x = 1/2 day's thrust
-    self.dockedTo = false
+    self.Resources.maxCrew = 1
-    self.dockedNode = false
 
-    self.moveTo = function(self, x, y)
+    self.Resources.ammo = math.random(0, 20)
-        if self.isDocked then
+    self.Resources.fuel = math.random(120, 1500)
-            self.dockedTo:undock(self.dockedNode)
+
-        end
+    self.Resources.fuelUseIdle = 0.09
-        self.destination.x = x
+    self.Resources.fuelUseMoving = 0.76
-        self.destination.y = y
-        self.isMoving = true
 end
 
-    self.update = function(self, dt)
+return Viper
-        -- check if moving, check our speed, see how far along the "line" we can go, go there
-        -- if reached destination ... WELL SHIT DEST NEEDS TO BE ABLE TO KNOW IF IS SHIP OR WHATEVER
-    end
-
-    return self
-end