pico-8 cartridge // http://www.pico-8.com
version 41
__lua__

-- vacation (18+)
-- kistaro windrider

--------------------------------
-- copyright (C) 2024 kistaro windrider
--
-- this program is free software; you can redistribute it and/or modify
-- it under the terms of the gnu general public license as published by
-- the free software foundation; either version 2 of the license, or
-- (at your option) any later version.
--
-- this program is distributed in the hope that it will be useful,
-- but without any warranty; without even the implied warranty of
-- merchantability or fitness for a particular purpose.  see the
-- gnu general public license for more details.
--------------------------------

-- tab 0: library
-- tab 1: p8 entry points
-- tabs 2...F: actual code

function usplit(str)
 return unpack(split(str))
end
function csv(s)
 local ret = split(s, "\n")
 for i, v in ipairs(ret) do
  ret[i] = type(v) == "string" and split(v) or { v }
 end
 return ret
end

-- generate standard "overlay"
-- constructor for type tt.
-- if more is defined, generated
-- new calls more(ret) after
-- ret is definitely not nil
-- before calling setmetatable.
-- use to initialize mutables.
--
-- if there was a previous new,
-- it is invoked on the new
-- object *after* more, because
-- this works better with the
-- `more` impls i use.
function mknew(tt, more)
 local mt, oldnew = { __index = tt }, tt.new
 tt.new = function(ret)
  if (not ret) ret = {}
  if (more) more(ret)
  if (oldnew) oldnew(ret)
  setmetatable(ret, mt)
  return ret
 end
end

-- if t[mname] is a thing,
-- invoke it as a method. else,
-- try each object in t
function outer_or_each_opt(t, mname)
 local fun = t[mname]
 if fun then
  fun(t)
  return
 end
 foreach(t, function(o)
  local f = o[mname]
  if(f) f(o)
 end)
end

-------------------------------
-- linked_list
-------------------------------
-- intrusive singly-linked list.
-- cannot be nested!
linked_list = {is_linked_list=true}
mknew(linked_list, function(x)
  x.next=nil
  x.tail=x
 end)

function linked_list:push_back(x)
 self.tail.next = x
 self.tail = x
end

function linked_list:push_front(x)
 if (not self.next) self.tail = x
 x.next = self.next
 self.next = x
end

-- vore eats another linked list
-- by appending its contents.
-- the ingested linked is empty.
function linked_list:vore(x)
 if (not x.next) return
 self.tail.next = x.next
 self.tail = x.tail
 x.next = nil
 x.tail = x
end

-- strip calls f(x) for each
-- node, removing each node for
-- which f(x) returns true. it
-- returns the new tail; nil
-- if the list is now empty.
function linked_list:strip(f)
 local p, n = self, self.next
 while n do
  if f(n) then
   p.next = n.next
  else
   p = n
  end
  n = n.next
 end
 self.tail = p
 return p
end

-- optimized special case -
-- could be done with strip but
-- this avoids extra function
-- calls and comparisions since
-- draw isn't allowed to kill
-- the item
function linked_list:draw()
 local n = self.next
 while n do
  n:draw()
  n = n.next
 end
end


function linked_list:pop_front()
 local ret = self.next
 if (not ret) return
 self.next = ret.next
 if (not ret.next) ret.tail = nil
 return ret
end

-------------------------------
-- view
-------------------------------
-- composits drawable items.
-- add items to .views to
-- composit them. x and y are
-- relative reverse camera
-- offsets. drawable items will
-- observe appropriate incoming
-- camera and clip state.
-- clipping respects existing
-- clipping so stacked views
-- intersect.
-------------------------------
view = {
 x=0,
 y=0,
 w=128,
 h=128,
}
mknew(view, function(x)
 if (not x.views) x.views = {}
end)

function view.of(subviews)
 return view.new{views=subviews}
end

function view:update()
 outer_or_each_opt(self.views, "update")
end

function view:draw()
 local oldcam, oldclip = $0x5f28, $0x5f20
 poke2(0x5f28, %0x5f28-self.x)
 poke2(0x5f2a, %0x5f2a-self.y)
 clip(-%0x5f28, -%0x5f2a, self.w, self.h, true)
 outer_or_each_opt(self.views, "draw")
 poke4(0x5f20, oldclip)
 poke4(0x5f28, oldcam)
end

-- draws opaque rectangles.
-- default bg is equivalent to
-- clip-aware cls.
-- restores prior fill pattern.
bg = {
 x=0,y=0,w=128,h=128,fp=0,c=0
}
mknew(bg)

function bg:draw()
 local oldfp=fillp(self.fp)
 rectfill(self.x,self.y,self.x+self.w,self.y+self.h,self.c)
 fillp(oldfp)
end

-------------------------------
-- animator
-------------------------------
-- animator is a linked list of
-- temporary drawables. a
-- temporary drawable is dropped
-- when its :update returns
-- a non-false value.
-------------------------------
animator = linked_list.new{}
mknew(animator)

function animator:update()
 self:strip(function(x) x:update() end)
end

-->8
-- setup and p8 entry points

function _init()
end

function _update()
end

function _draw()
end

-->8
-- text rendering

-->8
-- sprite rendering

-->8
-- consent screens

-->8
-- title screen

-->8
-- zonk mode

-->8
-- awakener

-->8
-- game mode