v1.4.4

attic/npcs/tentaclecomet/behavior.lua

@@ -0,0 +1,443 @@
+--------------------------------------------------------------------------------
+function init()
+  self.timers = createTimers()
+
+  self.state = stateMachine.create({
+    "smashAttack",
+    "riseState",
+    "followState",
+    "rangedAttack",
+    "followState",
+    "meleeAttack",
+    "followState",
+  })
+
+  self.state.enteringState = function(stateName)
+    self.state.moveStateToEnd(stateName)
+  end
+
+  self.state.leavingState = function(stateName)
+    self.hoverTimer = nil
+  end
+
+  entity.setAggressive(true)
+
+  -- Setup blinking
+  for i = 1, 3 do
+    local animationStateName = "eye" .. i
+    local blinkDelay = entity.randomizeParameterRange("blinkTimeRange")
+    self.timers.start(blinkDelay, function()
+      local animation = entity.animationState(animationStateName)
+      if animation == "open" then
+        entity.setAnimationState(animationStateName, "blink")
+      end
+      return blinkDelay
+    end)
+  end
+
+  self.state.pickState({ requestedState = "entrance" })
+end
+
+--------------------------------------------------------------------------------
+function update(dt)
+  if not self.state.update(dt) then
+    mcontroller.controlFly({ 0, 0 })
+  end
+
+  self.timers.tick(dt)
+end
+
+--------------------------------------------------------------------------------
+function moveTo(destination, maxSpeed)
+  moveBy(world.distance(destination, mcontroller.position()), maxSpeed)
+end
+
+--------------------------------------------------------------------------------
+function moveBy(delta, maxSpeed)
+  if maxSpeed ~= nil then
+    local speed = world.magnitude(delta)
+    delta = vec2.mul(vec2.norm(delta), math.min(speed, maxSpeed))
+  end
+
+  mcontroller.setVelocity(vec2.div(delta, script.updateDt()))
+end
+
+--------------------------------------------------------------------------------
+function hoverOffset(dt)
+  if self.hoverTimer == nil then
+    self.hoverTimer = 0
+  else
+    self.hoverTimer = self.hoverTimer + dt
+  end
+
+  local angle = 2.0 * math.pi * entity.configParameter("hoverFrequency") * self.hoverTimer
+  return entity.configParameter("hoverAmplitude") * math.sin(angle)
+end
+
+--------------------------------------------------------------------------------
+function findTargets(radius)
+  local position = mcontroller.position()
+  local targetIds = world.entityQuery(position, radius, {
+    -- validTargetOf = entity.id(), -- deprecated, but so is this whole behavior file
+    includedTypes = {"creature"},
+    order = "nearest"
+  })
+
+  -- Prefer an existing target as long as it stays within the search radius
+  if self.targetId ~= nil then
+    local targetPosition = world.entityPosition(self.targetId)
+    if targetPosition ~= nil then
+      local distance = world.magnitude(targetPosition, position)
+      if distance < radius then
+        table.insert(targetIds, self.targetId)
+      else
+        self.targetId = nil
+      end
+    else
+      self.targetId = nil
+    end
+  end
+
+  return targetIds
+end
+
+--------------------------------------------------------------------------------
+function closestCraterOffset(targetPosition)
+  local minDistance, bestOffset, bestOffsetIndex = nil, nil, nil
+
+  for index, offset in ipairs(entity.configParameter("craterOffsets")) do
+    local distance = world.magnitude(entity.toAbsolutePosition(offset), targetPosition)
+    if minDistance == nil or distance < minDistance then
+      minDistance = distance
+      bestOffset = offset
+      bestOffsetIndex = index
+    end
+  end
+
+  return bestOffset, bestOffsetIndex
+end
+
+--------------------------------------------------------------------------------
+riseState = {
+  riseSpeedFraction = 0.15,
+  riseHeight = 18,
+  maxRiseTime = 4,
+  pauseTime = 2,
+}
+
+function riseState.enterWith(params)
+  if params.requestedState ~= "rise" then return nil end
+  return { initialPosition = mcontroller.position(), timer = 0 }
+end
+
+function riseState.update(dt, stateData)
+  -- Pause for a bit after rising up
+  if stateData.pauseTimer ~= nil then
+    if stateData.hoverPosition == nil then
+      stateData.hoverPosition = mcontroller.position()
+    end
+    moveTo(vec2.add(stateData.hoverPosition, { 0, hoverOffset(dt) }))
+
+    if entity.animationState("eye1") == "closed" then
+      entity.setAnimationState("eye1", "open")
+      entity.setAnimationState("eye2", "open")
+      entity.setAnimationState("eye3", "open")
+    end
+
+    stateData.pauseTimer = stateData.pauseTimer - dt
+    return stateData.pauseTimer <= 0
+  end
+
+  local distance = world.magnitude(mcontroller.position(), stateData.initialPosition)
+  stateData.timer = stateData.timer + dt
+  if distance >= riseState.riseHeight or stateData.timer >= riseState.maxRiseTime then
+    stateData.pauseTimer = riseState.pauseTime
+  end
+
+  moveBy({ 0, entity.flySpeed() * riseState.riseSpeedFraction })
+
+  return false
+end
+
+--------------------------------------------------------------------------------
+followState = {
+  targetSearchRadius = 30,
+  duration = 10,
+  heightOffset = 15,
+  trackTargetXInterval = 0.25,
+  trackTargetYInterval = 1,
+  moveSpeedFraction = 0.1,
+}
+
+followState.enter = function()
+  local targetIds = findTargets(followState.targetSearchRadius)
+  if #targetIds > 0 then
+    return {
+      timer = followState.duration,
+      targetId = targetIds[1],
+      targetPosition = world.entityPosition(targetIds[1]),
+      trackTargetXTimer = followState.trackTargetXInterval,
+      trackTargetYTimer = followState.trackTargetYInterval,
+    }
+  end
+
+  return nil
+end
+
+followState.update = function(dt, stateData)
+  local targetPosition = world.entityPosition(stateData.targetId)
+  if targetPosition == nil then return true end
+
+  stateData.targetPosition[1] = targetPosition[1]
+  stateData.trackTargetXTimer = stateData.trackTargetYTimer - dt
+  if stateData.trackTargetXTimer <= 0 then
+    stateData.targetPosition[1] = targetPosition[1]
+    stateData.trackTargetXTimer = followState.trackTargetXInterval
+  end
+
+  stateData.trackTargetYTimer = stateData.trackTargetYTimer - dt
+  if stateData.trackTargetYTimer <= 0 then
+    stateData.targetPosition[2] = targetPosition[2]
+    stateData.trackTargetYTimer = followState.trackTargetYInterval
+  end
+
+  local followPosition = {
+    stateData.targetPosition[1],
+    stateData.targetPosition[2] + followState.heightOffset + hoverOffset(dt)
+  }
+  moveTo(followPosition, entity.flySpeed() * followState.moveSpeedFraction)
+
+  stateData.timer = stateData.timer - dt
+  return stateData.timer <= 0
+end
+
+--------------------------------------------------------------------------------
+-- Rise up a bit (optional), then smash down in the target's vicinity
+smashAttack = {
+  entranceTargetSearchRadius = 100,
+  targetSearchRadius = 50,
+
+  riseSpeedFraction = 0.2,
+  riseHeight = 22,
+  riseMaxTime = 4,
+
+  smashSpeedFraction = 0.5,
+  smashMaxTime = 3,
+  smashTargetOffset = { 0, -2 },
+
+  cooldown = 1,
+
+  explosionOffset = { 0, -6.25 },
+}
+
+function smashAttack.enter()
+  local targetIds = findTargets(smashAttack.targetSearchRadius)
+  if #targetIds == 0 then return nil end
+
+  return {
+    targetId = targetIds[1],
+    targetPosition = world.entityPosition(targetIds[1]),
+    riseTimer = smashAttack.riseMaxTime,
+  }
+end
+
+function smashAttack.enterWith(params)
+  -- Called on initial spawn, this is just a version of this state with some
+  -- additional effects/options
+  if params.requestedState ~= "entrance" then return nil end
+
+  local direction = { 0, -1 }
+
+  local targetIds = findTargets(smashAttack.entranceTargetSearchRadius)
+  if #targetIds > 0 then
+    direction = smashAttack.targetDirection(targetIds[1])
+  end
+
+  return { direction = direction }
+end
+
+function smashAttack.update(dt, stateData)
+  -- Delay one update after crashing to allow the explosion to trigger
+  if stateData.landed then
+    self.state.pickState({ requestedState = "rise" })
+    return true, smashAttack.cooldown
+  end
+
+  local position = mcontroller.position()
+
+  if stateData.riseTimer ~= nil then
+    -- Rising up
+    if not world.entityExists(stateData.targetId) then return true, smashAttack.cooldown end
+    local delta = world.distance(stateData.targetPosition, mcontroller.position())
+
+    if delta[2] < -smashAttack.riseHeight or stateData.riseTimer <= 0 then
+      stateData.direction = smashAttack.targetDirection(stateData.targetId)
+      stateData.riseTimer = nil
+    else
+      moveBy({ 0, entity.flySpeed() * smashAttack.riseSpeedFraction })
+      stateData.riseTimer = stateData.riseTimer - dt
+    end
+  else
+    -- Smashing down
+    local angle = vec2.angle(stateData.direction)
+    if stateData.direction[1] < 0 then angle = math.pi - angle end
+    entity.rotateGroup("flames", angle + math.pi / 2, true)
+    entity.setAnimationState("flames", "idle")
+
+    local delta = vec2.mul(stateData.direction, entity.flySpeed() * smashAttack.smashSpeedFraction)
+
+    moveBy(vec2.mul(vec2.norm(delta), entity.flySpeed() * smashAttack.smashSpeedFraction))
+
+    local bounds = entity.configParameter("metaBoundBox")
+    bounds = {
+      bounds[1] + position[1] + delta[1],
+      bounds[2] + position[2] + delta[2],
+      bounds[3] + position[1] + delta[1],
+      bounds[4] + position[2] + delta[2]
+    }
+    moveBy(delta)
+
+    if stateData.smashTimer == nil then
+      stateData.smashTimer = smashAttack.smashMaxTime
+    end
+    stateData.smashTimer = stateData.smashTimer - dt
+    if stateData.smashTimer <= 0 then
+      self.state.pickState({ requestedState = "rise" })
+      return true, smashAttack.cooldown
+    end
+
+    if world.rectTileCollision(bounds) then
+      -- entity.setFireDirection(smashAttack.explosionOffset, { 0, 0 })
+      -- entity.startFiring("crashexplosion")
+      stateData.landed = true
+    end
+  end
+
+  return false
+end
+
+function smashAttack.leavingState(stateData)
+  -- entity.stopFiring()
+  entity.setAnimationState("flames", "hidden")
+end
+
+function smashAttack.targetDirection(targetId)
+  local targetPosition = vec2.add(world.entityPosition(targetId), smashAttack.smashTargetOffset)
+  local toTarget = world.distance(targetPosition, mcontroller.position())
+  return vec2.norm(toTarget)
+end
+
+--------------------------------------------------------------------------------
+rangedAttack = {
+  targetSearchRadius = 30,
+  duration = 1,
+  cooldown = 1,
+}
+
+function rangedAttack.enter()
+  local targetIds = findTargets(rangedAttack.targetSearchRadius)
+  if #targetIds == 0 then return nil end
+
+  return {
+    targetId = targetIds[1],
+    targetPosition = world.entityPosition(targetIds[1]),
+    timer = rangedAttack.duration,
+  }
+end
+
+function rangedAttack.enteringState(stateData)
+  local fireOffset = closestCraterOffset(stateData.targetPosition)
+  -- entity.setFireDirection(fireOffset, vec2.norm(fireOffset))
+  -- entity.startFiring("meteor")
+end
+
+function rangedAttack.update(dt, stateData)
+  mcontroller.controlFly({ 0, 0 })
+
+  stateData.timer = stateData.timer - dt
+  return stateData.timer <= 0, rangedAttack.cooldown
+end
+
+function rangedAttack.leavingState(stateData)
+  -- entity.stopFiring()
+end
+
+--------------------------------------------------------------------------------
+meleeAttack = {
+  targetSearchRadius = 30,
+  targetOffset = { 0, 6 },
+  moveSpeedFraction = 0.3,
+  tentacleSearchRadius = 12,
+  maxTime = 4,
+  pauseTime = 2,
+  cooldown = 1,
+  minDistance = 7,
+
+  projectileLifetime = 0.5,
+}
+
+function meleeAttack.enter()
+  local targetIds = findTargets(meleeAttack.targetSearchRadius)
+  if #targetIds == 0 then return nil end
+
+  return {
+    targetId = targetIds[1],
+    targetPosition = vec2.add(world.entityPosition(targetIds[1]), meleeAttack.targetOffset),
+    timer = meleeAttack.maxTime,
+    tentacleProjectileEntityIds = { nil, nil, nil, nil, nil, nil, nil, nil }
+  }
+end
+
+function meleeAttack.update(dt, stateData)
+  local targetIds = findTargets(meleeAttack.tentacleSearchRadius)
+  for _, targetId in pairs(targetIds) do
+    local offset, index = closestCraterOffset(world.entityPosition(targetId))
+    local animationStateName = "tentacle" .. index
+    if entity.animationState(animationStateName) == "hidden" then
+      entity.setAnimationState(animationStateName, "extend")
+    end
+  end
+
+  local craterOffsets = entity.configParameter("craterOffsets")
+  for i = 1, 8 do
+    local animationStateName = "tentacle" .. i
+    local animation = entity.animationState(animationStateName)
+    if animation == "idle" then
+      if stateData.tentacleProjectileEntityIds[i] == nil or not world.entityExists(stateData.tentacleProjectileEntityIds[i]) then
+        stateData.tentacleProjectileEntityIds[i] = world.spawnProjectile("tentaclecomet" .. i, mcontroller.position(), entity.id(), craterOffsets[i], true, {
+          speed = 0,
+          power = 20,
+          timeToLive = meleeAttack.projectileLifetime
+        })
+      end
+    end
+  end
+
+  if stateData.pauseTimer ~= nil then
+    if stateData.hoverPosition == nil then
+      stateData.hoverPosition = mcontroller.position()
+    end
+    moveTo(vec2.add(stateData.hoverPosition, { 0, hoverOffset(dt) }))
+
+    stateData.pauseTimer = stateData.pauseTimer - dt
+    return stateData.pauseTimer <= 0, meleeAttack.cooldown
+  end
+
+  local distance = world.magnitude(stateData.targetPosition, mcontroller.position())
+  if distance <= meleeAttack.minDistance or stateData.timer <= 0 then
+    stateData.pauseTimer = meleeAttack.pauseTime
+  else
+    moveTo(stateData.targetPosition, entity.flySpeed() * meleeAttack.moveSpeedFraction)
+  end
+
+  return false
+end
+
+function meleeAttack.leavingState(stateData)
+  for i = 1, 8 do
+    local animationStateName = "tentacle" .. i
+    if entity.animationState(animationStateName) ~= "hidden" then
+      entity.setAnimationState(animationStateName, "retract")
+    end
+  end
+end