bye, chasey!

chasey can be replaced by a path segment now

vacuum_gambit.p8

@@ -194,7 +194,9 @@ function updategame()
   interlude -= 1
  else
   current_wave = flotilla.new()
-  current_wave:load(rnd() > 0.5 and 7 or 0, 0, min(ones(waves_complete)\2, 4))
+  --current_wave:load(rnd() > 0.5 and 7 or 0, 0, min(ones(waves_complete)\2, 4))
+  current_wave:load(0, 0, min(ones(waves_complete)\2, 4))
+  current_wave:update()
  end
  events = filtermoved(events)
  appendmove(events, new_events)
@@ -651,18 +653,18 @@ end
 
 function destination:anchor(fx, fy)
  local af = self.anchor_frac
- if (af == -1) return 55,63
- return lerp(fx, primary_ship.x + 4, af), lerp(fy, primary_ship.y + 4, af)
+ if (af == -1) return 51,59
+ return lerp(fx, primary_ship.x, af), lerp(fy, primary_ship.y, af)
 end
 
 function destination:target_from(fx, fy)
  local rx, ry = self:anchor(fx, fy)
  local xf, yf = self.x_off_frac, self.y_off_frac
  if (xf < 0) rx = lerp(rx, 0, -xf)
- if (xf > 0) rx = lerp(rx, 112, xf)
+ if (xf > 0) rx = lerp(rx, 104, xf)
  if (yf < 0) ry = lerp(ry, 0, -yf)
