Graceful way to make tables act like values when __indexed? - oop

Question

I'm having this particular problem with my homebrew OO design:
Entity = {}
function Entity:new(o)
o = o or {}
return setmetatable(o, {__index = Entity})
end
function Entity:init() end
function Entity:think() end
function Entity:spawn()
--put in entity pool and begin drawing/logic
self:init()
end
Block = Entity:new{
x = 0,
y = 0,
color = {255, 255, 255, 255},
}
function Block:getPos()
return self.x, self.y
end
--setPos, getColor, setColor etc
function Block:init()
self:setColor(math.random(255), math.random(255), math.random(255))
end
a = Block:new()
a:spawn() --a new block with a random color
--a few seconds later...
b = Block:new()
b:spawn() --all blocks change to new color
The color table is being shared by all prototypes and instances. How can I make that table behave like, say, a string:
a = {table}
b = a
print(b[1]) -->table
a[1] = "object"
print(a[1], b[1]) -->object, table
As opposed to an object:
a = {table}
b = a
print(b[1]) -->table
a[1] = "object"
print(a[1], b[1]) -->object, object
TL;DR: I need to make a new datatype.

Answer 1

There are three ways to fix your problem:
Initialize the Entity.color table during Entity object initialization – put it in Entity:new() function.
Replace the Entity.color table with four variables that will represent its contents – Entity.colorred, Entity.colorgreen, Entity.colorblue, Entity.coloralpha.
Make Entity:setColor() create a new self.color table with new values, instead of modifying the values directly. self.color = {red, green, blue, alpha} instead of self.color[1] = red; self.color[2] = green; self.color[3] = blue; self.color[4] = alpha.

Answer 2

How can I make that table behave like, say, a string:
Your example involves changing Lua variable assignment to copying values rather than references. Even if you could affect such a change in Lua (you can't) it would be an unspeakably terrible idea.
The color table is being shared by all prototypes and instances.
Becase you put it in the prototype (e.g. the "class"), so it's equivalent to a static member in an OOP language, shared by all instances. If you want it to be an instance variable, then it needs to be part of instance construction, not class construction. You need to do the same for x and y as well, or they'll also be shared by all Block instances.
function Block:new()
local instance = { x = 0, y = 0 }
instance:setColor(math.random(255), math.random(255), math.random(255))
return setmetatable(instance, {__index = self})
end
There are enhancements you can make to the constructor, such as passing in parameters (e.g. to initialize x, y, etc.), but the important part is that the instance carries its own state.
Having Entity:spawn simply call init on itself makes no sense. The example code you show suggests it should actually be spawning new instances, but the implementation does not do that.