579 lines
18 KiB
TypeScript
579 lines
18 KiB
TypeScript
import type { Iwt2BossTickResult } from './bossAi'
|
|
import type {
|
|
Iwt2ArenaEvent,
|
|
Iwt2ArenaIndicator,
|
|
Iwt2ArenaIndicatorPhase,
|
|
Iwt2ArenaState,
|
|
Iwt2BossEntityState,
|
|
Iwt2MechanicCircleState,
|
|
Iwt2MechanicLaneState,
|
|
Iwt2PartyEntityState,
|
|
Iwt2Vec2,
|
|
} from './types'
|
|
import {
|
|
applyPartyDamageInShape,
|
|
createCircleIndicator,
|
|
createConeIndicator,
|
|
createLaneIndicator,
|
|
indicatorPhaseFromAttack,
|
|
} from './mechanics'
|
|
import {
|
|
addVec2,
|
|
clamp,
|
|
clampVec2ToArena,
|
|
distanceVec2,
|
|
moveToward,
|
|
normalizeVec2,
|
|
scaleVec2,
|
|
subtractVec2,
|
|
withFallbackFacing,
|
|
} from './vector'
|
|
|
|
type RimebastionAttackPhase =
|
|
| Iwt2BossEntityState['attackPhase']
|
|
| 'iceWallWindup'
|
|
| 'shardShatterWindup'
|
|
| 'shardShatterRecover'
|
|
|
|
type RimebastionBossState = Omit<Iwt2BossEntityState, 'attackPhase'> & {
|
|
attackPhase: RimebastionAttackPhase
|
|
}
|
|
|
|
type ShardCone = {
|
|
id: string
|
|
origin: Iwt2Vec2
|
|
direction: Iwt2Vec2
|
|
range: number
|
|
angleRadians: number
|
|
}
|
|
|
|
const RIMEBASTION_BALANCE = {
|
|
iceWallCooldown: 7.2,
|
|
iceWallDamage: 18,
|
|
iceWallStunSeconds: 0.25,
|
|
iceWallWindup: 1,
|
|
iceCircleCount: 2,
|
|
iceCircleRadius: 58,
|
|
iceWallLaneCount: 3,
|
|
iceWallWidth: 22,
|
|
meleeCooldown: 1.45,
|
|
meleeDamage: 10,
|
|
meleeRange: 66,
|
|
moveSpeed: 64,
|
|
relocateCooldownFloor: 1.3,
|
|
relocateSpeed: 112,
|
|
relocateSeconds: 1.6,
|
|
shatterConeAngleRadians: Math.PI * 0.34,
|
|
shatterConeDamage: 30,
|
|
shatterConeRange: 158,
|
|
shatterLaneDamage: 34,
|
|
shatterLaneWidth: 34,
|
|
shatterRecover: 0.52,
|
|
shatterStunSeconds: 0.4,
|
|
shatterWindup: 0.72,
|
|
wallDisengageSeconds: 0.7,
|
|
wallMargin: 68,
|
|
}
|
|
|
|
const WALL_COLOR = '#a7ecff'
|
|
const SHARD_COLOR = '#e8fbff'
|
|
|
|
export function tickRimebastion(state: Iwt2ArenaState, dt: number): Iwt2BossTickResult {
|
|
const events: Iwt2ArenaEvent[] = []
|
|
let party = state.party
|
|
let boss: RimebastionBossState = {
|
|
...state.boss,
|
|
meleeCooldownRemaining: Math.max(0, state.boss.meleeCooldownRemaining - dt),
|
|
chargeCooldownRemaining: Math.max(0, state.boss.chargeCooldownRemaining - dt),
|
|
phaseSecondsRemaining: Math.max(0, state.boss.phaseSecondsRemaining - dt),
|
|
velocity: { x: 0, y: 0 },
|
|
}
|
|
boss = {
|
|
...boss,
|
|
wallContactSeconds: isBossNearWall(boss, state)
|
|
? boss.wallContactSeconds + dt
|
|
: Math.max(0, boss.wallContactSeconds - dt * 2),
|
|
}
|
|
const target = getBossTarget(party)
|
|
|
|
if (boss.health <= 0 || !target) return withRimebastionIndicators({ boss, party, events, state })
|
|
|
|
if (boss.attackPhase === 'relocating') {
|
|
boss = moveBossTowardRelocationTarget(boss, state, target, dt)
|
|
if (boss.phaseSecondsRemaining <= 0 || distanceVec2(boss.position, boss.relocateTarget) <= 8) {
|
|
boss = {
|
|
...boss,
|
|
attackPhase: 'idle',
|
|
chargeCooldownRemaining: Math.max(boss.chargeCooldownRemaining, RIMEBASTION_BALANCE.relocateCooldownFloor),
|
|
mechanicCircles: [],
|
|
mechanicLanes: [],
|
|
phaseSecondsRemaining: 0,
|
|
velocity: { x: 0, y: 0 },
|
|
}
|
|
}
|
|
return withRimebastionIndicators({ boss, party, events, state })
|
|
}
|
|
|
|
if (boss.attackPhase === 'iceWallWindup') {
|
|
boss = {
|
|
...boss,
|
|
facing: withFallbackFacing(subtractVec2(target.position, boss.position), boss.facing),
|
|
velocity: { x: 0, y: 0 },
|
|
}
|
|
if (boss.phaseSecondsRemaining <= 0) {
|
|
const result = applyIceWalls(party, boss, state.time + dt)
|
|
party = result.party
|
|
events.push(...result.events)
|
|
boss = {
|
|
...boss,
|
|
attackPhase: 'shardShatterWindup',
|
|
phaseSecondsRemaining: RIMEBASTION_BALANCE.shatterWindup,
|
|
}
|
|
}
|
|
return withRimebastionIndicators({ boss, party, events, state })
|
|
}
|
|
|
|
if (boss.attackPhase === 'shardShatterWindup') {
|
|
boss = {
|
|
...boss,
|
|
facing: withFallbackFacing(subtractVec2(target.position, boss.position), boss.facing),
|
|
velocity: { x: 0, y: 0 },
|
|
}
|
|
if (boss.phaseSecondsRemaining <= 0) {
|
|
const result = applyShardShatter(party, boss, state, state.time + dt)
|
|
party = result.party
|
|
events.push(...result.events)
|
|
boss = {
|
|
...boss,
|
|
attackPhase: 'shardShatterRecover',
|
|
phaseSecondsRemaining: RIMEBASTION_BALANCE.shatterRecover,
|
|
}
|
|
}
|
|
return withRimebastionIndicators({ boss, party, events, state })
|
|
}
|
|
|
|
if (boss.attackPhase === 'shardShatterRecover') {
|
|
if (boss.phaseSecondsRemaining <= 0) {
|
|
boss = {
|
|
...boss,
|
|
attackPhase: 'idle',
|
|
mechanicCircles: [],
|
|
mechanicLanes: [],
|
|
phaseSecondsRemaining: 0,
|
|
}
|
|
}
|
|
return withRimebastionIndicators({ boss, party, events, state })
|
|
}
|
|
|
|
if (boss.attackPhase === 'idle' && boss.wallContactSeconds >= RIMEBASTION_BALANCE.wallDisengageSeconds) {
|
|
boss = {
|
|
...boss,
|
|
attackPhase: 'relocating',
|
|
mechanicCircles: [],
|
|
mechanicLanes: [],
|
|
phaseSecondsRemaining: RIMEBASTION_BALANCE.relocateSeconds,
|
|
relocateTarget: relocationTarget(boss, state),
|
|
velocity: { x: 0, y: 0 },
|
|
}
|
|
return withRimebastionIndicators({ boss, party, events, state })
|
|
}
|
|
|
|
if (boss.chargeCooldownRemaining <= 0) {
|
|
const pattern = createIceWallPattern(state, party, boss)
|
|
boss = {
|
|
...boss,
|
|
attackPhase: 'iceWallWindup',
|
|
chargeCooldownRemaining: RIMEBASTION_BALANCE.iceWallCooldown,
|
|
chargeCount: boss.chargeCount + 1,
|
|
mechanicCircles: pattern.circles,
|
|
mechanicLanes: pattern.lanes,
|
|
phaseSecondsRemaining: RIMEBASTION_BALANCE.iceWallWindup,
|
|
velocity: { x: 0, y: 0 },
|
|
}
|
|
return withRimebastionIndicators({ boss, party, events, state })
|
|
}
|
|
|
|
const meleeResult = maybeApplyMelee(party, boss, target, state.time + dt)
|
|
party = meleeResult.party
|
|
events.push(...meleeResult.events)
|
|
boss = meleeResult.boss
|
|
if (events.length > 0) return withRimebastionIndicators({ boss, party, events, state })
|
|
|
|
boss = moveBossTowardEngagePoint(boss, state, target, dt)
|
|
return withRimebastionIndicators({ boss, party, events, state })
|
|
}
|
|
|
|
function createIceWallPattern(
|
|
state: Iwt2ArenaState,
|
|
party: Iwt2PartyEntityState[],
|
|
boss: RimebastionBossState,
|
|
): { lanes: Iwt2MechanicLaneState[], circles: Iwt2MechanicCircleState[] } {
|
|
const living = party.filter((member) => member.health > 0)
|
|
const center = partyCenter(living, arenaCenter(state))
|
|
const vertical = boss.chargeCount % 2 === 0
|
|
const lanes: Iwt2MechanicLaneState[] = []
|
|
const offsets = [-96, 0, 96]
|
|
|
|
for (let index = 0; index < RIMEBASTION_BALANCE.iceWallLaneCount; index += 1) {
|
|
const offset = offsets[index] ?? 0
|
|
if (vertical) {
|
|
const x = clamp(center.x + offset, 82, state.bounds.width - 82)
|
|
lanes.push({
|
|
end: { x, y: state.bounds.height - 38 },
|
|
id: `rime-wall-lane-${index}`,
|
|
start: { x, y: 38 },
|
|
width: RIMEBASTION_BALANCE.iceWallWidth,
|
|
})
|
|
} else {
|
|
const y = clamp(center.y + offset * 0.72, 74, state.bounds.height - 74)
|
|
lanes.push({
|
|
end: { x: state.bounds.width - 38, y },
|
|
id: `rime-wall-lane-${index}`,
|
|
start: { x: 38, y },
|
|
width: RIMEBASTION_BALANCE.iceWallWidth,
|
|
})
|
|
}
|
|
}
|
|
|
|
const circles = living
|
|
.filter((member) => member.aiRole === 'ranged' || member.aiRole === 'flanker' || member.aiRole === 'player')
|
|
.slice(0, RIMEBASTION_BALANCE.iceCircleCount)
|
|
.map((member, index) => ({
|
|
id: `rime-wall-circle-${index}`,
|
|
position: clampVec2ToArena(member.position, RIMEBASTION_BALANCE.iceCircleRadius, state.bounds),
|
|
radius: RIMEBASTION_BALANCE.iceCircleRadius,
|
|
}))
|
|
|
|
return { circles, lanes }
|
|
}
|
|
|
|
function applyIceWalls(
|
|
party: Iwt2PartyEntityState[],
|
|
boss: RimebastionBossState,
|
|
time: number,
|
|
): { party: Iwt2PartyEntityState[], events: Iwt2ArenaEvent[] } {
|
|
let nextParty = party
|
|
const events: Iwt2ArenaEvent[] = []
|
|
const hitEntityIds: string[] = []
|
|
|
|
for (const lane of boss.mechanicLanes) {
|
|
const result = applyPartyDamageInShape(nextParty, {
|
|
kind: 'lane',
|
|
end: lane.end,
|
|
start: lane.start,
|
|
width: lane.width,
|
|
}, {
|
|
damage: RIMEBASTION_BALANCE.iceWallDamage,
|
|
excludedEntityIds: hitEntityIds,
|
|
knockdownSeconds: 0,
|
|
sourceId: boss.id,
|
|
stunSeconds: RIMEBASTION_BALANCE.iceWallStunSeconds,
|
|
time,
|
|
})
|
|
nextParty = result.party
|
|
hitEntityIds.push(...result.hitEntityIds)
|
|
events.push(...result.events)
|
|
}
|
|
|
|
for (const circle of boss.mechanicCircles) {
|
|
const result = applyPartyDamageInShape(nextParty, {
|
|
kind: 'circle',
|
|
position: circle.position,
|
|
radius: circle.radius,
|
|
}, {
|
|
damage: RIMEBASTION_BALANCE.iceWallDamage,
|
|
excludedEntityIds: hitEntityIds,
|
|
knockdownSeconds: 0,
|
|
sourceId: boss.id,
|
|
stunSeconds: RIMEBASTION_BALANCE.iceWallStunSeconds,
|
|
time,
|
|
})
|
|
nextParty = result.party
|
|
hitEntityIds.push(...result.hitEntityIds)
|
|
events.push(...result.events)
|
|
}
|
|
|
|
return { party: nextParty, events }
|
|
}
|
|
|
|
function applyShardShatter(
|
|
party: Iwt2PartyEntityState[],
|
|
boss: RimebastionBossState,
|
|
state: Iwt2ArenaState,
|
|
time: number,
|
|
): { party: Iwt2PartyEntityState[], events: Iwt2ArenaEvent[] } {
|
|
let nextParty = party
|
|
const events: Iwt2ArenaEvent[] = []
|
|
const hitEntityIds: string[] = []
|
|
|
|
for (const lane of boss.mechanicLanes) {
|
|
const result = applyPartyDamageInShape(nextParty, {
|
|
kind: 'lane',
|
|
end: lane.end,
|
|
start: lane.start,
|
|
width: RIMEBASTION_BALANCE.shatterLaneWidth,
|
|
}, {
|
|
damage: RIMEBASTION_BALANCE.shatterLaneDamage,
|
|
excludedEntityIds: hitEntityIds,
|
|
knockdownSeconds: RIMEBASTION_BALANCE.shatterStunSeconds,
|
|
sourceId: boss.id,
|
|
stunSeconds: RIMEBASTION_BALANCE.shatterStunSeconds,
|
|
time,
|
|
})
|
|
nextParty = result.party
|
|
hitEntityIds.push(...result.hitEntityIds)
|
|
events.push(...result.events)
|
|
}
|
|
|
|
for (const cone of createShardCones(boss, state)) {
|
|
const result = applyPartyDamageInShape(nextParty, {
|
|
kind: 'cone',
|
|
angleRadians: cone.angleRadians,
|
|
direction: cone.direction,
|
|
origin: cone.origin,
|
|
range: cone.range,
|
|
}, {
|
|
damage: RIMEBASTION_BALANCE.shatterConeDamage,
|
|
excludedEntityIds: hitEntityIds,
|
|
knockdownSeconds: RIMEBASTION_BALANCE.shatterStunSeconds,
|
|
sourceId: boss.id,
|
|
stunSeconds: RIMEBASTION_BALANCE.shatterStunSeconds,
|
|
time,
|
|
})
|
|
nextParty = result.party
|
|
hitEntityIds.push(...result.hitEntityIds)
|
|
events.push(...result.events)
|
|
}
|
|
|
|
return { party: nextParty, events }
|
|
}
|
|
|
|
function createShardCones(boss: RimebastionBossState, state: Iwt2ArenaState): ShardCone[] {
|
|
const cones: ShardCone[] = []
|
|
const center = arenaCenter(state)
|
|
|
|
for (const lane of boss.mechanicLanes) {
|
|
const midpoint = {
|
|
x: (lane.start.x + lane.end.x) * 0.5,
|
|
y: (lane.start.y + lane.end.y) * 0.5,
|
|
}
|
|
cones.push({
|
|
angleRadians: RIMEBASTION_BALANCE.shatterConeAngleRadians,
|
|
direction: withFallbackFacing(subtractVec2(center, midpoint), boss.facing),
|
|
id: `${lane.id}-shard-cone`,
|
|
origin: midpoint,
|
|
range: RIMEBASTION_BALANCE.shatterConeRange,
|
|
})
|
|
}
|
|
|
|
for (const circle of boss.mechanicCircles) {
|
|
cones.push({
|
|
angleRadians: RIMEBASTION_BALANCE.shatterConeAngleRadians,
|
|
direction: withFallbackFacing(subtractVec2(circle.position, boss.position), boss.facing),
|
|
id: `${circle.id}-shard-cone`,
|
|
origin: circle.position,
|
|
range: RIMEBASTION_BALANCE.shatterConeRange * 0.86,
|
|
})
|
|
}
|
|
|
|
return cones
|
|
}
|
|
|
|
function moveBossTowardRelocationTarget(
|
|
boss: RimebastionBossState,
|
|
state: Iwt2ArenaState,
|
|
target: Iwt2PartyEntityState,
|
|
dt: number,
|
|
): RimebastionBossState {
|
|
const nextPosition = clampVec2ToArena(
|
|
moveToward(boss.position, boss.relocateTarget, RIMEBASTION_BALANCE.relocateSpeed * dt),
|
|
boss.radius,
|
|
state.bounds,
|
|
)
|
|
return {
|
|
...boss,
|
|
facing: withFallbackFacing(subtractVec2(target.position, nextPosition), boss.facing),
|
|
position: nextPosition,
|
|
velocity: scaleVec2(subtractVec2(nextPosition, boss.position), dt > 0 ? 1 / dt : 0),
|
|
wallContactSeconds: 0,
|
|
}
|
|
}
|
|
|
|
function moveBossTowardEngagePoint(
|
|
boss: RimebastionBossState,
|
|
state: Iwt2ArenaState,
|
|
target: Iwt2PartyEntityState,
|
|
dt: number,
|
|
): RimebastionBossState {
|
|
const center = arenaCenter(state)
|
|
const targetNearWall = isPositionNearWall(target.position, target.radius + RIMEBASTION_BALANCE.wallMargin, state)
|
|
const desired = targetNearWall
|
|
? addVec2(target.position, scaleVec2(normalizeVec2(subtractVec2(center, target.position)), RIMEBASTION_BALANCE.meleeRange * 0.9))
|
|
: target.position
|
|
const nextPosition = clampVec2ToArena(
|
|
moveToward(boss.position, desired, RIMEBASTION_BALANCE.moveSpeed * dt),
|
|
boss.radius,
|
|
state.bounds,
|
|
)
|
|
return {
|
|
...boss,
|
|
facing: withFallbackFacing(subtractVec2(target.position, nextPosition), boss.facing),
|
|
position: nextPosition,
|
|
velocity: scaleVec2(subtractVec2(nextPosition, boss.position), dt > 0 ? 1 / dt : 0),
|
|
}
|
|
}
|
|
|
|
function relocationTarget(boss: RimebastionBossState, state: Iwt2ArenaState): Iwt2Vec2 {
|
|
const center = arenaCenter(state)
|
|
const awayFromWall = normalizeVec2({
|
|
x: boss.position.x < state.bounds.width * 0.5 ? 1 : -1,
|
|
y: boss.position.y < state.bounds.height * 0.5 ? 1 : -1,
|
|
})
|
|
return clampVec2ToArena(addVec2(center, scaleVec2(awayFromWall, 58)), boss.radius, state.bounds)
|
|
}
|
|
|
|
function maybeApplyMelee(
|
|
party: Iwt2PartyEntityState[],
|
|
boss: RimebastionBossState,
|
|
target: Iwt2PartyEntityState,
|
|
time: number,
|
|
): { boss: RimebastionBossState, party: Iwt2PartyEntityState[], events: Iwt2ArenaEvent[] } {
|
|
if (boss.meleeCooldownRemaining > 0) return { boss, party, events: [] }
|
|
if (distanceVec2(boss.position, target.position) > RIMEBASTION_BALANCE.meleeRange + target.radius) {
|
|
return { boss, party, events: [] }
|
|
}
|
|
const result = applyPartyDamageInShape(party, {
|
|
kind: 'circle',
|
|
position: boss.position,
|
|
radius: RIMEBASTION_BALANCE.meleeRange,
|
|
}, {
|
|
damage: RIMEBASTION_BALANCE.meleeDamage,
|
|
sourceId: boss.id,
|
|
time,
|
|
})
|
|
return {
|
|
boss: { ...boss, meleeCooldownRemaining: RIMEBASTION_BALANCE.meleeCooldown },
|
|
events: result.events,
|
|
party: result.party,
|
|
}
|
|
}
|
|
|
|
function getBossTarget(party: Iwt2PartyEntityState[]): Iwt2PartyEntityState | undefined {
|
|
const livingTank = party.find((member) => member.classId === 'paladin' && member.health > 0)
|
|
if (livingTank) return livingTank
|
|
return party.find((member) => member.health > 0)
|
|
}
|
|
|
|
function partyCenter(party: Iwt2PartyEntityState[], fallback: Iwt2Vec2): Iwt2Vec2 {
|
|
if (party.length <= 0) return fallback
|
|
const total = party.reduce((sum, member) => addVec2(sum, member.position), { x: 0, y: 0 })
|
|
return scaleVec2(total, 1 / party.length)
|
|
}
|
|
|
|
function arenaCenter(state: Iwt2ArenaState): Iwt2Vec2 {
|
|
return {
|
|
x: state.bounds.width * 0.5,
|
|
y: state.bounds.height * 0.5,
|
|
}
|
|
}
|
|
|
|
function isBossNearWall(boss: Pick<Iwt2BossEntityState, 'position' | 'radius'>, state: Iwt2ArenaState): boolean {
|
|
return isPositionNearWall(boss.position, boss.radius + RIMEBASTION_BALANCE.wallMargin, state)
|
|
}
|
|
|
|
function isPositionNearWall(position: Iwt2Vec2, margin: number, state: Iwt2ArenaState): boolean {
|
|
return (
|
|
position.x <= margin
|
|
|| position.x >= state.bounds.width - margin
|
|
|| position.y <= margin
|
|
|| position.y >= state.bounds.height - margin
|
|
)
|
|
}
|
|
|
|
function withRimebastionIndicators(result: {
|
|
boss: RimebastionBossState
|
|
party: Iwt2PartyEntityState[]
|
|
events: Iwt2ArenaEvent[]
|
|
state: Iwt2ArenaState
|
|
}): Iwt2BossTickResult {
|
|
const { state, ...rest } = result
|
|
return {
|
|
...rest,
|
|
boss: result.boss as Iwt2BossEntityState,
|
|
indicators: createRimebastionIndicators(result.boss, state),
|
|
}
|
|
}
|
|
|
|
function createRimebastionIndicators(boss: RimebastionBossState, state: Iwt2ArenaState): Iwt2ArenaIndicator[] {
|
|
const indicators: Iwt2ArenaIndicator[] = []
|
|
const showWalls = (
|
|
boss.attackPhase === 'iceWallWindup'
|
|
|| boss.attackPhase === 'shardShatterWindup'
|
|
|| boss.attackPhase === 'shardShatterRecover'
|
|
)
|
|
if (showWalls) {
|
|
const wallPhase: Iwt2ArenaIndicatorPhase = boss.attackPhase === 'iceWallWindup'
|
|
? 'windup'
|
|
: boss.attackPhase === 'shardShatterWindup'
|
|
? 'active'
|
|
: 'recover'
|
|
for (const lane of boss.mechanicLanes) {
|
|
indicators.push(createLaneIndicator({
|
|
color: WALL_COLOR,
|
|
end: lane.end,
|
|
id: `${boss.id}:${lane.id}`,
|
|
mechanicId: 'rimebastion-ice-wall-lane',
|
|
phase: wallPhase,
|
|
sourceId: boss.id,
|
|
start: lane.start,
|
|
width: lane.width,
|
|
}))
|
|
}
|
|
for (const circle of boss.mechanicCircles) {
|
|
indicators.push(createCircleIndicator({
|
|
color: WALL_COLOR,
|
|
id: `${boss.id}:${circle.id}`,
|
|
mechanicId: 'rimebastion-ice-wall-circle',
|
|
phase: wallPhase,
|
|
position: circle.position,
|
|
radius: circle.radius,
|
|
sourceId: boss.id,
|
|
}))
|
|
}
|
|
}
|
|
|
|
if (boss.attackPhase === 'shardShatterWindup' || boss.attackPhase === 'shardShatterRecover') {
|
|
const shardPhase = indicatorPhaseFromAttack(
|
|
boss.attackPhase === 'shardShatterWindup',
|
|
boss.attackPhase === 'shardShatterRecover',
|
|
)
|
|
for (const lane of boss.mechanicLanes) {
|
|
indicators.push(createLaneIndicator({
|
|
color: SHARD_COLOR,
|
|
end: lane.end,
|
|
id: `${boss.id}:${lane.id}:shatter`,
|
|
mechanicId: 'rimebastion-shard-lane',
|
|
phase: shardPhase,
|
|
sourceId: boss.id,
|
|
start: lane.start,
|
|
width: RIMEBASTION_BALANCE.shatterLaneWidth,
|
|
}))
|
|
}
|
|
for (const cone of createShardCones(boss, state)) {
|
|
indicators.push(createConeIndicator({
|
|
angleRadians: cone.angleRadians,
|
|
color: SHARD_COLOR,
|
|
direction: cone.direction,
|
|
id: `${boss.id}:${cone.id}`,
|
|
mechanicId: 'rimebastion-shard-cone',
|
|
origin: cone.origin,
|
|
phase: shardPhase,
|
|
range: cone.range,
|
|
sourceId: boss.id,
|
|
}))
|
|
}
|
|
}
|
|
|
|
return indicators
|
|
}
|