112 lines
5.1 KiB
C++
112 lines
5.1 KiB
C++
#pragma once
|
|
#include <string>
|
|
#include <BWAPI/Position.h>
|
|
#include <BWAPI/Color.h>
|
|
namespace BWAPI
|
|
{
|
|
class Unit;
|
|
class Player;
|
|
|
|
/** AIModule is a virtual class that is intended to be implemented or inherited by a custom AI class.
|
|
*
|
|
* \note
|
|
* Using BWAPI in a different thread than the default one will produce unexpected results and possibly crash
|
|
* the program. Multi-threaded AIs are possible so long as all BWAPI interaction is limited to the default
|
|
* thread (during one of the call-backs). */
|
|
class AIModule
|
|
{
|
|
public:
|
|
AIModule();
|
|
virtual ~AIModule();
|
|
|
|
/** BWAPI calls this at the start of a match. Typically an AI will execute set up code in this method
|
|
* (initialize data structures, load build orders, etc). */
|
|
virtual void onStart();
|
|
|
|
/** BWAPI calls this at the end of the match. isWinner will be true if the AIModule won the game. If the
|
|
* game is a replay, isWinner will always be false. */
|
|
virtual void onEnd(bool isWinner);
|
|
|
|
/** BWAPI calls this on every logical frame in the game. */
|
|
virtual void onFrame();
|
|
|
|
/** If Flag::UserInput is enabled, BWAPI will call this each time a user enters a message into the chat.
|
|
* */
|
|
virtual void onSendText(std::string text);
|
|
|
|
/** BWAPI calls this when another player sends a message. */
|
|
virtual void onReceiveText(Player* player, std::string text);
|
|
|
|
/** BWAPI calls this when a player leaves the game. */
|
|
virtual void onPlayerLeft(Player* player);
|
|
|
|
/** BWAPI calls this when a nuclear launch has been detected. If the target position is visible, or if
|
|
* Complete Map Information is enabled, the target position will also be provided. If Complete Map
|
|
* Information is disabled and the target position is not visible, target will be set to
|
|
* Positions::Unknown. */
|
|
virtual void onNukeDetect(Position target);
|
|
|
|
/** BWAPI calls this when a unit becomes accessible. */
|
|
virtual void onUnitDiscover(Unit* unit);
|
|
|
|
/** BWAPI calls this when a unit becomes inaccessible. */
|
|
virtual void onUnitEvade(Unit* unit);
|
|
|
|
/** BWAPI calls this the instant a previously invisible unit becomes visible. The complete map
|
|
* information flag has no effect on this callback. */
|
|
virtual void onUnitShow(Unit* unit);
|
|
|
|
/** BWAPI calls this right before a unit becomes invisible, so if you want your non-cheating AI to
|
|
* remember where it last saw a unit, this callback would be a good place to implement it. The complete
|
|
* map information flag has no effect on this callback. */
|
|
virtual void onUnitHide(Unit* unit);
|
|
|
|
/** BWAPI calls this when a unit is created. Note that this is NOT called when a unit changes type
|
|
* (such as larva into egg or egg into drone). Building a refinery/assimilator/extractor will not
|
|
* produce an onUnitCreate call since the vespene geyser changes to the unit type of the
|
|
* refinery/assimilator/extractor. If Complete Map Information is enabled, this will also be called for
|
|
* new units that are hidden by the fog of war. If the unit is visible upon creation, onUnitShow will be
|
|
* called shortly after onUnitCreate is called. */
|
|
virtual void onUnitCreate(Unit* unit);
|
|
|
|
/** BWAPI calls this when a unit dies or otherwise removed from the game (i.e. a mined out mineral
|
|
* patch). When a zerg drone becomes an extractor, the Vespene geyser changes to the Zerg Extractor type
|
|
* and the drone is removed. If Complete Map Information is enabled, this will also be called for units
|
|
* that are hidden by the fog of war. If a unit that was visible gets destroyed, onUnitHide will be
|
|
* called right before onUnitDestroy is called. */
|
|
virtual void onUnitDestroy(Unit* unit);
|
|
|
|
/** BWAPI calls this when a unit changes type, such as from a Zerg Drone to a Zerg Hatchery, or from a
|
|
* Terran Siege Tank Tank Mode to Terran Siege Tank Siege Mode. This is not called when the type changes
|
|
* to or from UnitTypes::Unknown (which happens when a unit becomes visible or invisible). */
|
|
virtual void onUnitMorph(Unit* unit);
|
|
|
|
/** BWAPI calls this when an accessible unit changes ownership. */
|
|
virtual void onUnitRenegade(Unit* unit);
|
|
|
|
// TODO: Add Doxygen documentation
|
|
virtual void onSaveGame(std::string gameName);
|
|
|
|
/** */
|
|
virtual void onUnitComplete(Unit *unit);
|
|
|
|
virtual void onPlayerDropped(Player *player);
|
|
};
|
|
class TournamentModule
|
|
{
|
|
public:
|
|
TournamentModule();
|
|
virtual ~TournamentModule();
|
|
|
|
/** BWAPI calls this any time some Game-related functions are called.
|
|
Return true to allow them, or false to disallow them.
|
|
This includes functions like Game::pauseGame and Game::enableFlag. */
|
|
virtual bool onAction(int actionType, void *parameter = NULL);
|
|
|
|
/** BWAPI calls this when this module was the first to send out its
|
|
tournament advertisement. It can prevent both modules from performing
|
|
the same task if it's necessary. */
|
|
virtual void onFirstAdvertisement();
|
|
};
|
|
}
|