- if (yf > 0) ry = lerp(ry, 128, yf)
- return rx, ry
+ if (yf > 0) ry = lerp(ry, 120, yf)
+ return rx, ry, self.accel_frac
 end
 
 segment = mknew{
@@ -684,24 +686,37 @@ segment = mknew{
  -- dest_x, dest_y: stored
  --  current destination to
  --  figure out approach/depart
- -- [1..n]: destinations
+ -- dests[1..n]: destinations
  init = function(x)
-  x.remain = x.limit
+  x.init = segment.reset
+  mknew(x)
+  if not x.mirror then
+   local mdests = {}
+   for i, v in ipairs(x.dests) do
+    mdests[i] = destination.new{
+     anchor_frac=v.anchor_frac,
+     accel_frac=v.accel_frac,
+     x_off_frac=-v.x_off_frac,
+     y_off_frac=v.y_off_frac,
+    }
+   end
+   x.mirror = mknew(x.new{mirror=x, init=segment.reset, dests=mdests})
+  end
  end
 }
 
 function segment:reset()
  self.current_idx = 1
  self.remain = self.limit
- self.prev_x = nil
- self.prev_y = nil
+ self.prev_x = false
+ self.prev_y = false
  self.was_approaching = false
 end
 
 function segment:target_from(fx, fy)
- local rx, ry = self[self.current_idx]:target_from(fx, fy)
+ local rx, ry, af = self.dests[self.current_idx]:target_from(fx, fy)
  self.dest_x, self.dest_y = rx, ry
- return rx, ry
+ return rx, ry, af
 end
 
 function segment:update(x, y)
@@ -710,7 +725,8 @@ function segment:update(x, y)
  if (rem > 0) rem -= 1
 
  if self:should_step(x, y) then
-  if self.current_idx == #self then
+  self.prev_x, self.prev_y, self.was_approaching = false, false, false
+  if self.current_idx == #self.dests then
    self.current_idx = self.loop_idx
    if (rem < 0) rem += 1
   else
@@ -722,52 +738,69 @@ function segment:update(x, y)
 end
 
 function segment:should_step(x, y)
- local dest_x, dest_y, ret = self.dest_x, self.dest_y, false
+ local dest_x, dest_y = self.dest_x, self.dest_y
  local dx1, dy1 = x - dest_x, y-dest_y
- if abs(dx1) <= 4 and abs(dy1) <= 4 then
-  self.was_approaching = false
-  ret = true
- end
+ if (abs(dx1) <= 1.5 and abs(dy1) <= 1.5) return true
  if self.prev_x then
   local dx0, dy0 = self.prev_x - dest_x, self.prev_y - dest_y
-  if dx1 * dx1 + dy1 * dy1 > dx0 * dx0 + dy0 * dy0 then
-   if self.was_approaching then
-    self.was_approaching = false
-    ret = true
-   end
+  local d12, d02 = dx1 * dx1 + dy1 * dy1, dx0 * dx0 + dy0 * dy0
+  if d12 > d02 then
+   if (self.was_approaching) return true
   else
+   if (d12 == d02 and self.was_approaching) return true
    self.was_approaching = true
   end
  end
  self.prev_x, self.prev_y = x, y
- return ret
+ return false
 end
 
 path = mknew {
  loop_idx = 1,
- current_idx = 1,
- -- [1..n]: destinations
+ -- segs[1..n]: segments or subpaths
+ init=function(x)
+  if not x.mirror then
+   local msegs = {}
+   for i, v in ipairs(x.segs) do
+    msegs[i]=v.mirror
+   end
+   x.mirror = path.new{mirror=x, loop_idx=x.loop_idx, segs=msegs}
+  end
+  x.init = function(y)
+   local ysegs = {}
+   for i, v in ipairs(x.segs) do
+    ysegs[i]=v.new{}
+   end
+   y.segs = ysegs
+   y:reset()
+  end
+  mknew(x)
+ end,
 }
 
 function path:reset()
- self.loop_idx = 1
  self.current_idx = 1
+ for s in all(self.segs) do
+  s:reset()
+ end
 end
 
 function path:target_from(fx, fy)
- return self[self.current_idx]:target_from(fx, fy)
+ return self.segs[self.current_idx]:target_from(fx, fy)
 end
 
 function path:update(x, y)
- local idx = self.current_idx
- if self[idx]:update(x, y) then
-  if idx == #self then
+ local idx, segs = self.current_idx, self.segs
+ if not segs[idx]:update(x, y) then
+  segs[idx]:reset()
+  if idx == #segs then
    self.current_idx = self.loop_idx
-   return true
+   return
   else
    self.current_idx = idx+1
   end
  end
+ return true
 end
 
 -->8
@@ -1374,71 +1407,6 @@ shield will
  return ret
 end
 
--- original prototype leftover;
--- likely to be the basis of a
--- standard raider type, so
--- i am keeping it around
-chasey = mknew(ship_m.new{
- sprite = 5,
- xp = 0x0.0004,
- size = 1,
- hurt = {
-  x_off = 1,
-  y_off = 2,
-  width = 6,
-  height = 5,
- },
- sparks = smokespark,
- sparkodds = 8,
- hp = 1.5,
- shield = 1,
- maxshield = 1,
-
- fire_off_x = 4,
- fire_off_y = 7,
- 
- maxspd = 2,
- thrust = 0.2,
- drag = 0.075,
-
- init = function(ship)
-  --ship.main_gun=ship.main_gun or zap_gun_e.new{}
- end
-})
-
-function chasey:act()
- self.xmin = max(primary_ship.x-8, 0)
- self.xmax = min(primary_ship.x + 8, 112 - 8*self.size)
- return 0, 0, false, self.y > 10 and self.x - 16 < primary_ship.x and self.x + 16 > primary_ship.x
-end
-
-xl_chasey=mknew(chasey.new{
- size=2,
- xp = 0x0.000a,
- maxspd=1.25,
- hurt = {
-  x_off = 2,
-  y_off = 4,
-  width = 12,
-  height = 10
- },
- fire_off_x = 8,
- fire_off_y = 15,
- hp = 19.5,
- shield = 5,
- boss = true,
- act = function(self)
-  local dx,dy,shoot_spec,shoot_main = chasey.act(self)
-  if (self.y < 4) dy=self.thrust
-  return dx,dy,shoot_spec,shoot_main
- end,
- draw = function(self)
-  if(self.fx_pal) pal(self.fx_pal)
-  sspr(40, 0, 8, 8, self.x, self.y, 16, 16)
-  pal()
- end,
-})
-
 -- flotilla ships
 
 ship_f = mknew(ship_m.new{
@@ -1457,13 +1425,76 @@ ship_f = mknew(ship_m.new{
  act = function(self)
   local wx,wy=self.want_x,self.want_y
   self.xmin,self.xmax,self.ymin,self.ymax = wx,wx,wy,wy
-  return 0,0,false,false
+  return 0,0
  end,
  init = function(self)
   if (self.gun_proto) self.main_gun = self.gun_proto.new()
+  if (self.path) self.path = self.path.new()
  end
 })
 
+diamond_loop = segment.new{
+ dests = {
+  destination.new{
+   x_off_frac=0.125
+  }, destination.new{
+   y_off_frac=0.125
+  }, destination.new {
+   x_off_frac = -0.125
+  }, destination.new {
+   y_off_frac = -0.125
+  },
+ },
+}
+
+park = segment.new{
+ dests = {
+  destination.new{
+   accel_frac = 0
+  }
+ }
+}
+
+diamond_bounce = path.new{
+ segs = {
+  park,
+  diamond_loop,
+  park,
+  diamond_loop.mirror,
+ },
+}
+
+swoop = segment.new {
+ dests = {
+  destination.new{
+   accel_frac = 0
+  }, destination.new{
+   x_off_frac = -0.75,
+   anchor_frac = 0.25,
+  }, destination.new {
+   x_off_frac = -0.375,
+   anchor_frac = 0.625,
+  }, destination.new {
+   y_off_frac = -0.125,
+   anchor_frac = 1,
+  }, destination.new {
+   x_off_frac = 0.375,
+   anchor_frac = 0.625,
+  },
+ },
+}
+
+swoop_loop = path.new {
+ segs = {
+  diamond_loop,
+  swoop,
+  park,
+  diamond_loop.mirror,
+  swoop.mirror,
+  park,
+ }
+}
+
 ship_mook = mknew(ship_f.new{
  sprite=103
 })
@@ -1480,15 +1511,35 @@ ship_turret = mknew(ship_f.new{
 ship_skirmisher = mknew(ship_f.new{
  sprite=107,
  xp = 0x0.0004,
+ hp = 1.5,
  sparks = smokespark,
  sparkodds = 3,
  fire_off_y = 7,
  xmin = -8,
  xmax = 112,
+ path = swoop_loop,
 })
 
 function ship_skirmisher:reset_bounds()
- self.xmin, self.xmax, self.ymin, self.ymax = -8, 112, 0, 120
+ self.xmin, self.xmax, self.ymin, self.ymax = -8, 112, 0, 128
+end
+
+function ship_skirmisher:act()
+ local tx, ty, af = self.path:target_from(self.want_x, self.want_y)
+ if af <= 0 then
+  self.xmin, self.xmax, self.ymin, self.ymax = tx,tx,ty,ty
+  return 0,0
+ end
+ self:reset_bounds()
+ local ax, ay, th = tx - self.x, ty - self.y, self.thrust*af
+ local ma = max(abs(ax), abs(ay))
+ return ax*th/ma, ay*th/ma
+end
+
+function ship_skirmisher:move()
+ if (not ship_f.move(self)) return
+ if (not self.path:update(self.x, self.y)) self.path:reset()
+ return true
 end
 
 function rnd_spawn_loc()
@@ -1591,7 +1642,7 @@ flotilla = mknew{
    [8]=mknew(ship_turret.new{ship_t=8}),
    [9]=mknew(ship_turret.new{ship_t=9, sprite=4}),
    [12]=mknew(ship_skirmisher.new{ship_t=12}),
-   [13]=mknew(ship_skirmisher.new{ship_t=13, sprite=26}),
+   [13]=mknew(ship_skirmisher.new{ship_t=13, sprite=26, path=diamond_bounce}),
   }
  end,
 }
@@ -1607,8 +1658,9 @@ function flotilla:load(ulc_cx, ulc_cy, lvl)
   [12]=0,
   [13]=0,
  }
+ local maxcol = 0
  repeat
-  local row,cx,opt,f,mode= {},ulc_cx,{},0,0
+  local row,cx,opt,f,mode = {},ulc_cx,{},0,0
   for i,v in ipairs(self.opt_odds) do
    opt[i*4-4]=rnd()<v
   end
@@ -1618,7 +1670,7 @@ function flotilla:load(ulc_cx, ulc_cy, lvl)
    mode = f&0x03
    if mode==2 then
     -- bits 0x0c: ship class
-    local ship_t = f&0x0c
+    local ship_t, col = f&0x0c, cx-ulc_cx
     -- bit 0x20: optional?
     if f&0x20 == 0 or opt[ship_t] then
      -- bit 0x10: alternate ship?
@@ -1627,7 +1679,8 @@ function flotilla:load(ulc_cx, ulc_cy, lvl)
      -- and we allow alternates
      -- for this type of ship
      ship_t+=(uv>>ship_t&0x1)&((f&0x10)>>4)
-     add(row, self.ship_bases[ship_t].new{col=cx-ulc_cx})
+     add(row, self.ship_bases[ship_t].new{col=col})
+     if (col > maxcol) maxcol = col
     end
    end
    cx += 1
@@ -1647,6 +1700,13 @@ function flotilla:load(ulc_cx, ulc_cy, lvl)
   -- control mark bit 0x04: end of flotilla
  until f&0x04 > 0
  self.rows=rows
+ -- mirror right half paths; alternate center column if odd
+ local rh = maxcol>>1
+ for r, row in ipairs(rows) do
+  for s in all(row) do
+   if ((s.path) and (s.col > rh or (s.col == rh and r & 1 == 1))) s.path = s.path.mirror.new()
+  end
+ end
  self:statisfy(counts)
 end