I based this post on an article by nerdyteachers

NB: to make the code easier to read, the examples shown here contain spaces, which is not recommended in Pico 8 to save space.

How to write a class~ish

We will start with a simple class:

function monster(x, y, sp)
  m={x=x,y=y,sp=sp or 0}

  function m.update(s)
    s.x+=1
  end

  function m.draw(s)
    spr(s.s,s.x,s.y)
  end

  return m

end 

The word class is a bit of a misnomer, because in reality monster is just a function.
This function constructs the class instance, using a table.

Attributs

Inside the table You will write the attributes of your class:

function monster(x,y)
  p={x=x,y=x}
...

Note that the function's parameters act as constructors, allowing arguments to be passed to the class.

Methods

There are two ways to write a method with a : or with a ..

The first way is the more usual in Lua, because in this way you can omit the parameter reserved for the class instance.
The parameter self automatically exists in your function without declaration.

The other way ask you to declare, in first place, a parameter reserved for the class instance.
In short, function m:draw() can be written like that function m.draw(self).

We will prefer the second way because it's make economize tokens using this solution.

For instance, the method draw will look like that

function m.draw(s)
  spr(s.sp,s.x,s.y)
end

Using the class

To create an instance of the class, you just need to use the function mo=monster(64,64,0)

And to call a method is also simple mo:update
Note that using : as a link between the instance and the method, is a way of avoiding re-passing the instance to the method. Simply put, writing mo:draw() is a way to avoid writing mo.draw(mo)

Here is an example of code using the class monster

function _init()
  mo=monster(64, 64, 0)
end

function _update()
 mo:update()
end

function _draw()
 cls()
 mo:draw()
end

Inheritance~ish

Here is the spider class that inherits from monster

function spider(x, y)
  spi=monster(x,y,0)
  return spi
end

It's yet really basic, but it works.

New attribute

If you want to add a new attribute you can proceed like it was a table, (because it's a table)

function spider(x, y)
  spi=monster(x,y,0)
  spi.hp=50	

  return spi

end

New method

To add another method, you just do as you did before.

function spider(x, y)
  spi=monster(x,y,0)
  spi.hp=50

  function spi.damage(s,d)
    s.hp-=d
  end
  return spi
end

Overwrite a method

The most "complex" task is the overwriting.

Before, you need to understand that a function is store in memory, in the same way that a variable.
For instance, if I want, I can store print in a variable a and use a as print.

a = print
function _draw()
  a("This is a test.", 5, 10)
end

It works because when you write a=print, a contains a reference to the print function.

Now that we are aware of that, we can proceed to overwriting.

If I want to add a behavior to my spider on update, in addition to the existing code already inside the update method from monster, I will proceed like this:

...
spi.supspiupdate=spi.update
function spi.update(s)
  spi.supspiupdate(s)
  s.y +=1
end	
...

First you store the update method from the ancestor inside a variable here spi.supspiupdate
This variable need to be unique inside your class (including parent and child).

Then you can overwrite your function.
You can use the variable with the reference of the ancestor method, inside the new method.
Note that we pass directly the instance to the function (s passed as argument to s.supspiupdate).

Like this, you can have almost every feature expected by object-oriented programming.

function monster(x, y, sp)
  m={x=x,y=y,sp=sp or 0}

  function m.update(s)
    s.x+=1
  end

  function m.draw(s)
    spr(s.s,s.x,s.y)
  end

  return m

end

function spider(x, y)
  spi=monster(x,y,0)
  spi.hp=50

  function spi.damage(s,d)
    spi.hp-=d
  end

  spi.supspiupdate=spi.update
  function spi.update(s)
    spi.supspiupdate(s)
    s.y +=1
  end

  return spi
end

function _init()
  sp=spider(64, 64)
end

function _update()
 sp:update()
end

function _draw()
 cls()
 sp:draw()
end