Azymoove Ajuda

Ajudantes: o Drone

Um drone que voa com o seu robô, atira, protege ou conserta.

Passe ajudantes ao construtor com super({ helpers: [new Drone()] }). O drone voa ao redor do seu robô, tem 15 de vida, é derrubado por qualquer tiro que cruze o caminho dele e cai junto com você.

Ajudantes e itens dividem os 3 espaços. O primeiro drone custa 3 pontos, e cada um a mais custa 1 a mais (2 drones = 7 pontos).

Modos

O new Drone() escolhe o que fazer pelo mode, que você troca na instância (this.helpers[0].mode = "guard"). A troca vale na hora:

  • follow (padrão): acompanha você e atira no inimigo mais próximo (2 de dano a cada 2 s, alcance 18), mirando na frente dele.
  • attack: persegue o inimigo em target e atira nele; enquanto não o vê, faz o mesmo que follow.
  • guard: fica entre você e o inimigo mais próximo, com escudo, sem atirar.
  • repair: não atira; devolve 0,4 de vida por segundo, gastando 3 de energia sua por ponto.

Como o Drone funciona

Este é o código que o new Drone() executa, exatamente. Para mudar, crie uma classe que estende Drone e reescreva só o método que quiser (followOwner, attackTarget, guardOwner, repairOwner ou aim; em Python, Ruby e Lua, follow_owner…). Por exemplo, para mirar sem antecipar o movimento:

class MeuDrone extends Drone {
  aim(state, enemy) { this.fireAt(enemy.x, enemy.z); }
}

Para mudar tudo, copie a classe inteira e troque o nome.

// Como o Drone funciona: este é o código que new Drone() executa.
// Para mudar, crie class MeuDrone extends Drone e reescreva só o método
// que quiser (followOwner, attackTarget, guardOwner, repairOwner ou aim).
class Drone extends Helper {
  get kind() { return "drone"; }

  // O loop do drone: a cada turno, o programa do modo que o robô escolheu.
  run() {
    while (true) {
      const state = this.scan();
      if (this.mode === "attack") this.attackTarget(state);
      else if (this.mode === "guard") this.guardOwner(state);
      else if (this.mode === "repair") this.repairOwner(state);
      else this.followOwner(state);
    }
  }

  // Orbita o dono e atira no inimigo mais próximo que estiver no alcance.
  followOwner(state) {
    this.follow(4);
    const enemy = state.enemies.find(e => e.distance <= state.me.limits.range);
    if (enemy) this.aim(state, enemy);
  }

  // Fica a 8 do alvo (this.target) e atira nele; sem vê-lo, segue o dono.
  attackTarget(state) {
    const target = state.enemies.find(e => e.id === this.target);
    if (!target) return this.followOwner(state);
    const dx = state.me.x - target.x, dz = state.me.z - target.z;
    const distance = Math.max(Math.sqrt(dx * dx + dz * dz), 1e-9);
    this.goTo(target.x + dx / distance * 8, target.z + dz / distance * 8);
    if (target.distance <= state.me.limits.range) this.aim(state, target);
  }

  // Fica entre o dono e o inimigo mais perto dele, com escudo (não atira).
  guardOwner(state) {
    let threat = null;
    for (const e of state.enemies) {
      if (!threat || e.ownerDistance < threat.ownerDistance || (e.ownerDistance === threat.ownerDistance && e.id < threat.id)) threat = e;
    }
    if (threat) {
      // Vários drones protegendo se abrem em leque na linha de tiro.
      const spread = (state.me.index - (state.me.count - 1) / 2) * 0.55;
      const angle = Math.atan2(threat.x - state.owner.x, threat.z - state.owner.z) + spread;
      this.goTo(state.owner.x + Math.sin(angle) * 2.9, state.owner.z + Math.cos(angle) * 2.9);
    } else {
      this.follow(2.9);
    }
    this.shield();
  }

  // Fica perto do dono e devolve vida a ele (gasta a energia do dono).
  repairOwner(state) {
    this.follow(2.6);
    if (state.owner.health < state.owner.maxHealth) this.repair();
  }

  // Atira onde o inimigo vai estar quando o tiro chegar.
  aim(state, enemy) {
    let x = enemy.x, z = enemy.z;
    for (let i = 0; i < 2; i++) {
      const dx = x - state.me.x, dz = z - state.me.z;
      const flight = Math.sqrt(dx * dx + dz * dz) / state.me.limits.bulletSpeed;
      x = enemy.x + Math.sin(enemy.heading) * enemy.velocity * flight;
      z = enemy.z + Math.cos(enemy.heading) * enemy.velocity * flight;
    }
    this.fireAt(x, z);
  }
}

Um drone com o seu próprio código

O ajudante segue o mesmo padrão do robô: um run() chamado uma vez, com o loop dele, e scan() a cada turno.

  • state.me é o drone (posição, vida e limits: speed, range, bulletSpeed…), state.owner é o seu robô e state.enemies traz os inimigos que ele enxerga.
  • Comandos: goTo(x, z), follow(), fireAt(x, z), shield() e repair() (Python, Ruby e Lua: go_to, fire_at…).
  • Um turno sem nenhum comando deixa o drone parado. super.run() (Python super().run(), Ruby super, Lua Drone.run(self)) usa o programa pronto.
  • Cada drone roda separado do robô: os dois conversam pelo mode e pelo target. O jogo aplica os limites do drone (velocidade, alcance, cadência) a qualquer código, e cada drone tem o próprio limite de processamento por turno.

Na batalha

this.helpers guarda as instâncias na ordem declarada; um drone destruído fica na lista com alive falso. Os drones inimigos que o radar vê ficam em state.helpers (com owner, mode, distance e bearing); eles não entram em state.scanned. Eventos: hitHelper (seu tiro acertou um drone) e helperDestroyed (um drone seu caiu).