C++ aithread类代码示例

bool Enter_Transport::execute(aithread &thread) const
{
  if ( this->getOpcode() == AISCRIPT::Enum::ENTER_BUNKER || this->getOpcode() == AISCRIPT::Enum::ENTER_TRANSPORT )
  {
    Unitset unitsForTrans( Broodwar->getUnitsInRectangle(thread.getLocation().topLeft, thread.getLocation().bottomRight, 
                            this->getOpcode() == AISCRIPT::Enum::ENTER_BUNKER ? bunkerProc : transProc) );
  
    // Iterate the units that are to enter the bunkers
    for ( auto u : unitsForTrans )
    {
      // Find a bunker closest to the current unit that has space available
      Unit pClosest = u->getClosestUnit( (this->getOpcode() == AISCRIPT::Enum::ENTER_BUNKER ? GetType == UnitTypes::Terran_Bunker : GetType != UnitTypes::Terran_Bunker) &&
                                            IsTransport &&
                                            GetPlayer == Broodwar->self() && 
                                            SpaceRemaining >= u->getType().spaceRequired() );

      if ( pClosest )  // If a bunker was found
        u->rightClick(pClosest);
    }
  }
  else if ( this->getOpcode() == AISCRIPT::Enum::EXIT_TRANSPORT )
  {
    // Normally we are supposed to check the type here, but we don't need to save processing time and can let BWAPI sort it out
    Broodwar->getUnitsInRectangle(thread.getLocation().topLeft, thread.getLocation().bottomRight).unloadAll();
  }

  // Debug and return
  thread.saveDebug(Text::Green, this->getOpcode());
  return true;
}

bool Killable::execute(aithread &thread) const
{
  thread.setFlags(AI_THREAD_KILLABLE);

  // Save debug info and return
  thread.saveDebug(Text::Green, this->getOpcode());
  return true;
}

bool Wait_FinishAttack::execute(aithread &thread) const
{
  // Debug
  thread.saveDebug(Text::Red, this->getOpcode());

  // Check if AI is attacking
  // if ( AIIsAttacking )
  {
    return thread.noretry();
  }
  return thread.retry();
}

bool Wait_Upgrades::execute(aithread &thread) const
{
  // Debug
  thread.saveDebug(Text::Green, this->getOpcode());

  // If upgrades are finished, then move on to next opcode
  if ( MainController.getFlags() & CONTROLLER_UPGRADES_FINISHED )
    return thread.noretry();
  
  // Otherwise retry this opcode
  return thread.retry();
}

bool Harass_Factor::execute(aithread &thread) const
{
  // Parameters
  WORD wUnknown;
  thread.readTuple( std::tie( wUnknown ) );

  // HarassFactor(wUnk);

  // Save debug info and return
  thread.saveDebug(Text::Red, this->getOpcode(), "%u", wUnknown);
  return true;
}

bool Allies_Watch::execute(aithread &thread) const
{
  // Params
  BYTE bExpansionId;
  WORD wBlock;
  thread.readTuple( std::tie(bExpansionId, wBlock) );
  
  // @TODO

  // Save debug info and return
  thread.saveDebug(Text::Red, this->getOpcode(), "%u %04X", bExpansionId, wBlock);
  return true;
}

bool DefenseUse::execute(aithread &thread) const
{
  // Parameters
  BYTE bCount;
  WORD wUnitType;
  thread.readTuple( std::tie(bCount, wUnitType) );

  MainController.DefenseUse(this->getOpcode() - AISCRIPT::Enum::DEFENSEUSE_GG, bCount, wUnitType);

  // Debug and return
  thread.saveDebug(Text::Green, this->getOpcode(), "%u %s", bCount, AISCRIPT::getUnitName(wUnitType) );
  return true;
}

bool Nuke_Rate::execute(aithread &thread) const
{
  // Parameters
  BYTE bNukeRate;
  thread.readTuple( std::tie( bNukeRate ) );

  // Assign to controller
  MainController.bNukeRate = bNukeRate;

  // Save debug info and return
  thread.saveDebug(Text::Green, this->getOpcode());
  return true;
}

bool Default_Min::execute(aithread &thread) const
{
  // Parameters
  BYTE bDefaultMin;
  thread.readTuple( std::tie( bDefaultMin ) );

  // Assign to controller
  MainController.bDefaultMin = bDefaultMin;

  // Save debug info and return
  thread.saveDebug(Text::Green, this->getOpcode());
  return true;
}

bool Guard_Resources::execute(aithread &thread) const
{
  // Retrieve parameters
  WORD wUnitType;
  thread.readTuple( std::tie(wUnitType) );

  // Execution
  // GuardResources(wType);

  // Save debug info and return
  thread.saveDebug(Text::Red, this->getOpcode(), "%s", AISCRIPT::getUnitName(wUnitType));
  return true;
}

bool Panic::execute(aithread &thread) const
{
  // Retrieve parameters
  WORD wOffset;
  thread.readTuple( std::tie(wOffset) );

  // Set panic block
  MainController.wPanicBlock = wOffset;

  // Save debug info and return
  thread.saveDebug(Text::Green, this->getOpcode(), "p_%04X", wOffset);
  return true;
}

bool Place_Guard::execute(aithread &thread) const
{
  // Retrieve parameters
  WORD wUnitType;
  BYTE bGuardType;
  thread.readTuple( std::tie(wUnitType, bGuardType) );

  // Execution
  // this->pTown->PlaceGuard(bGuardType, wUnitType);

  // Save debug info and return
  thread.saveDebug(Text::Red, this->getOpcode(), "%s %u", AISCRIPT::getUnitName(wUnitType), bGuardType);
  return true;
}

bool Move_DT::execute(aithread &thread) const
{
  // Execute
  Unitset myUnits( Broodwar->self()->getUnits() );

  // NOTE: Not actual behaviour. Needs special AI Control & Captain assignment.
  // However this command is not important and serves little purpose.
  myUnits.erase_if(!((GetType == UnitTypes::Protoss_Dark_Templar || GetType == UnitTypes::Hero_Dark_Templar) && Exists && IsCompleted));
  myUnits.move( thread.getLocation().center() );

  // Debug and return
  thread.saveDebug(Text::Yellow, this->getOpcode());
  return true;
}

bool Build::execute(aithread &thread) const
{
  // Retrieve parameters
  BYTE bBuildCount, bPriority;
  WORD wUnitType;
  thread.readTuple( std::tie(bBuildCount, wUnitType, bPriority) );

  //if ( bBuildCount <= 30 && wBuildType < UnitTypes::None )
  //  this->pTown->MacroManagerSet(MACRO_BUILD, bBuildCount, wBuildType, bPriority, false);

  // Save debug info and return
  thread.saveDebug(Text::Red, this->getOpcode(), "%u %s %u", bBuildCount, AISCRIPT::getUnitName(wUnitType), bPriority);
  return true;
}

bool Define_Max::execute(aithread &thread) const
{
  // Retrieve parameters
  BYTE bCount;
  WORD wType;
  thread.readTuple( std::tie(bCount, wType) );

  if ( wType < UnitTypes::None )
    MainController.bDefineMax[wType] = bCount;

  // Save debug info and return
  thread.saveDebug(Text::Green, this->getOpcode(), "%u %s", bCount, AISCRIPT::getUnitName(wType) );
  return true;
}