LÖVE

pgimeno wrote: childonline, I'm curious about what tool you used to save this png.

ivan wrote: - Don't use a huge bitmap when the background is an array of dots
- The current way you're using 'setmetatable' doesn't look correct -
sometimes you're using metabales and sometimes you're passing the 'self' reference manually.
Generally you need 1 table for the interface, one for the metatable and one for each instance,
You don't need metatables unless there is inheritance involved
- Don't clamp vectors along the x/y axis separately, clamp them based on length
- math.atan2 accepts Y as the first parameter
- use locals for temporary variables (ex: "vehicle.lua:232") - "strict.lua" can help you pinpoint these
- I didn't know the demo was interactive without looking at the code,
Either way you want to use abstraction for your 'vehicle' class so that it's not dependent on love2d's mouse

ivan wrote: - mention Reynolds or Buckland in the comments

Sir_Silver wrote: Very cool, it would be nice though if you talked a little bit about exactly whats goin' on here

pgimeno wrote:Sometimes it may be convenient to swap them. In particular, when you use an angle convention where north is 0° and angle increases clockwise

childonline wrote:great feedback, thanks! i will definitely start using strict.lua more often. Could you please be more specific regarding what i'm doing wrong with the metatables/self-references (examples of best practices /bad practices would be most helpful)

local oo = {}

local meta = {}
local rmeta = {}

-- Creates a new class
function oo.class()
  local c = {}
  local mt = { __index = c }
  meta[c] = mt
  rmeta[mt] = c
  return c
end

-- Creates a subclass
function oo.subclass(p)
  assert(meta[p], "undefined parent class")
  local c = oo.class()
  return setmetatable(c, meta[p])
end

-- Creates a new instance
function oo.instance(c)
  assert(meta[c], "undefined class")
  return setmetatable({}, meta[c])
end

-- Gets the class of an instance
function oo.getclass(i)
  local mt = getmetatable(i)
  return rmeta[mt]
end

-- Inheritance:

local oo = require 'oo'

local Fruit = oo.class()
Fruit.sweetness_threshold = 5 -- sort of like "static"
function Fruit:initialize(sweetness)
  self.sweetness = sweetness
end
function Fruit:isSweet()
  return self.sweetness > Fruit.sweetness_threshold
end

local Lemon = oo.subclass(Fruit) -- subclassing
function Lemon:initialize()
  Fruit.initialize(self, 1) -- manually invoking the superclass' initializer
end

local lemon = oo.instance(Lemon)
lemon:initialize()
print(lemon:isSweet()) -- false

to be fair i wrote this demo after reading this excellent post: http://natureofcode.com/book/chapter-6- ... us-agents/, i assume the article is strongly based on Reynolds/Bucklands original code