trunk/bwapi/BWAPI/Source/BW/OrderTypes.h

Go to the documentation of this file.

#pragma once

#include <Util/Types.h>

#include <BWAPI/UnitType.h>
#include <BWAPI/Position.h>
#include <BWAPI/Unit.h>

#include "PositionUnitTarget.h"
#include "Race.h"
#include <BW/TilePosition.h>

namespace BWAPI { class UnitImpl; }
#pragma pack(1)
namespace BW
{
  namespace Orders
  {
    class Attack
    {
      public :
        Attack(const BW::Position& target, int order, bool queued = false);
        Attack(int x, int y, int order, bool queued = false);
        Attack(const BWAPI::Position& target, int order, bool queued = false);
        Attack(BWAPI::Unit* target, int order, bool queued = false);
        Attack(const PositionUnitTarget& target, int order, bool queued = false);
      private :
        u8 always0x15;
        BW::PositionUnitTarget target;
        u16 always0xe4;
        u8 order;
        u8 type;
    };
    class RightClick
    {
      public :
        RightClick(const BW::Position& target, bool queued = false);
        RightClick(int x, int y, bool queued = false);
        RightClick(BWAPI::Unit* target, bool queued = false);
        RightClick(const PositionUnitTarget& target, bool queued = false);
      private :
        u8 always0x14;
        BW::PositionUnitTarget target;
        u16 always0xe4;
        u8  type;
    };
    class SelectAdd
    {
      public :
        SelectAdd(int count, BWAPI::UnitImpl **units);
        SelectAdd(int count, BW::Unit **units);
        u8         always0x0A;
        u8         targCount;
        UnitTarget targets[12];
        u32        size;
    };
    class Select
    {
      public :
        Select(int count, BWAPI::UnitImpl **units);
        Select(int count, BW::Unit **units);
        Select(const std::vector<BW::Unit*> &vUnits);
        Select(const std::vector<BWAPI::UnitImpl*> &vUnits);
        u8         always0x09;
        u8         targCount;
        UnitTarget targets[12];
        u32        size;
    };
    class TrainUnit
    {
      public :
        TrainUnit(int type);
        u8 always0x1f;
        u16 type;
    };
    class TrainFighter
    {
      public :
        TrainFighter();
        u8 always0x27;
    };
    class MakeBuilding
    {
      public :
        MakeBuilding(BW::TilePosition position, int type);
        MakeBuilding(int tileX, int tileY, int type);
        u8 always0x0c;
        u8 raceDependant;
        BW::TilePosition position;
        u16 type;
    };

    class PlaceCOP
    {
      public :
        PlaceCOP(BW::TilePosition position, int type);
        PlaceCOP(int x, int y, int type);
        u8 always0x0c;
        u8 always0x9B;
        BW::TilePosition position;
        u16 type;
    };

    class Invent
    {
      public :
        Invent(int type);
        u8 always0x30;
        u8 tech;
    };
    class Upgrade
    {
      public :
        Upgrade(int upgrade);
        u8 always0x32;
        u8 upgrade;
    };
    class MakeAddon
    {
      public :
        MakeAddon(BW::TilePosition position, int type);
        MakeAddon(BWAPI::TilePosition position, int type);
        MakeAddon(int tileX, int tileY, int type);
        u8 always0x0c;
        u8 always0x24;
        BW::TilePosition position;
        u16 type;
    };
    class MakeNydusExit
    {
      public :
        MakeNydusExit(BW::TilePosition position);
        MakeNydusExit(int tileX, int tileY);
        u8 always0x0c;
        u8 always0x2E;
        BW::TilePosition position;
        u16 type;
    };
    class ChangeSlot
    {
      public :
      typedef enum Slot
        {
          Computer = 0,
          Open = 1,
          Closed = 2
        };
        ChangeSlot(Slot slot, int slotID);
      private :
        u8 always0x44;
        u8 slotID;
        Slot slot;
    };
    class RequestChangeRace
    {
      public :
        RequestChangeRace(int slot, int slotID);
      private :
        u8 always0x41;
        u8 slotID;
        u8 race;
    };
    class UpdateSlot
    {
    public:
      UpdateSlot(int slot, int stormPlayerID, int owner, int newRace, int team);
    private:
      u8 always0x3E;
      u8 bSlot;
      u8 bStormPlayerID;
      u8 nType;
      u8 bNewRace;
      u8 nTeam;
    };
    class StartGame
    {
      public :
        StartGame();
      private :
        u8 always0x3c;
    };
    class PauseGame
    {
      public :
        PauseGame();
      private :
        u8 always0x10;
    };
    class ResumeGame
    {
      public :
        ResumeGame();
      private :
        u8 always0x11;
    };
    class LeaveGame
    {
      public :
        LeaveGame(int type);
      private :
        u8 always0x57;
        u8 type;
    };

