Compare commits
3 Commits
main
...
color_theo
Author | SHA1 | Date | |
---|---|---|---|
5634fcf4a4 | |||
447a1bedd0 | |||
0f7c7a810b |
2
.gitignore
vendored
2
.gitignore
vendored
@ -1,2 +0,0 @@
|
||||
.DS_Store
|
||||
.vscode/settings.json
|
@ -1,244 +0,0 @@
|
||||
pico-8 cartridge // http://www.pico-8.com
|
||||
version 41
|
||||
__lua__
|
||||
|
||||
-- vacuum gambit automatic brake test
|
||||
-- by kistaro windrider
|
||||
|
||||
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
|
||||
|
||||
function _init()
|
||||
pal(1,129,1)
|
||||
the_ship = ship.new()
|
||||
constraints:setup()
|
||||
slomo = 1
|
||||
sloc = 0
|
||||
reroll()
|
||||
end
|
||||
|
||||
function reroll()
|
||||
frames=0
|
||||
sloc=0
|
||||
the_ship:reroll()
|
||||
end
|
||||
|
||||
function _update60()
|
||||
if (btnp(4)) reroll()
|
||||
if (btnp(5)) constraints:cycle()
|
||||
if (btnp(3)) slomo <<= 1
|
||||
if (btnp(2)) slomo >>= 1
|
||||
slomo = (slomo < 1) and 1 or (slomo > 8192) and 8192 or slomo
|
||||
sloc += 1
|
||||
if sloc >= slomo then
|
||||
frames += 1
|
||||
the_ship:update()
|
||||
sloc=0
|
||||
end
|
||||
end
|
||||
|
||||
function _draw()
|
||||
cls(1)
|
||||
constraints:draw()
|
||||
the_ship:draw()
|
||||
print("frames: " .. frames, 4, 64, 7)
|
||||
print("speed: 1/" .. slomo, 8, 70, 7)
|
||||
|
||||
print("thrust: ".. actual_t, 4, 80, 7)
|
||||
meter(80, 80, 128, 84, actual_t/the_ship.thrust/2)
|
||||
print("dx: ".. the_ship.dx, 20, 86, 7)
|
||||
meter(80, 86, 128, 90, the_ship.dx/the_ship.maxspd/2)
|
||||
print("x: "..the_ship.x, 24, 92, 7)
|
||||
print("bx: "..gbx, 20, 98, 7)
|
||||
|
||||
print("xmin:"..tostr(constraints.xmin), 12, 108, 7)
|
||||
print("xmax:"..tostr(constraints.xmax), 12, 114, 7)
|
||||
end
|
||||
|
||||
function meter(x0, y0, x1, y1, frac)
|
||||
local c = 11
|
||||
if frac < 0 then
|
||||
frac = -frac
|
||||
c = 8
|
||||
end
|
||||
local range = x1-x0
|
||||
local midpoint = x0 + (range/2)
|
||||
rectfill(x0, y0-1, x0, y1+1, 13)
|
||||
rectfill(midpoint, y0-1, midpoint, y1 + 1, 13)
|
||||
local width = range * frac
|
||||
if (width ~= 0) rectfill(x0, y0, x0 + width, y1, c)
|
||||
end
|
||||
|
||||
-->8
|
||||
-- ship
|
||||
|
||||
ship = {
|
||||
maxspd=4,
|
||||
thrust=0.25,
|
||||
drag=0.0625,
|
||||
y=32,
|
||||
}
|
||||
mknew(ship)
|
||||
|
||||
function ship:reroll()
|
||||
self.x=rnd(128)
|
||||
self.dx=rnd(2*self.maxspd)-self.maxspd
|
||||
end
|
||||
|
||||
function ship:draw()
|
||||
if self.x < -7 then
|
||||
spr(2, 0, self.y-7)
|
||||
spr(2, 0, self.y+8)
|
||||
elseif self.x > 127 then
|
||||
spr(2, 120, self.y-7, 1, 1, true)
|
||||
spr(2, 120, self.y+8, 1, 1, true)
|
||||
else
|
||||
spr(1,self.x,self.y)
|
||||
end
|
||||
|
||||
--if (self.dx == 0) return
|
||||
local bd, f = brake_dist(self.dx, self.thrust + self.drag)
|
||||
gbx = self.x+bd
|
||||
spr(3, gbx-2,self.y-2)
|
||||
print(tostr(f), gbx-2, self.y - 8, 14)
|
||||
end
|
||||
|
||||
function calc_velocity(v0, t, vmax, drag)
|
||||
v0 = mid(v0 + t, vmax, -vmax)
|
||||
return v0 - mid(drag, -drag, v0)
|
||||
end
|
||||
|
||||
function ship:update()
|
||||
local t = btn(0) and -1 or btn(1) and 1 or 0
|
||||
t *= self.thrust
|
||||
t = constraints:constrain(self, t)
|
||||
-- t = constraints:constrain(self, t)
|
||||
-- t = constraints:constrain(self, t)
|
||||
local s = calc_velocity(self.dx, t, self.maxspd, self.drag)
|
||||
|
||||
self.x += s
|
||||
self.dx = s
|
||||
actual_t = t
|
||||
end
|
||||
|
||||
-->8
|
||||
-- constraints
|
||||
|
||||
constraints = {
|
||||
ymin=20,
|
||||
ymax=52,
|
||||
color=10
|
||||
}
|
||||
|
||||
function constraints:constrain(s, want)
|
||||
self.color=10
|
||||
if (not self.xmin) return want
|
||||
|
||||
-- bmx: brake max
|
||||
local v1, bmx = calc_velocity(s.dx, want, s.maxspd, s.drag), s.thrust + s.drag
|
||||
local bd, bf = brake_dist(v1, bmx)
|
||||
local bx, txm = s.x + bd + v1, self.xmax
|
||||
if bx < self.xmin then
|
||||
-- predicted brake point left
|
||||
-- of xmin; apply max reverse
|
||||
-- thrust, treat xmin as our
|
||||
-- max target, and handle
|
||||
-- overbraking by coalescing
|
||||
-- with past +xmax case
|
||||
self.color = 9
|
||||
want = s.thrust
|
||||
txm = self.xmin
|
||||
v1 = calc_velocity(s.dx, want, s.maxspd, s.drag)
|
||||
bd, bf = brake_dist(v1, bmx)
|
||||
bx = bd + s.x + v1
|
||||
end
|
||||
if (bx <= txm) return want
|
||||
self.color = 8
|
||||
local overage = bx - txm
|
||||
want -= overage/max(bf,1)
|
||||
if (want < -s.thrust) want = -s.thrust
|
||||
return want
|
||||
end
|
||||
|
||||
function brake_dist(v0, brake_max)
|
||||
local tri_frames = abs(v0\brake_max)
|
||||
local chunks = tri_frames * (tri_frames - 1) >> 1
|
||||
local chunk_zone = chunks * brake_max
|
||||
local overage = abs(v0) - tri_frames * brake_max
|
||||
return (chunk_zone + overage * (tri_frames + 1)) * sgn(v0), (overage > 0) and tri_frames + 1 or tri_frames
|
||||
end
|
||||
|
||||
function constraints:cycle()
|
||||
if self.ctype=="bounds" then
|
||||
self.ctype="point"
|
||||
elseif self.ctype=="point" then
|
||||
self.ctype="off"
|
||||
else
|
||||
self.ctype="bounds"
|
||||
end
|
||||
self:setup()
|
||||
end
|
||||
|
||||
function constraints:setup()
|
||||
if self.ctype=="point" then
|
||||
self.xmin = 64
|
||||
self.xmax = 64
|
||||
elseif self.ctype=="bounds" then
|
||||
self.xmin = 32
|
||||
self.xmax = 96
|
||||
else
|
||||
self.xmin = nil
|
||||
self.xmax = nil
|
||||
end
|
||||
end
|
||||
|
||||
function constraints:draw()
|
||||
if (not self.xmin) return
|
||||
rect(self.xmin, self.ymin, self.xmax, self.ymax, self.color)
|
||||
end
|
||||
|
||||
-->8
|
||||
-- fx
|
||||
|
||||
-- todo: spark ring buffer
|
||||
|
||||
__gfx__
|
||||
000000008000000000080000a000a000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
|
||||
00000000006666000080000009090000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
|
||||
00000000067777600800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
|
||||
00000000675555758008888009090000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
|
||||
000000006750007508000000a000a000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
|
||||
00000000067777500080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
|
||||
00000000005555000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
|
@ -1 +0,0 @@
|
||||
Trans rights.
|
@ -75,7 +75,7 @@ function updategame()
|
||||
edeaths = {}
|
||||
for ip, ps in ipairs(pships) do
|
||||
for ie, eb in ipairs(ebullets) do
|
||||
if collides(hurtbox(ps), hurtbox(eb)) then
|
||||
if collides(hurtobx(ps), hurtbox(eb)) then
|
||||
if (eb:hitship(ps)) add(edeaths, ie)
|
||||
if ps:hitbullet(eb) then
|
||||
add(pdeaths, ip)
|
||||
|
2162
last_tyrianlike.p8
2162
last_tyrianlike.p8
File diff suppressed because it is too large
Load Diff
356
old_readme.md
356
old_readme.md
@ -1,356 +0,0 @@
|
||||
This file contains text that used to be in the cartridge itself, but
|
||||
I'm getting increasingly anxious about cartridge space so I'm moving
|
||||
it out ot a separate file.
|
||||
|
||||
---
|
||||
|
||||
main loop sequence
|
||||
==================
|
||||
1. level_frame
|
||||
2. events
|
||||
3. merge new_events into events
|
||||
4. update bg intangibles
|
||||
5. move ships (player first)
|
||||
6. move bullets (player first)
|
||||
7. calculate collisions
|
||||
1. pship on eship
|
||||
2. ebullet on pship
|
||||
3. pbullet on eship
|
||||
8. update fg intangibles
|
||||
9. check for end of level
|
||||
|
||||
draw order
|
||||
----------
|
||||
bottom to top:
|
||||
1. intangibles_bg
|
||||
2. player bullets
|
||||
3. player ships
|
||||
4. enemy ships
|
||||
5. enemy bullets
|
||||
6. intangibles_fg
|
||||
|
||||
notes
|
||||
-----
|
||||
intangibles_fg move()s after
|
||||
all collisions and other moves
|
||||
are processed. if an intangible
|
||||
is added to the list as a result
|
||||
of a collision or move, it will
|
||||
itself be move()d before it is
|
||||
drawn.
|
||||
|
||||
data-driven items
|
||||
=================
|
||||
guns and bullets both allow the
|
||||
most common behaviors to be
|
||||
expressed with data alone.
|
||||
ships only need a movement
|
||||
algorithm expressed.
|
||||
|
||||
guns
|
||||
----
|
||||
* t - metatable for bullet type.
|
||||
fired once in the bullet's
|
||||
default direction per shot.
|
||||
* enemy - if true, fired bullets
|
||||
are flagged as enemy bullets.
|
||||
* icon - sprite index of an
|
||||
8x8 sprite to display in the
|
||||
hud when the player has this
|
||||
gun. default is 20, a generic
|
||||
crosshair bullseye thing.
|
||||
* cooldown - min frames between
|
||||
shots.
|
||||
* ammo, maxammo - permitted
|
||||
number of shots. 0 is empty
|
||||
and unfireable. maxammo = 0
|
||||
will cause a divide by zero
|
||||
so don't do that. if nil,
|
||||
ammo is infinite.
|
||||
|
||||
default guns manage ammo and
|
||||
cooldown in shoot, then call
|
||||
actually_shoot to create the
|
||||
projectile. override only
|
||||
actually_shoot to change
|
||||
projectile logic while keeping
|
||||
cooldown and ammo logic.
|
||||
|
||||
bullets
|
||||
-------
|
||||
* dx, dy - movement per frame.
|
||||
player bullets use -dy
|
||||
instead.
|
||||
* enemyspd - multiplier for dx
|
||||
and dy on enemy bullets.
|
||||
default is 0.5, making enemy
|
||||
shots much easier to dodge
|
||||
* damage - damage per hit;
|
||||
used by ships
|
||||
* sprite - sprite index.
|
||||
* x_off, y_off - renamed for
|
||||
the next two vars. may revert
|
||||
* center_off_x - the horizontal
|
||||
centerpoint of the bullet,
|
||||
for positioning when firing.
|
||||
assume a pixel's coordinates
|
||||
refer to the upper left corner
|
||||
of the pixel; the center of
|
||||
a 2-width bullet with an
|
||||
upper left corner at 0 is 1,
|
||||
not 0.5.
|
||||
* top_off_y, bottom_off_y -
|
||||
also for positioning when
|
||||
firing. positive distance from
|
||||
top or bottom edge to image.
|
||||
top_off_y will usually be 0,
|
||||
bottom_off_y will not be when
|
||||
bullets are smaller than
|
||||
the sprite box.
|
||||
* width, height - measured in
|
||||
full sprites (8x8 boxes), not
|
||||
pixels. used for drawing.
|
||||
|
||||
bullets despawn when above or
|
||||
below the screen (player or
|
||||
enemy bullets, respectively).
|
||||
|
||||
by default, bullets despawn
|
||||
when they hit something.
|
||||
override hitship to change this.
|
||||
|
||||
ships
|
||||
____
|
||||
|
||||
ships move by calculating
|
||||
momentum, then offsetting their
|
||||
position by that momentum, then
|
||||
clamping their position to the
|
||||
screen (horizontally only for
|
||||
ships that autoscroll). ships
|
||||
that autoscroll (slip==true)
|
||||
then slide down by scrollspeed.
|
||||
fractional coordinates are ok.
|
||||
after movement, ships lose
|
||||
momentum (ship.drag along each
|
||||
axis). abs(momentum) can't
|
||||
exceed ship.maxspeed.
|
||||
|
||||
ships gain momentum by acting
|
||||
like a player pushing buttons.
|
||||
the player ship actually reads
|
||||
buttons for this.
|
||||
|
||||
act -- returns new acceleration:
|
||||
dx, dy, shoot_spec, shoot_main.
|
||||
dx and dy are change in momentum
|
||||
in px/frame. this is controls
|
||||
only -- friction is handled in
|
||||
ship:move (`drag` value).
|
||||
|
||||
ships hitting another ship take
|
||||
1 damage per frame of overlap.
|
||||
ships hitting a bullet check
|
||||
bullet.damage to find out how
|
||||
much damage they take. damage
|
||||
is applied to shields, then hp.
|
||||
damaged ships flash briefly -
|
||||
blue (12) if all damage was
|
||||
shielded, white (7) if hp was
|
||||
damaged. a ship that then has 0
|
||||
or less hp calls self:die() and
|
||||
tells the main game loop to
|
||||
remove it.
|
||||
|
||||
shieldcooldown is the interval
|
||||
between restoring shield points.
|
||||
shieldpenalty is the delay
|
||||
before restoring points after
|
||||
any damage, reset to this value
|
||||
on every damaging hit (whether
|
||||
it is absorbed by the shield or
|
||||
not) -- shield behaves like
|
||||
halo and other shooters in its
|
||||
heritage, where it recovers if
|
||||
you avoid damage for a while.
|
||||
not that there is any safe cover
|
||||
in this kind of game.
|
||||
|
||||
ships do not repair hp on their
|
||||
own. negative-damage bullets
|
||||
are treated as 0, but a bullet
|
||||
can choose to repair the ship
|
||||
it hits in its own hitship
|
||||
method, or otherwise edit it
|
||||
(changing weapons, refilling
|
||||
weapon ammo). powerups are
|
||||
therefore a kind of bullet.
|
||||
|
||||
levels
|
||||
======
|
||||
|
||||
a level is a table mapping
|
||||
effective frame number to
|
||||
functions. when a level starts,
|
||||
it sets lframe ("level frame")
|
||||
and distance to 0.
|
||||
|
||||
every frame, level_frame
|
||||
increments lframe by 0x0.0001.
|
||||
then if the level is not frozen,
|
||||
it increments distance by 1.0
|
||||
and runs the function in the
|
||||
level table for exactly that
|
||||
frame number (if any). distance
|
||||
is therefore "nonfrozen frames",
|
||||
and is used to trigger level
|
||||
progress. lframe always
|
||||
increments. ships are encouraged
|
||||
to use lframe to control
|
||||
animation and movement, and may
|
||||
use distance to react to level
|
||||
progress separately from overall
|
||||
time. remember to multiply
|
||||
lframe-related stuff by 0x0001.
|
||||
|
||||
a special sentinel value, eol,
|
||||
marks the end of the level.
|
||||
(the level engine doesn't know
|
||||
when it's out of events, so
|
||||
without eol, the level will
|
||||
simply have no events forever.)
|
||||
when it finds eol, level_frame
|
||||
throws away the current level
|
||||
and tells the main loop that it
|
||||
might be done. the main loop
|
||||
agrees the level is over and the
|
||||
player has won when the level
|
||||
has reached eol and there are
|
||||
no more enemy ships, enemy
|
||||
bullets, or background events
|
||||
remaining. player ships, player
|
||||
bullets, and intangibles are
|
||||
not counted.
|
||||
|
||||
level freezing
|
||||
--------------
|
||||
the level is frozen when the
|
||||
global value freeze > 0.
|
||||
generally, something intending
|
||||
to block level progress (a
|
||||
miniboss, a minigame, etc.)
|
||||
increments freeze and prepares
|
||||
some means of decrementing it
|
||||
when it no longer wants to block
|
||||
level progress.
|
||||
|
||||
most commonly, we want to block
|
||||
until some specific ship or
|
||||
group of ships has died. for
|
||||
these ships, override ship:die
|
||||
to decrement freeze. make sure
|
||||
to set ship.dead in any new
|
||||
ship:die method so anything else
|
||||
looking at it can recognize
|
||||
the ship as dead.
|
||||
|
||||
for anything else, you probably
|
||||
want an event to figure out when
|
||||
to unfreeze.
|
||||
|
||||
levels start at 1
|
||||
-----------------
|
||||
|
||||
distance is initialized to 0
|
||||
but gets incremented before the
|
||||
first time the engine looks for
|
||||
events. therefore, the first
|
||||
frame of the level executes
|
||||
level[1]. since levelframe
|
||||
executes before anything else,
|
||||
level[1] sets up the first frame
|
||||
drawn in the level. the player
|
||||
does not see a blank world
|
||||
before level[1] runs.
|
||||
level[1] can therefore be used
|
||||
to reconfigure the player ship,
|
||||
set up backgrounds, start music,
|
||||
kick off some kind of fade-in
|
||||
animation, etc.
|
||||
|
||||
|
||||
events
|
||||
======
|
||||
the global list "events" stores
|
||||
0-argument functions which are
|
||||
called every frame. if they
|
||||
return true, they are removed
|
||||
from the list and not run again;
|
||||
if they return false, they stay
|
||||
and will be called in later
|
||||
frames. the level does not end
|
||||
while the events table is
|
||||
nonempty.
|
||||
|
||||
events are most commonly used
|
||||
to set up something for later
|
||||
(for example, blip uses an event
|
||||
to remove the fx_pallete from
|
||||
the flashing ship when the blip
|
||||
expires), but can also be used
|
||||
to implement a "level within a
|
||||
level" that does something
|
||||
complicated until it's done. if
|
||||
you froze the level when
|
||||
creating the event, remember
|
||||
to thaw it (freeze -= 1) on all
|
||||
paths that return true.
|
||||
|
||||
to do complex stuff in events,
|
||||
use a closure or a metatable
|
||||
that specifies __call.
|
||||
|
||||
to avoid editing the events
|
||||
list while it is being iterated,
|
||||
events that create new events
|
||||
must add those events to
|
||||
new_events rather than events.
|
||||
new_events is only valid during
|
||||
the "event execution" stage, so
|
||||
events created at any other time
|
||||
must go directly on events
|
||||
without using new_events.
|
||||
|
||||
intangibles
|
||||
===========
|
||||
|
||||
the intangibles_fg and
|
||||
intangibles_bg lists contain
|
||||
items with :move and :draw.
|
||||
like ships and bullets, they
|
||||
move during _update60 and
|
||||
draw during _draw. they are
|
||||
not checked for collisions.
|
||||
|
||||
intangibles_bg moves/draws
|
||||
before anything else moves or
|
||||
draws. intangibles_fg
|
||||
moves/draws last. this controls
|
||||
whether your intangible object
|
||||
draws in front of or behind
|
||||
other stuff. you probably want
|
||||
intangibles_bg for decorative
|
||||
elements and intangibles_fg
|
||||
for explosions, score popups,
|
||||
etc.
|
||||
|
||||
there's no scrolling background
|
||||
engine but intangibles_bg could
|
||||
be used to create one, including
|
||||
using the map (otherwise unused
|
||||
in this engine) for the purpose.
|
||||
|
||||
intangibles do not prevent the
|
||||
level from ending. like bullets
|
||||
and ships, if :move returns
|
||||
true, they are dropped.
|
@ -1,87 +0,0 @@
|
||||
pico-8 cartridge // http://www.pico-8.com
|
||||
version 42
|
||||
__lua__
|
||||
-- vacuum gambit
|
||||
-- by kistaro windrider
|
||||
|
||||
function _draw()
|
||||
cls()
|
||||
draw_hud_placeholder()
|
||||
draw_weap_opt(0,0,frame_col(item==1),1,"hull","\n +1\n max\nhealth")
|
||||
draw_weap_opt(56,0,frame_col(item==2),2,"vulc"," rate\n\n faster\n firing\n rate")
|
||||
draw_rearm(frame_col(item<0))
|
||||
end
|
||||
|
||||
function _init()
|
||||
item=1
|
||||
bfm=1
|
||||
end
|
||||
|
||||
function _update()
|
||||
if (btn(3) and item > 0 or btn(2) and item < 0) item = -item
|
||||
if (btn(0)) item = 1
|
||||
if (btn(1)) item = 2
|
||||
if (btn() & 0xF ~= 0) and bfm >= 10 or bfm >= 30 then
|
||||
bfm = 1
|
||||
else
|
||||
bfm += 1
|
||||
end
|
||||
end
|
||||
|
||||
function draw_hud_placeholder()
|
||||
rectfill(112, 0, 127, 127,0x56)
|
||||
rect(112,0,127,127,7)
|
||||
line(127,1,127,127,5)
|
||||
line(113,127)
|
||||
end
|
||||
|
||||
function glow_box(x0, y0, x1, y1, c, cf)
|
||||
rect(x0, y0, x1, y1, c[1])
|
||||
rect(x0+1, y0+1, x1-1, y1-1, c[2])
|
||||
rect(x0+2, y0+2, x1-2, y1-2, c[1])
|
||||
if cf then
|
||||
-- todo: animate "dot crawl" background
|
||||
fillp(…)
|
||||
rectfill(x0+3, y0+3, x1-3, y1-3, cf)
|
||||
fillp()
|
||||
end
|
||||
end
|
||||
|
||||
function frame_col(hot)
|
||||
if (not hot) return {4,10}
|
||||
if (bfm<=16) return {14,7}
|
||||
return {2,8}
|
||||
end
|
||||
|
||||
function draw_weap_opt(x, y, c, s, hdr, body)
|
||||
camera(-x,-y)
|
||||
glow_box(0,0,55,100,c,1)
|
||||
spr(s,5, 5)
|
||||
print(hdr, 13, 8, 7)
|
||||
print(body, 5, 15, 6)
|
||||
camera()
|
||||
end
|
||||
|
||||
function draw_rearm(c)
|
||||
glow_box(0,101,111,127,c,1)
|
||||
spr(5,15,107,4,2)
|
||||
print("full ammo\nfull shield\n+50% health",54, 106, 6)
|
||||
end
|
||||
|
||||
__gfx__
|
||||
000000000b00000000000a0007700770000aa0000444440004444444000000000000000000000000000000000000000000000000000000000000000000000000
|
||||
00000000bba80880000008000aa00aa00a0880a0447777700477777a000000000000000000000000000000000000000000000000000000000000000000000000
|
||||
007007000aaa28780a0000000990099008000080477aaa7a0477aaaa000000000000000000000000000000000000000000000000000000000000000000000000
|
||||
0007000008a8887808000000099009900080080047a0047a047a0000000000000000000000000000000000000000000000000000000000000000000000000000
|
||||
00007000088888820000a000088008800000000047a0447a047a0000000000000000000000000000000000000000000000000000000000000000000000000000
|
||||
00700700008888200000800008800880a000000a47a4477a047a4440000000000000000000000000000000000000000000000000000000000000000000000000
|
||||
000000000008820000a0000008800880080aa080477777a00477777a000000000000000000000000000000000000000000000000000000000000000000000000
|
||||
0000000000002000008000000880088000088000477770000422aaaa222200020000020000000000000000000000000000000000000000000000000000000000
|
||||
000000000000000000000000000000000000000047a77700022ee0002eeee002e00022e000000000000000000000000000000000000000000000000000000000
|
||||
000000000000000000000000000000000000000047a4777002ea2e002e002e02ee022ee000000000000000000000000000000000000000000000000000000000
|
||||
000000000000000000000000000000000000000047a0477a22ea2e002e002e02e2e2e2e000000000000000000000000000000000000000000000000000000000
|
||||
000000000000000000000000000000000000000047a0047a2e2222e02e222e02e02e02e000000000000000000000000000000000000000000000000000000000
|
||||
000000000000000000000000000000000000000047a0047a2eeeeeea2eeee002e02e02e000000000000000000000000000000000000000000000000000000000
|
||||
00000000000000000000000000000000000000000aa000aa2e7aa2ea2e00e002e02e02e000000000000000000000000000000000000000000000000000000000
|
||||
0000000000000000000000000000000000000000000000002e0002e02e002e02e02e02e000000000000000000000000000000000000000000000000000000000
|
||||
0000000000000000000000000000000000000000000000000e0000e00e000e00e00e00e000000000000000000000000000000000000000000000000000000000
|
@ -1,61 +0,0 @@
|
||||
pico-8 cartridge // http://www.pico-8.com
|
||||
version 41
|
||||
__lua__
|
||||
-- the parser
|
||||
|
||||
parser = {}
|
||||
mknew(parser)
|
||||
|
||||
-- calls parse_into with a nop
|
||||
-- emit function.
|
||||
function parser:parse(str)
|
||||
self:parse_into(str, function() end)
|
||||
end
|
||||
|
||||
-- read a file of commands and
|
||||
-- execute them, emitting the
|
||||
-- results from each call into
|
||||
-- `emit` as a table per row.
|
||||
--
|
||||
-- a "command" is a method on
|
||||
-- self. a row alternates
|
||||
-- commands with args. when
|
||||
-- calling a command, it also
|
||||
-- gets a table of previous
|
||||
-- results as the first arg.
|
||||
-- args are split on ','.
|
||||
function parser:parse_into(str, emit)
|
||||
for row in all(split(str, "\n")) do
|
||||
local prev = {}
|
||||
local sectors = split(row, ":")
|
||||
for i=1,#sectors,2 do
|
||||
local x = self[sectors[i]](self, prev, usplit(sectors[i+1]))
|
||||
if (x) add(prev, x)
|
||||
end
|
||||
emit(prev)
|
||||
end
|
||||
end
|
||||
|
||||
-- saves prev[sel] as self.name.
|
||||
-- if sel is unspecified, saves
|
||||
-- all of prev (as a table).
|
||||
function parser:saveas(prev, name, sel)
|
||||
self[name] = sel and prev[sel] or prev
|
||||
end
|
||||
|
||||
-- returns its args, ignoring
|
||||
-- prev. Used to stuff things
|
||||
-- into prev. args are packed
|
||||
-- if there's multiple.
|
||||
function parser:val(_, ...)
|
||||
local ret := pack(...)
|
||||
if (#ret == 1) return ret[1]
|
||||
return ret
|
||||
end
|
||||
|
||||
function parser:bind(_, fn, ...)
|
||||
local f = self[fn]
|
||||
return function()
|
||||
f(...)
|
||||
end
|
||||
end
|
1243
updatedshmup.p8
1243
updatedshmup.p8
File diff suppressed because it is too large
Load Diff
1813
vacuum_gambit.p8
1813
vacuum_gambit.p8
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue
Block a user