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;
}
bool Player_Ally::execute(aithread &thread) const
{
// @TODO: BWAPI: Unitset::getPlayers for retrieving set of players owning the units, not important
/* can become
unitsInRect( bw->getUnitsInRectangle(location.topLeft, location.bottomRight, GetPlayer != self) ).getPlayers().setAlliance(bOpcode == AISCRIPT::Enum::PLAYER_ALLY);
*/
// Set the alliance of all players who own units inside the thread's execution location
Unitset units( Broodwar->getUnitsInRectangle(thread.getLocation().topLeft, thread.getLocation().bottomRight, GetPlayer != Broodwar->self()) );
for ( auto u = units.begin(); u != units.end(); ++u )
Broodwar->setAlliance(u->getPlayer(), this->getOpcode() == AISCRIPT::Enum::PLAYER_ALLY);
// Debug and return
thread.saveDebug(Text::Green, this->getOpcode());
return true;
}
bool Random_Jump::execute(aithread &thread) const
{
// Retrieve parameters
BYTE bChance;
WORD wOffset;
thread.readTuple( std::tie(bChance, wOffset) );
/// Set the new script offset
if ( (BYTE)rand() <= bChance )
thread.setScriptOffset( wOffset );
// Save debug info and return
thread.saveDebug(Text::Green, this->getOpcode(), "%u p_%04X", bChance, wOffset);
return true;
}
bool Wait_Train::execute(aithread &thread) const
{
// Parameters
BYTE bCount;
WORD wUnitType;
thread.readTuple( std::tie(bCount, wUnitType) );
// Debug
thread.saveDebug(Text::Green, this->getOpcode(), "%u %s", bCount, AISCRIPT::getUnitName(wUnitType) );
// Perform actions
if ( GetStandardUnitCount(wUnitType) < bCount )
return thread.retry();
return thread.noretry();
}
bool If_Dif::execute(aithread &thread) const
{
// Parameters
BYTE bModifier, bValue;
WORD wBlock;
thread.readTuple( std::tie( bModifier, bValue, wBlock ) );
// Compare diff value
BYTE bDiff = MainController.bIfDif;
if ( bModifier ? (bDiff > bValue) : (bDiff < bValue) )
thread.setScriptOffset( wBlock );
// Save debug info and return
thread.saveDebug(Text::Green, this->getOpcode(), "%u %u %04X", bModifier, bValue, wBlock);
return true;
}
bool Capt_Expand::execute(aithread &thread) const
{
// Save debug info and return
thread.saveDebug(Text::Red, this->getOpcode());
return true;
}
bool Return::execute(aithread &thread) const
{
thread.saveDebug(Text::Green, this->getOpcode());
bool result = thread.ret();
// Error handling, kill the script if the callstack is empty
if ( !result )
{
thread.killThread();
thread.noretry();
return false;
}
// Success
return true;
}
bool Debug::execute(aithread &thread) const
{
// Perform independant behaviours
if ( this->getOpcode() == AISCRIPT::Enum::FATAL_ERROR )
{
// Message
Broodwar->sendText("Illegal AI script executed.");
// Debug
thread.saveDebug(Text::Green, this->getOpcode());
// Kill the script
thread.killThread();
thread.noretry();
return false;
}
else if ( this->getOpcode() == AISCRIPT::Enum::DEBUG )
{
// Read parameters
WORD wJump;
thread.readTuple( std::tie( wJump) );
// Send the message
Broodwar->sendText("%s", &pbAIScriptBinary[thread.getScriptOffset()] );
// Jump to offset
thread.setScriptOffset(wJump);
thread.saveDebug(Text::Green, this->getOpcode(), "p_%X %s", wJump, &pbAIScriptBinary[thread.getScriptOffset()]);
}
return true;
}
bool Target_Expansion::execute(aithread &thread) const
{
// Set campaign flag
MainController.setFlags(CONTROLLER_TARGET_EXPANSION);
// Save debug info and return
thread.saveDebug(Text::Green, this->getOpcode());
return true;
}
bool Start_Campaign::execute(aithread &thread) const
{
// Set campaign flag
MainController.setFlags(CONTROLLER_IS_CAMPAIGN);
// Save debug info and return
thread.saveDebug(Text::Green, this->getOpcode());
return true;
}
bool Prep_Down::execute(aithread &thread) const
{
// Retrieve parameters
BYTE bSaveCount, bMinCount;
WORD wUnitType;
thread.readTuple( std::tie(bSaveCount, bMinCount, wUnitType) );
// Get count
int count = GetStandardUnitCount(wUnitType, false) - bSaveCount;
if ( count < bMinCount )
count = bMinCount;
// Add to attack group
// AI_AttackAdd(count, wUnitType);
// Save debug info and return
thread.saveDebug(Text::Red, this->getOpcode(), "%u %u %s", bSaveCount, bMinCount, AISCRIPT::getUnitName(wUnitType));
return true;
}
bool Train::execute(aithread &thread) const
{
// Parameters
BYTE bCount;
WORD wUnitType;
thread.readTuple( std::tie(bCount, wUnitType) );
// Debug
thread.saveDebug(Text::Green, this->getOpcode(), "%u %s", bCount, AISCRIPT::getUnitName(wUnitType) );
// Perform actions
if ( GetStandardUnitCount(wUnitType, this->getOpcode() != AISCRIPT::Enum::TRAIN) < bCount )
{
MainController.wWaitForType = (int)wUnitType + 1;
if ( this->getOpcode() != AISCRIPT::Enum::DO_MORPH )
return thread.retry();
}
return thread.noretry();
}
bool Farms_Timing::execute(aithread &thread) const
{
if ( this->getOpcode() == AISCRIPT::Enum::FARMS_NOTIMING ) // off
MainController.setFlags(CONTROLLER_FARMS_TIMING_OFF);
else // on
MainController.clearFlags(CONTROLLER_FARMS_TIMING_OFF);
// Debug and return
thread.saveDebug(Text::Green, this->getOpcode());
return true;
}
bool Default_Build::execute(aithread &thread) const
{
if ( this->getOpcode() == AISCRIPT::Enum::DEFAULTBUILD_OFF ) // off
MainController.setFlags(CONTROLLER_DEFAULT_BUILD_OFF);
else // on
MainController.clearFlags(CONTROLLER_DEFAULT_BUILD_OFF);
// Debug and return
thread.saveDebug(Text::Green, this->getOpcode());
return true;
}
bool Check_Transports::execute(aithread &thread) const
{
if ( this->getOpcode() == AISCRIPT::Enum::TRANSPORTS_OFF ) // off
MainController.setFlags(CONTROLLER_TRANSPORTS_OFF);
else // on
MainController.clearFlags(CONTROLLER_TRANSPORTS_OFF);
// Debug and return
thread.saveDebug(Text::Green, this->getOpcode());
return true;
}
bool Kill_Thread::execute(aithread &thread) const
{
for ( auto i = aiThreadList.begin(); i != aiThreadList.end(); ++i )
{
if ( i->getFlags() & AI_THREAD_KILLABLE )
i->killThread();
}
// Save debug info and return
thread.saveDebug(Text::Green, this->getOpcode());
return true;
}