    class MergeDarkArchon
    {
      public :
        MergeDarkArchon();
      private :
        u8 always0x5A;
    };

    class MergeArchon
    {
      public :
        MergeArchon();
      private :
        u8 always0x2A;
    };

    class MinimapPing
    {
      public :
        MinimapPing(BW::Position position);
        MinimapPing(BWAPI::Position position);
        MinimapPing(int x, int y);
      private :
        u8 always0x58;
        BW::Position position;
    };

    class UseStimPack
    {
      public :
        UseStimPack();
      private :
        u8 always0x36;
    };

    class BuildingMorph
    {
      public :
        BuildingMorph(int type);
        u8 always0x35;
        u16 type;
    };

    class CancelAddon
    {
      public :
        CancelAddon();
      private :
        u8 always0x34;
    };

    class CancelUpgrade
    {
      public :
        CancelUpgrade();
      private :
        u8 always0x33;
    };

    class CancelResearch
    {
      public :
        CancelResearch();
      private :
        u8 always0x31;
    };

    class CancelNuke
    {
      public :
        CancelNuke();
      private :
        u8 always0x2E;
    };

    class Lift
    {
      public :
        Lift();
      private :
        u8 always0x2F;
        u32 unknown;
    };

    class Land
    {
      public :
        Land(BW::TilePosition position, int type);
        Land(int x, int y, int type);
      private :
        u8 always0x0C;
        u8 always0x47;
        BW::TilePosition position;
        u16 type;
    };

    class Burrow
    {
      public :
        Burrow();
      private :
        u8 always0x2C;
        u8 unused;
    };

    class Unburrow
    {
      public :
        Unburrow();
      private :
        u8 always0x2D;
        u8 unused;
    };

    class HoldPosition
    {
      public :
        HoldPosition(bool queued = false);
      private :
        u8 always0x2B;
        u8 type;
    };

    class UnloadUnit
    {
      public :
        UnloadUnit(BWAPI::Unit* unload);
        u8 always0x29;
        UnitTarget target;
    };

    class UnloadAll
    {
      public :
        UnloadAll();
      private :
        u8 always0x28;
        u8 unused;
    };

    class Siege
    {
      public :
        Siege();
      private :
        u8 always0x26;
        u8 unused;
    };

    class Unsiege
    {
      public :
        Unsiege();
      private :
        u8 always0x25;
        u8 unused;
    };

    class UnitMorph
    {
      public :
        UnitMorph(int type);
        u8 always0x23;
        u16 type;
    };

    class Cloak
    {
      public :
        Cloak();
      private :
        u8 always0x21;
        u8 unused;
    };

    class Decloak
    {
      public :
        Decloak();
      private :
        u8 always0x22;
        u8 unused;
    };

    class ReturnCargo
    {
      public :
        ReturnCargo(bool queued = false);
      private :
        u8 always0x1E;
        u8 type;
    };

    class Stop
    {
      public :
        Stop(bool queued = false);
      private :
        u8 always0x1A;
        u8 type;
    };

    class ReaverStop
    {
      public :
        ReaverStop();
      private :
        u8 always0x1C;
    };

    class CarrierStop
    {
      public :
        CarrierStop();
      private :
        u8 always0x1B;
    };

    class CancelUnitMorph
    {
      public :
        CancelUnitMorph();
      private :
        u8 always0x19;
    };

    class CancelConstruction
    {
      public :
        CancelConstruction();
      private :
        u8 always0x18;
    };

    class CancelTrain
    {
      public :
        CancelTrain(int slot = -2);
      private :
        u8 always0x20;
        s8 slot;
        u8 unknown;
    };

    class UseCheat
    {
      public :
        UseCheat(u32 flags);
      private :
        u8 always0x12;
        u32 flags;
    };

    class RestartGame
    {
      public :
        RestartGame();
      private :
        u8 always0x08;
    };

    class SetAllies
    {
      public :
        SetAllies(u32 allies);
      private :
        u8  always0x0E;
        u32 allies;
    };

    class SetVision
    {
      public :
        SetVision(u16 vision);
      private :
        u8  always0x0D;
        u16 vision;
    };
  } // namespace orders
}; // namespace BW
#pragma pack()