local Vector = function(x, y)

local Vector
Vector = function(x, y)

		__add = function()
			--TODO implement this
		end

		__add = function(self, other)
			return Vector(self.x + other.x, self.y + other.y)
		end,
		__tostring = function(self)
			return string.format("%d, %d", self.x, self.y)
		end,

		-- TODO: bounds checking

		-- TODO: bounds checking

		-- TODO: bounds checking

		-- TODO: bounds checking

	local core = nil
	if t.core then
		for command, fun in pairs(commands) do
			coreState[command] = function(...)
				return coroutine.yield(fun, {...})
			end

	for command, fun in pairs(commands) do
		coreState[command] = function(...)
			return coroutine.yield(fun, {...})

		core = function()
			t.core(coreState)
		end

		energy = t.energy or 0,

		waitTime = 0,
		energy = t.energy or 1,

		core = core,
		data = core and coreState.data,

		core = t.core and coroutine.create(t.core),
		data = t.core and coreState.data,
		returnValue = coreState,

	function intermediate:resolve(x, y)

	function intermediate:resolve(pos)

		for _, cell in self.cells[x][y].cells do

		for _, cell in ipairs(self.cells[pos.x][pos.y].cells) do

		return result or self:getCell(x, y)

		return result or self:getCell(pos)

	function intermediate:undo(x, y)
		local cell = self.cells[x][y]

	function intermediate:undo(pos)
		local cell = self.cells[pos.x][pos.y]

			action.undo()

			action()

	function intermediate:setCell(x, y, to, undo)

	function intermediate:setCell(pos, to, undo)
		-- TODO: bounds checking

			table.insert(self.cells[x][y].actions, undo)

			table.insert(self.cells[pos.x][pos.y].actions, undo)

		table.insert(self.cells[x][y].cells, to)

		table.insert(self.cells[pos.x][pos.y].cells, to)

	function intermediate:getCell(x, y)
		return self.cells[x][y].original

	function intermediate:getCell(pos)
		-- TODO: bounds checking
		return self.cells[pos.x][pos.y].original

				cells = {},

				cells = {cell},

		-- TODO: bounds checking

		-- TODO: bounds checking

	end
	function arena:spawn(x, y, name, core)
		self:setCell(Vector(x, y), Cell{core=core, owner=name})

					cell.waitTime = cell.waitTime + 1
					if cell.core.waitTime == 0 then
						local _, command, args = coroutine.resume(cell.core, cell.returnValue)
						-- Validate that the command is not a malicious.
						local valid = false
						for _, fun in pairs(commands) do
							if fun == command then
								valid = true

					cell.waitTime = cell.waitTime - 1
					if cell.waitTime <= 0 then
						if coroutine.status(cell.core) == "dead" then
							-- TODO: kill core
						else
							local _, command, args = coroutine.resume(cell.core, cell.returnValue)
							-- Validate that the command is not a malicious.
							local valid = false
							for _, fun in pairs(commands) do
								if fun == command then
									valid = true
								end

						end
						if valid then
							cell.waitTime, cell.returnValue = command(cell, Vector(x, y), intermediate, table.unpack(args))
							cell.waitTime = cell.waitTime * 100 / cell.energy

							if valid then
								cell.waitTime, cell.returnValue = command(cell, Vector(x, y), intermediate, table.unpack(args))
								cell.waitTime = cell.waitTime * 10 / cell.energy
							end

					if not intermediate:resolve(x, y) then

					if not intermediate:resolve(Vector(x, y)) then

						intermediate:undo(x, y)

						intermediate:undo(Vector(x, y))

				self:setCell(Vector(x, y), intermediate:resolve(x, y))

				local pos = Vector(x, y)
				self:setCell(pos, intermediate:resolve(pos))

	function Arena:draw()

	function arena:draw()

			for _ = 1, width*7 do

			for _ = 1, width*7-9 do

				io.write(string.format("%-5s", tostring(owner):sub(5)))

				--io.write(string.format("%.5s", tostring(owner):sub(5)))
				io.write(string.format("%-5s", owner or "                    "):sub(1, 5))
				io.write("|")
			end
			io.write("\n|")
			for x = 1, width do
				local core = self:getCell(Vector(x, y)).core
				io.write(core and "Core " or "     ")

			io.write("\n")
			for _ = 1, width*7 do
				io.write("-")

			io.write("\n|")
			for x = 1, width do
				local cell = self:getCell(Vector(x, y))
				io.write(cell.core and string.format("%-5d", cell.energy) or "     ")
				io.write("|")

		end
		for _ = 1, width*7-9 do
			io.write("-")

		io.write("\n")

local Arena = require "arena"
local arena = Arena(10, 5)
arena:spawn(4, 4, "Jummit", function(core)
	while true do
		core.move("right")
	end
end)
arena:spawn(7, 4, "Ulf", function() end)
while true do
	arena:simulate()
	arena:draw()
	os.execute("sleep 0.01")
end