bwapi-sys 0.1.2

/* automatically generated by rust-bindgen */

#![allow(improper_ctypes, non_snake_case)]


/// These are interface-only types with provided API
/// You should use them only by pointer
pub struct Unit;
pub struct Player;
pub struct Region;
pub struct Force;
pub struct Bullet;
pub struct Game;
pub struct Client;
/// These are value-only structs with no API
/// You should implement API on your own
#[repr(C)]
#[derive(Copy, Clone)]
pub struct Race {
    pub id: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct Order {
    pub id: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct Color {
    pub color: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct TextSize {
    pub size: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct CoordinateType {
    pub id: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct MouseButton {
    pub id: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct KeyButton {
    pub id: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct Error {
    pub id: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct UnitType {
    pub id: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct PlayerType {
    pub id: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WeaponType {
    pub id: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct TechType {
    pub id: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct UpgradeType {
    pub id: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct UnitCommandType {
    pub id: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct BulletType {
    pub id: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GameType {
    pub id: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct Position {
    pub x: ::std::os::raw::c_int,
    pub y: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct TilePosition {
    pub x: ::std::os::raw::c_int,
    pub y: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct WalkPosition {
    pub x: ::std::os::raw::c_int,
    pub y: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct UnitCommand {
    pub unit: *mut Unit,
    pub type_: UnitCommandType,
    pub target: *mut Unit,
    pub x: ::std::os::raw::c_int,
    pub y: ::std::os::raw::c_int,
    pub extra: ::std::os::raw::c_int,
}
pub struct BwString;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct EventType {
    pub id: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct Event {
    pub position: Position,
    pub text: *mut ::std::os::raw::c_void,
    pub unit: *mut Unit,
    pub player: *mut Player,
    pub type_: EventType,
    pub winner: bool,
}
pub struct Iterator;
pub struct UnitIterator;
pub struct PlayerIterator;
pub struct ForceIterator;
pub struct BulletIterator;
pub struct RegionIterator;
pub struct PositionIterator;
pub struct TilePositionIterator;
pub struct EventIterator;
pub struct UnitTypeIterator;
pub type UnaryUnitFilter = ::std::option::Option<unsafe extern "C" fn(unit: *mut Unit) -> bool>;
pub type BestUnitFilter =
    ::std::option::Option<unsafe extern "C" fn(left: *mut Unit, right: *mut Unit) -> *mut Unit>;
extern "C" {
    pub fn BwString_new(
        data: *const ::std::os::raw::c_char,
        len: ::std::os::raw::c_int,
    ) -> *mut BwString;
}
extern "C" {
    pub fn BwString_data(self_: *const BwString) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn BwString_len(self_: *const BwString) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn BwString_release(self_: *mut BwString);
}
extern "C" {
    pub fn Iterator_valid(self_: *const Iterator) -> bool;
}
extern "C" {
    pub fn Iterator_get(self_: *const Iterator) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn Iterator_next(self_: *mut Iterator);
}
extern "C" {
    pub fn Iterator_release(self_: *mut Iterator);
}
extern "C" {
    /// BWAPIC_setGame must be called from gameInit to initialize BWAPI::BroodwarPtr
    pub fn BWAPIC_setGame(game: *mut Game);
}
extern "C" {
    pub fn BWAPIC_getGame() -> *mut Game;
}
extern "C" {
    pub fn Game_getForces(self_: *mut Game) -> *mut ForceIterator;
}
extern "C" {
    pub fn Game_getPlayers(self_: *mut Game) -> *mut PlayerIterator;
}
extern "C" {
    pub fn Game_getAllUnits(self_: *mut Game) -> *mut UnitIterator;
}
extern "C" {
    pub fn Game_getMinerals(self_: *mut Game) -> *mut UnitIterator;
}
extern "C" {
    pub fn Game_getGeysers(self_: *mut Game) -> *mut UnitIterator;
}
extern "C" {
    pub fn Game_getNeutralUnits(self_: *mut Game) -> *mut UnitIterator;
}
extern "C" {
    pub fn Game_getStaticMinerals(self_: *mut Game) -> *mut UnitIterator;
}
extern "C" {
    pub fn Game_getStaticGeysers(self_: *mut Game) -> *mut UnitIterator;
}
extern "C" {
    pub fn Game_getStaticNeutralUnits(self_: *mut Game) -> *mut UnitIterator;
}
extern "C" {
    pub fn Game_getBullets(self_: *mut Game) -> *mut BulletIterator;
}
extern "C" {
    pub fn Game_getNukeDots(self_: *mut Game) -> *mut PositionIterator;
}
extern "C" {
    pub fn Game_getEvents(self_: *mut Game) -> *mut EventIterator;
}
extern "C" {
    pub fn Game_getForce(self_: *mut Game, forceID: ::std::os::raw::c_int) -> *mut Force;
}
extern "C" {
    pub fn Game_getPlayer(self_: *mut Game, playerID: ::std::os::raw::c_int) -> *mut Player;
}
extern "C" {
    pub fn Game_getUnit(self_: *mut Game, unitID: ::std::os::raw::c_int) -> *mut Unit;
}
extern "C" {
    pub fn Game_indexToUnit(self_: *mut Game, unitIndex: ::std::os::raw::c_int) -> *mut Unit;
}
extern "C" {
    pub fn Game_getRegion(self_: *mut Game, regionID: ::std::os::raw::c_int) -> *mut Region;
}
extern "C" {
    pub fn Game_getGameType(self_: *mut Game) -> GameType;
}
extern "C" {
    pub fn Game_getLatency(self_: *mut Game) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Game_getFrameCount(self_: *mut Game) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Game_getReplayFrameCount(self_: *mut Game) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Game_getFPS(self_: *mut Game) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Game_getAverageFPS(self_: *mut Game) -> f64;
}
extern "C" {
    pub fn Game_getMousePosition(self_: *mut Game) -> Position;
}
extern "C" {
    pub fn Game_getMouseState(self_: *mut Game, button: MouseButton) -> bool;
}
extern "C" {
    pub fn Game_getKeyState(self_: *mut Game, key: KeyButton) -> bool;
}
extern "C" {
    pub fn Game_getScreenPosition(self_: *mut Game) -> Position;
}
extern "C" {
    pub fn Game_setScreenPosition(self_: *mut Game, p: Position);
}
extern "C" {
    pub fn Game_pingMinimap(self_: *mut Game, p: Position);
}
extern "C" {
    pub fn Game_isFlagEnabled(self_: *mut Game, flag: ::std::os::raw::c_int) -> bool;
}
extern "C" {
    pub fn Game_enableFlag(self_: *mut Game, flag: ::std::os::raw::c_int);
}
extern "C" {
    pub fn Game_getUnitsOnTile(
        self_: *mut Game,
        tile: TilePosition,
        pred: UnaryUnitFilter,
    ) -> *mut UnitIterator;
}
extern "C" {
    pub fn Game_getUnitsInRectangle(
        self_: *mut Game,
        topLeft: Position,
        bottomRight: Position,
        pred: UnaryUnitFilter,
    ) -> *mut UnitIterator;
}
extern "C" {
    pub fn Game_getUnitsInRadius(
        self_: *mut Game,
        center: Position,
        radius: ::std::os::raw::c_int,
        pred: UnaryUnitFilter,
    ) -> *mut UnitIterator;
}
extern "C" {
    pub fn Game_getClosestUnit(
        self_: *mut Game,
        center: Position,
        pred: UnaryUnitFilter,
        radius: ::std::os::raw::c_int,
    ) -> *mut Unit;
}
extern "C" {
    pub fn Game_getClosestUnitInRectangle(
        self_: *mut Game,
        center: Position,
        pred: UnaryUnitFilter,
        left: ::std::os::raw::c_int,
        top: ::std::os::raw::c_int,
        right: ::std::os::raw::c_int,
        bottom: ::std::os::raw::c_int,
    ) -> *mut Unit;
}
extern "C" {
    pub fn Game_getBestUnit(
        self_: *mut Game,
        best: BestUnitFilter,
        pred: UnaryUnitFilter,
        center: Position,
        radius: ::std::os::raw::c_int,
    ) -> *mut Unit;
}
extern "C" {
    pub fn Game_getLastError(self_: *mut Game) -> Error;
}
extern "C" {
    pub fn Game_setLastError(self_: *mut Game, e: Error) -> bool;
}
extern "C" {
    pub fn Game_mapWidth(self_: *mut Game) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Game_mapHeight(self_: *mut Game) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Game_mapFileName(self_: *mut Game) -> *mut BwString;
}
extern "C" {
    pub fn Game_mapPathName(self_: *mut Game) -> *mut BwString;
}
extern "C" {
    pub fn Game_mapName(self_: *mut Game) -> *mut BwString;
}
extern "C" {
    pub fn Game_mapHash(self_: *mut Game) -> *mut BwString;
}
extern "C" {
    pub fn Game_isWalkable(self_: *mut Game, position: WalkPosition) -> bool;
}
extern "C" {
    pub fn Game_getGroundHeight(self_: *mut Game, position: TilePosition) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Game_isBuildable(
        self_: *mut Game,
        position: TilePosition,
        includeBuildings: bool,
    ) -> bool;
}
extern "C" {
    pub fn Game_isVisible(self_: *mut Game, position: TilePosition) -> bool;
}
extern "C" {
    pub fn Game_isExplored(self_: *mut Game, position: TilePosition) -> bool;
}
extern "C" {
    pub fn Game_hasCreep(self_: *mut Game, position: TilePosition) -> bool;
}
extern "C" {
    pub fn Game_hasPowerPrecise(self_: *mut Game, position: Position, unitType: UnitType) -> bool;
}
extern "C" {
    pub fn Game_hasPower(self_: *mut Game, position: TilePosition, unitType: UnitType) -> bool;
}
extern "C" {
    pub fn Game_hasPowerWH(
        self_: *mut Game,
        position: TilePosition,
        tileWidth: ::std::os::raw::c_int,
        tileHeight: ::std::os::raw::c_int,
        unitType: UnitType,
    ) -> bool;
}
extern "C" {
    pub fn Game_canBuildHere(
        self_: *mut Game,
        position: TilePosition,
        type_: UnitType,
        builder: *mut Unit,
        checkExplored: bool,
    ) -> bool;
}
extern "C" {
    pub fn Game_canMake(self_: *mut Game, type_: UnitType, builder: *mut Unit) -> bool;
}
extern "C" {
    pub fn Game_canResearch(
        self_: *mut Game,
        type_: TechType,
        unit: *mut Unit,
        checkCanIssueCommandType: bool,
    ) -> bool;
}
extern "C" {
    pub fn Game_canUpgrade(
        self_: *mut Game,
        type_: UpgradeType,
        unit: *mut Unit,
        checkCanIssueCommandType: bool,
    ) -> bool;
}
extern "C" {
    pub fn Game_getStartLocations(self_: *mut Game) -> *mut TilePositionIterator;
}
extern "C" {
    pub fn Game_printf(self_: *mut Game, format: *const ::std::os::raw::c_char, ...);
}
extern "C" {
    pub fn Game_sendText(self_: *mut Game, format: *const ::std::os::raw::c_char, ...);
}
extern "C" {
    pub fn Game_sendTextEx(
        self_: *mut Game,
        toAllies: bool,
        format: *const ::std::os::raw::c_char,
        ...
    );
}
extern "C" {
    pub fn Game_isInGame(self_: *mut Game) -> bool;
}
extern "C" {
    pub fn Game_isMultiplayer(self_: *mut Game) -> bool;
}
extern "C" {
    pub fn Game_isBattleNet(self_: *mut Game) -> bool;
}
extern "C" {
    pub fn Game_isPaused(self_: *mut Game) -> bool;
}
extern "C" {
    pub fn Game_isReplay(self_: *mut Game) -> bool;
}
extern "C" {
    pub fn Game_pauseGame(self_: *mut Game);
}
extern "C" {
    pub fn Game_resumeGame(self_: *mut Game);
}
extern "C" {
    pub fn Game_leaveGame(self_: *mut Game);
}
extern "C" {
    pub fn Game_restartGame(self_: *mut Game);
}
extern "C" {
    pub fn Game_setLocalSpeed(self_: *mut Game, speed: ::std::os::raw::c_int);
}
extern "C" {
    pub fn Game_issueCommand(
        self_: *mut Game,
        units: *mut UnitIterator,
        command: UnitCommand,
    ) -> bool;
}
extern "C" {
    pub fn Game_getSelectedUnits(self_: *mut Game) -> *mut UnitIterator;
}
extern "C" {
    pub fn Game_self(self_: *mut Game) -> *mut Player;
}
extern "C" {
    pub fn Game_enemy(self_: *mut Game) -> *mut Player;
}
extern "C" {
    pub fn Game_neutral(self_: *mut Game) -> *mut Player;
}
extern "C" {
    pub fn Game_allies(self_: *mut Game) -> *mut PlayerIterator;
}
extern "C" {
    pub fn Game_enemies(self_: *mut Game) -> *mut PlayerIterator;
}
extern "C" {
    pub fn Game_observers(self_: *mut Game) -> *mut PlayerIterator;
}
extern "C" {
    pub fn Game_setTextSize(self_: *mut Game, size: TextSize);
}
extern "C" {
    pub fn Game_drawText(
        self_: *mut Game,
        ctype: CoordinateType,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
        format: *const ::std::os::raw::c_char,
        ...
    );
}
extern "C" {
    pub fn Game_drawTextMap(
        self_: *mut Game,
        p: Position,
        format: *const ::std::os::raw::c_char,
        ...
    );
}
extern "C" {
    pub fn Game_drawTextMouse(
        self_: *mut Game,
        p: Position,
        format: *const ::std::os::raw::c_char,
        ...
    );
}
extern "C" {
    pub fn Game_drawTextScreen(
        self_: *mut Game,
        p: Position,
        format: *const ::std::os::raw::c_char,
        ...
    );
}
extern "C" {
    pub fn Game_drawBox(
        self_: *mut Game,
        ctype: CoordinateType,
        left: ::std::os::raw::c_int,
        top: ::std::os::raw::c_int,
        right: ::std::os::raw::c_int,
        bottom: ::std::os::raw::c_int,
        color: Color,
        isSolid: bool,
    );
}
extern "C" {
    pub fn Game_drawBoxMap(
        self_: *mut Game,
        leftTop: Position,
        rightBottom: Position,
        color: Color,
        isSolid: bool,
    );
}
extern "C" {
    pub fn Game_drawBoxMouse(
        self_: *mut Game,
        leftTop: Position,
        rightBottom: Position,
        color: Color,
        isSolid: bool,
    );
}
extern "C" {
    pub fn Game_drawBoxScreen(
        self_: *mut Game,
        leftTop: Position,
        rightBottom: Position,
        color: Color,
        isSolid: bool,
    );
}
extern "C" {
    pub fn Game_drawTriangle(
        self_: *mut Game,
        ctype: CoordinateType,
        ax: ::std::os::raw::c_int,
        ay: ::std::os::raw::c_int,
        bx: ::std::os::raw::c_int,
        by: ::std::os::raw::c_int,
        cx: ::std::os::raw::c_int,
        cy: ::std::os::raw::c_int,
        color: Color,
        isSolid: bool,
    );
}
extern "C" {
    pub fn Game_drawTriangleMap(
        self_: *mut Game,
        a: Position,
        b: Position,
        c: Position,
        color: Color,
        isSolid: bool,
    );
}
extern "C" {
    pub fn Game_drawTriangleMouse(
        self_: *mut Game,
        a: Position,
        b: Position,
        c: Position,
        color: Color,
        isSolid: bool,
    );
}
extern "C" {
    pub fn Game_drawTriangleScreen(
        self_: *mut Game,
        a: Position,
        b: Position,
        c: Position,
        color: Color,
        isSolid: bool,
    );
}
extern "C" {
    pub fn Game_drawCircle(
        self_: *mut Game,
        ctype: CoordinateType,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
        radius: ::std::os::raw::c_int,
        color: Color,
        isSolid: bool,
    );
}
extern "C" {
    pub fn Game_drawCircleMap(
        self_: *mut Game,
        p: Position,
        radius: ::std::os::raw::c_int,
        color: Color,
        isSolid: bool,
    );
}
extern "C" {
    pub fn Game_drawCircleMouse(
        self_: *mut Game,
        p: Position,
        radius: ::std::os::raw::c_int,
        color: Color,
        isSolid: bool,
    );
}
extern "C" {
    pub fn Game_drawCircleScreen(
        self_: *mut Game,
        p: Position,
        radius: ::std::os::raw::c_int,
        color: Color,
        isSolid: bool,
    );
}
extern "C" {
    pub fn Game_drawEllipse(
        self_: *mut Game,
        ctype: CoordinateType,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
        xrad: ::std::os::raw::c_int,
        yrad: ::std::os::raw::c_int,
        color: Color,
        isSolid: bool,
    );
}
extern "C" {
    pub fn Game_drawEllipseMap(
        self_: *mut Game,
        p: Position,
        xrad: ::std::os::raw::c_int,
        yrad: ::std::os::raw::c_int,
        color: Color,
        isSolid: bool,
    );
}
extern "C" {
    pub fn Game_drawEllipseMouse(
        self_: *mut Game,
        p: Position,
        xrad: ::std::os::raw::c_int,
        yrad: ::std::os::raw::c_int,
        color: Color,
        isSolid: bool,
    );
}
extern "C" {
    pub fn Game_drawEllipseScreen(
        self_: *mut Game,
        p: Position,
        xrad: ::std::os::raw::c_int,
        yrad: ::std::os::raw::c_int,
        color: Color,
        isSolid: bool,
    );
}
extern "C" {
    pub fn Game_drawDot(
        self_: *mut Game,
        ctype: CoordinateType,
        x: ::std::os::raw::c_int,
        y: ::std::os::raw::c_int,
        color: Color,
    );
}
extern "C" {
    pub fn Game_drawDotMap(self_: *mut Game, p: Position, color: Color);
}
extern "C" {
    pub fn Game_drawDotMouse(self_: *mut Game, p: Position, color: Color);
}
extern "C" {
    pub fn Game_drawDotScreen(self_: *mut Game, p: Position, color: Color);
}
extern "C" {
    pub fn Game_drawLine(
        self_: *mut Game,
        ctype: CoordinateType,
        x1: ::std::os::raw::c_int,
        y1: ::std::os::raw::c_int,
        x2: ::std::os::raw::c_int,
        y2: ::std::os::raw::c_int,
        color: Color,
    );
}
extern "C" {
    pub fn Game_drawLineMap(self_: *mut Game, a: Position, b: Position, color: Color);
}
extern "C" {
    pub fn Game_drawLineMouse(self_: *mut Game, a: Position, b: Position, color: Color);
}
extern "C" {
    pub fn Game_drawLineScreen(self_: *mut Game, a: Position, b: Position, color: Color);
}
extern "C" {
    pub fn Game_getLatencyFrames(self_: *mut Game) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Game_getLatencyTime(self_: *mut Game) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Game_getRemainingLatencyFrames(self_: *mut Game) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Game_getRemainingLatencyTime(self_: *mut Game) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Game_getRevision(self_: *mut Game) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Game_getClientVersion(self_: *mut Game) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Game_isDebug(self_: *mut Game) -> bool;
}
extern "C" {
    pub fn Game_isLatComEnabled(self_: *mut Game) -> bool;
}
extern "C" {
    pub fn Game_setLatCom(self_: *mut Game, isEnabled: bool);
}
extern "C" {
    pub fn Game_isGUIEnabled(self_: *mut Game) -> bool;
}
extern "C" {
    pub fn Game_setGUI(self_: *mut Game, enabled: bool);
}
extern "C" {
    pub fn Game_getInstanceNumber(self_: *mut Game) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Game_getAPM(self_: *mut Game, includeSelects: bool) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Game_setMap(self_: *mut Game, mapFileName: *const ::std::os::raw::c_char) -> bool;
}
extern "C" {
    pub fn Game_setFrameSkip(self_: *mut Game, frameSkip: ::std::os::raw::c_int);
}
extern "C" {
    pub fn Game_hasPath(self_: *mut Game, source: Position, destination: Position) -> bool;
}
extern "C" {
    pub fn Game_setAlliance(
        self_: *mut Game,
        player: *mut Player,
        allied: bool,
        alliedVictory: bool,
    ) -> bool;
}
extern "C" {
    pub fn Game_setVision(self_: *mut Game, player: *mut Player, enabled: bool) -> bool;
}
extern "C" {
    pub fn Game_elapsedTime(self_: *mut Game) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Game_setCommandOptimizationLevel(self_: *mut Game, level: ::std::os::raw::c_int);
}
extern "C" {
    pub fn Game_countdownTimer(self_: *mut Game) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Game_getAllRegions(self_: *mut Game) -> *mut RegionIterator;
}
extern "C" {
    pub fn Game_getRegionAt(self_: *mut Game, position: Position) -> *mut Region;
}
extern "C" {
    pub fn Game_getLastEventTime(self_: *mut Game) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Game_setRevealAll(self_: *mut Game, reveal: bool) -> bool;
}
extern "C" {
    pub fn Game_getBuildLocation(
        self_: *mut Game,
        type_: UnitType,
        desiredPosition: TilePosition,
        maxRange: ::std::os::raw::c_int,
        creep: bool,
    ) -> TilePosition;
}
extern "C" {
    pub fn Game_getDamageFrom(
        self_: *mut Game,
        fromType: UnitType,
        toType: UnitType,
        fromPlayer: *mut Player,
        toPlayer: *mut Player,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Game_getDamageTo(
        self_: *mut Game,
        toType: UnitType,
        fromType: UnitType,
        toPlayer: *mut Player,
        fromPlayer: *mut Player,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Game_getRandomSeed(self_: *mut Game) -> ::std::os::raw::c_uint;
}
extern "C" {
    pub fn Game_registerEvent(
        self_: *mut Game,
        action: ::std::option::Option<unsafe extern "C" fn(arg1: *mut Game)>,
        condition: ::std::option::Option<unsafe extern "C" fn(arg1: *mut Game) -> bool>,
        timesToRun: ::std::os::raw::c_int,
        framesToCheck: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn BWAPIC_getClient() -> *mut Client;
}
extern "C" {
    pub fn Client_isConnected(self_: *mut Client) -> bool;
}
extern "C" {
    pub fn Client_connect(self_: *mut Client) -> bool;
}
extern "C" {
    pub fn Client_disconnect(self_: *mut Client);
}
extern "C" {
    pub fn Client_update(self_: *mut Client);
}
extern "C" {
    pub fn Player_getID(self_: *mut Player) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_getName(self_: *mut Player) -> *mut BwString;
}
extern "C" {
    pub fn Player_getUnits(self_: *mut Player) -> *mut UnitIterator;
}
extern "C" {
    pub fn Player_getRace(self_: *mut Player) -> Race;
}
extern "C" {
    pub fn Player_getType(self_: *mut Player) -> PlayerType;
}
extern "C" {
    pub fn Player_getForce(self_: *mut Player) -> *mut Force;
}
extern "C" {
    pub fn Player_isAlly(self_: *mut Player, player: *mut Player) -> bool;
}
extern "C" {
    pub fn Player_isEnemy(self_: *mut Player, player: *mut Player) -> bool;
}
extern "C" {
    pub fn Player_isNeutral(self_: *mut Player) -> bool;
}
extern "C" {
    pub fn Player_getStartLocation(self_: *mut Player) -> TilePosition;
}
extern "C" {
    pub fn Player_isVictorious(self_: *mut Player) -> bool;
}
extern "C" {
    pub fn Player_isDefeated(self_: *mut Player) -> bool;
}
extern "C" {
    pub fn Player_leftGame(self_: *mut Player) -> bool;
}
extern "C" {
    pub fn Player_minerals(self_: *mut Player) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_gas(self_: *mut Player) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_gatheredMinerals(self_: *mut Player) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_gatheredGas(self_: *mut Player) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_repairedMinerals(self_: *mut Player) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_repairedGas(self_: *mut Player) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_refundedMinerals(self_: *mut Player) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_refundedGas(self_: *mut Player) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_spentMinerals(self_: *mut Player) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_spentGas(self_: *mut Player) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_supplyTotal(self_: *mut Player, race: Race) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_supplyUsed(self_: *mut Player, race: Race) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_allUnitCount(self_: *mut Player, unit: UnitType) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_visibleUnitCount(self_: *mut Player, unit: UnitType) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_completedUnitCount(self_: *mut Player, unit: UnitType) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_incompleteUnitCount(self_: *mut Player, unit: UnitType) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_deadUnitCount(self_: *mut Player, unit: UnitType) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_killedUnitCount(self_: *mut Player, unit: UnitType) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_getUpgradeLevel(
        self_: *mut Player,
        upgrade: UpgradeType,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_hasResearched(self_: *mut Player, tech: TechType) -> bool;
}
extern "C" {
    pub fn Player_isResearching(self_: *mut Player, tech: TechType) -> bool;
}
extern "C" {
    pub fn Player_isUpgrading(self_: *mut Player, upgrade: UpgradeType) -> bool;
}
extern "C" {
    pub fn Player_getColor(self_: *mut Player) -> Color;
}
extern "C" {
    pub fn Player_getTextColor(self_: *mut Player) -> ::std::os::raw::c_char;
}
extern "C" {
    pub fn Player_maxEnergy(self_: *mut Player, unit: UnitType) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_topSpeed(self_: *mut Player, unit: UnitType) -> f64;
}
extern "C" {
    pub fn Player_weaponMaxRange(self_: *mut Player, weapon: WeaponType) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_sightRange(self_: *mut Player, unit: UnitType) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_weaponDamageCooldown(self_: *mut Player, unit: UnitType)
        -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_armor(self_: *mut Player, unit: UnitType) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_damage(self_: *mut Player, wpn: WeaponType) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_getUnitScore(self_: *mut Player) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_getKillScore(self_: *mut Player) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_getBuildingScore(self_: *mut Player) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_getRazingScore(self_: *mut Player) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_getCustomScore(self_: *mut Player) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_isObserver(self_: *mut Player) -> bool;
}
extern "C" {
    pub fn Player_getMaxUpgradeLevel(
        self_: *mut Player,
        upgrade: UpgradeType,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Player_isResearchAvailable(self_: *mut Player, tech: TechType) -> bool;
}
extern "C" {
    pub fn Player_isUnitAvailable(self_: *mut Player, unit: UnitType) -> bool;
}
extern "C" {
    pub fn Player_hasUnitTypeRequirement(
        self_: *mut Player,
        unit: UnitType,
        amount: ::std::os::raw::c_int,
    ) -> bool;
}
extern "C" {
    pub fn Player_registerEvent(
        self_: *mut Player,
        action: ::std::option::Option<unsafe extern "C" fn(arg1: *mut Player)>,
        condition: ::std::option::Option<unsafe extern "C" fn(arg1: *mut Player) -> bool>,
        timesToRun: ::std::os::raw::c_int,
        framesToCheck: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn Force_getID(self_: *mut Force) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Force_getName(self_: *mut Force) -> *mut BwString;
}
extern "C" {
    pub fn Force_getPlayers(self_: *mut Force) -> *mut PlayerIterator;
}
extern "C" {
    pub fn Unit_getID(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_exists(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_getReplayID(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getPlayer(self_: *mut Unit) -> *mut Player;
}
extern "C" {
    pub fn Unit_getType(self_: *mut Unit) -> UnitType;
}
extern "C" {
    pub fn Unit_getPosition(self_: *mut Unit) -> Position;
}
extern "C" {
    pub fn Unit_getTilePosition(self_: *mut Unit) -> TilePosition;
}
extern "C" {
    pub fn Unit_getAngle(self_: *mut Unit) -> f64;
}
extern "C" {
    pub fn Unit_getVelocityX(self_: *mut Unit) -> f64;
}
extern "C" {
    pub fn Unit_getVelocityY(self_: *mut Unit) -> f64;
}
extern "C" {
    pub fn Unit_getRegion(self_: *mut Unit) -> *mut Region;
}
extern "C" {
    pub fn Unit_getLeft(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getTop(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getRight(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getBottom(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getHitPoints(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getShields(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getEnergy(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getResources(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getResourceGroup(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getDistance_Position(self_: *mut Unit, target: Position) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getDistance_Unit(self_: *mut Unit, target: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_hasPath_Position(self_: *mut Unit, target: Position) -> bool;
}
extern "C" {
    pub fn Unit_hasPath_Unit(self_: *mut Unit, target: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_getLastCommandFrame(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getLastCommand(self_: *mut Unit) -> UnitCommand;
}
extern "C" {
    pub fn Unit_getLastAttackingPlayer(self_: *mut Unit) -> *mut Player;
}
extern "C" {
    pub fn Unit_getInitialType(self_: *mut Unit) -> UnitType;
}
extern "C" {
    pub fn Unit_getInitialPosition(self_: *mut Unit) -> Position;
}
extern "C" {
    pub fn Unit_getInitialTilePosition(self_: *mut Unit) -> TilePosition;
}
extern "C" {
    pub fn Unit_getInitialHitPoints(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getInitialResources(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getKillCount(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getAcidSporeCount(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getInterceptorCount(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getScarabCount(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getSpiderMineCount(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getGroundWeaponCooldown(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getAirWeaponCooldown(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getSpellCooldown(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getDefenseMatrixPoints(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getDefenseMatrixTimer(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getEnsnareTimer(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getIrradiateTimer(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getLockdownTimer(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getMaelstromTimer(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getOrderTimer(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getPlagueTimer(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getRemoveTimer(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getStasisTimer(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getStimTimer(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getBuildType(self_: *mut Unit) -> UnitType;
}
extern "C" {
    pub fn Unit_getTrainingQueue(self_: *mut Unit) -> *mut UnitTypeIterator;
}
extern "C" {
    pub fn Unit_getTech(self_: *mut Unit) -> TechType;
}
extern "C" {
    pub fn Unit_getUpgrade(self_: *mut Unit) -> UpgradeType;
}
extern "C" {
    pub fn Unit_getRemainingBuildTime(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getRemainingTrainTime(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getRemainingResearchTime(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getRemainingUpgradeTime(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getBuildUnit(self_: *mut Unit) -> *mut Unit;
}
extern "C" {
    pub fn Unit_getTarget(self_: *mut Unit) -> *mut Unit;
}
extern "C" {
    pub fn Unit_getTargetPosition(self_: *mut Unit) -> Position;
}
extern "C" {
    pub fn Unit_getOrder(self_: *mut Unit) -> Order;
}
extern "C" {
    pub fn Unit_getSecondaryOrder(self_: *mut Unit) -> Order;
}
extern "C" {
    pub fn Unit_getOrderTarget(self_: *mut Unit) -> *mut Unit;
}
extern "C" {
    pub fn Unit_getOrderTargetPosition(self_: *mut Unit) -> Position;
}
extern "C" {
    pub fn Unit_getRallyPosition(self_: *mut Unit) -> Position;
}
extern "C" {
    pub fn Unit_getRallyUnit(self_: *mut Unit) -> *mut Unit;
}
extern "C" {
    pub fn Unit_getAddon(self_: *mut Unit) -> *mut Unit;
}
extern "C" {
    pub fn Unit_getNydusExit(self_: *mut Unit) -> *mut Unit;
}
extern "C" {
    pub fn Unit_getPowerUp(self_: *mut Unit) -> *mut Unit;
}
extern "C" {
    pub fn Unit_getTransport(self_: *mut Unit) -> *mut Unit;
}
extern "C" {
    pub fn Unit_getLoadedUnits(self_: *mut Unit) -> *mut UnitIterator;
}
extern "C" {
    pub fn Unit_getSpaceRemaining(self_: *mut Unit) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Unit_getCarrier(self_: *mut Unit) -> *mut Unit;
}
extern "C" {
    pub fn Unit_getInterceptors(self_: *mut Unit) -> *mut UnitIterator;
}
extern "C" {
    pub fn Unit_getHatchery(self_: *mut Unit) -> *mut Unit;
}
extern "C" {
    pub fn Unit_getLarva(self_: *mut Unit) -> *mut UnitIterator;
}
extern "C" {
    pub fn Unit_getUnitsInRadius(
        self_: *mut Unit,
        radius: ::std::os::raw::c_int,
        pred: UnaryUnitFilter,
    ) -> *mut UnitIterator;
}
extern "C" {
    pub fn Unit_getUnitsInWeaponRange(
        self_: *mut Unit,
        weapon: WeaponType,
        pred: UnaryUnitFilter,
    ) -> *mut UnitIterator;
}
extern "C" {
    pub fn Unit_getClosestUnit(
        self_: *mut Unit,
        pred: UnaryUnitFilter,
        radius: ::std::os::raw::c_int,
    ) -> *mut Unit;
}
extern "C" {
    pub fn Unit_hasNuke(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isAccelerating(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isAttacking(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isAttackFrame(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isBeingConstructed(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isBeingGathered(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isBeingHealed(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isBlind(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isBraking(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isBurrowed(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isCarryingGas(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isCarryingMinerals(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isCloaked(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isCompleted(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isConstructing(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isDefenseMatrixed(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isDetected(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isEnsnared(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isFlying(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isFollowing(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isGatheringGas(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isGatheringMinerals(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isHallucination(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isHoldingPosition(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isIdle(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isInterruptible(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isInvincible(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isInWeaponRange(self_: *mut Unit, target: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isIrradiated(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isLifted(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isLoaded(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isLockedDown(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isMaelstrommed(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isMorphing(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isMoving(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isParasited(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isPatrolling(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isPlagued(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isRepairing(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isResearching(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isSelected(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isSieged(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isStartingAttack(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isStasised(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isStimmed(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isStuck(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isTraining(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isUnderAttack(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isUnderDarkSwarm(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isUnderDisruptionWeb(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isUnderStorm(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isPowered(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isUpgrading(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_isVisible(self_: *mut Unit, player: *mut Player) -> bool;
}
extern "C" {
    pub fn Unit_isTargetable(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_issueCommand(self_: *mut Unit, command: UnitCommand) -> bool;
}
extern "C" {
    pub fn Unit_attack_Position(
        self_: *mut Unit,
        target: Position,
        shiftQueueCommand: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_attack_Unit(self_: *mut Unit, target: *mut Unit, shiftQueueCommand: bool) -> bool;
}
extern "C" {
    pub fn Unit_build(self_: *mut Unit, type_: UnitType, target: TilePosition) -> bool;
}
extern "C" {
    pub fn Unit_buildAddon(self_: *mut Unit, type_: UnitType) -> bool;
}
extern "C" {
    pub fn Unit_train(self_: *mut Unit, type_: UnitType) -> bool;
}
extern "C" {
    pub fn Unit_morph(self_: *mut Unit, type_: UnitType) -> bool;
}
extern "C" {
    pub fn Unit_research(self_: *mut Unit, tech: TechType) -> bool;
}
extern "C" {
    pub fn Unit_upgrade(self_: *mut Unit, upgrade: UpgradeType) -> bool;
}
extern "C" {
    pub fn Unit_setRallyPoint_Position(self_: *mut Unit, target: Position) -> bool;
}
extern "C" {
    pub fn Unit_setRallyPoint_Target(self_: *mut Unit, target: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_move(self_: *mut Unit, target: Position, shiftQueueCommand: bool) -> bool;
}
extern "C" {
    pub fn Unit_patrol(self_: *mut Unit, target: Position, shiftQueueCommand: bool) -> bool;
}
extern "C" {
    pub fn Unit_holdPosition(self_: *mut Unit, shiftQueueCommand: bool) -> bool;
}
extern "C" {
    pub fn Unit_stop(self_: *mut Unit, shiftQueueCommand: bool) -> bool;
}
extern "C" {
    pub fn Unit_follow(self_: *mut Unit, target: *mut Unit, shiftQueueCommand: bool) -> bool;
}
extern "C" {
    pub fn Unit_gather(self_: *mut Unit, target: *mut Unit, shiftQueueCommand: bool) -> bool;
}
extern "C" {
    pub fn Unit_returnCargo(self_: *mut Unit, shiftQueueCommand: bool) -> bool;
}
extern "C" {
    pub fn Unit_repair(self_: *mut Unit, target: *mut Unit, shiftQueueCommand: bool) -> bool;
}
extern "C" {
    pub fn Unit_burrow(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_unburrow(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_cloak(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_decloak(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_siege(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_unsiege(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_lift(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_land(self_: *mut Unit, target: TilePosition) -> bool;
}
extern "C" {
    pub fn Unit_load(self_: *mut Unit, target: *mut Unit, shiftQueueCommand: bool) -> bool;
}
extern "C" {
    pub fn Unit_unload(self_: *mut Unit, target: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_unloadAll(self_: *mut Unit, shiftQueueCommand: bool) -> bool;
}
extern "C" {
    pub fn Unit_unloadAll_Position(
        self_: *mut Unit,
        target: Position,
        shiftQueueCommand: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_rightClick_Position(
        self_: *mut Unit,
        target: Position,
        shiftQueueCommand: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_rightClick_Unit(
        self_: *mut Unit,
        target: *mut Unit,
        shiftQueueCommand: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_haltConstruction(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_cancelConstruction(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_cancelAddon(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_cancelTrain(self_: *mut Unit, slot: ::std::os::raw::c_int) -> bool;
}
extern "C" {
    pub fn Unit_cancelMorph(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_cancelResearch(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_cancelUpgrade(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_useTech_Position(self_: *mut Unit, tech: TechType, target: Position) -> bool;
}
extern "C" {
    pub fn Unit_useTech_Unit(self_: *mut Unit, tech: TechType, target: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_placeCOP(self_: *mut Unit, target: TilePosition) -> bool;
}
extern "C" {
    pub fn Unit_canIssueCommand(
        self_: *mut Unit,
        command: UnitCommand,
        checkCanUseTechPositionOnPositions: bool,
        checkCanUseTechUnitOnUnits: bool,
        checkCanBuildUnitType: bool,
        checkCanTargetUnit: bool,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canIssueCommandGrouped(
        self_: *mut Unit,
        command: UnitCommand,
        checkCanUseTechPositionOnPositions: bool,
        checkCanUseTechUnitOnUnits: bool,
        checkCanTargetUnit: bool,
        checkCanIssueCommandType: bool,
        checkCommandibilityGrouped: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canCommand(self_: *mut Unit) -> bool;
}
extern "C" {
    pub fn Unit_canCommandGrouped(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canIssueCommandType(
        self_: *mut Unit,
        ct: UnitCommandType,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canIssueCommandTypeGrouped(
        self_: *mut Unit,
        ct: UnitCommandType,
        checkCommandibilityGrouped: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canTargetUnit(
        self_: *mut Unit,
        targetUnit: *mut Unit,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canAttack(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canAttack_Position(
        self_: *mut Unit,
        target: Position,
        checkCanTargetUnit: bool,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canAttack_Unit(
        self_: *mut Unit,
        target: *mut Unit,
        checkCanTargetUnit: bool,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canAttackGrouped(
        self_: *mut Unit,
        checkCommandibilityGrouped: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canAttackGrouped_Position(
        self_: *mut Unit,
        target: Position,
        checkCanTargetUnit: bool,
        checkCanIssueCommandType: bool,
        checkCommandibilityGrouped: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canAttackGrouped_Unit(
        self_: *mut Unit,
        target: *mut Unit,
        checkCanTargetUnit: bool,
        checkCanIssueCommandType: bool,
        checkCommandibilityGrouped: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canAttackMove(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canAttackMoveGrouped(
        self_: *mut Unit,
        checkCommandibilityGrouped: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canAttackUnit(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canAttackUnit_Unit(
        self_: *mut Unit,
        targetUnit: *mut Unit,
        checkCanTargetUnit: bool,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canAttackUnitGrouped(
        self_: *mut Unit,
        checkCommandibilityGrouped: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canAttackUnitGrouped_Unit(
        self_: *mut Unit,
        targetUnit: *mut Unit,
        checkCanTargetUnit: bool,
        checkCanIssueCommandType: bool,
        checkCommandibilityGrouped: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canBuild(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canBuild_UnitType(
        self_: *mut Unit,
        uType: UnitType,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canBuild_UnitType_TilePosition(
        self_: *mut Unit,
        uType: UnitType,
        tilePos: TilePosition,
        checkTargetUnitType: bool,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canBuildAddon(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canBuildAddon_UnitType(
        self_: *mut Unit,
        uType: UnitType,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canTrain(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canTrain_UnitType(
        self_: *mut Unit,
        uType: UnitType,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canMorph(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canMorph_UnitType(
        self_: *mut Unit,
        uType: UnitType,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canResearch(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canResearch_TechType(
        self_: *mut Unit,
        type_: TechType,
        checkCanIssueCommandType: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canUpgrade(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canUpgrade_UpgradeType(
        self_: *mut Unit,
        type_: UpgradeType,
        checkCanIssueCommandType: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canSetRallyPoint(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canSetRallyPoint_Position(
        self_: *mut Unit,
        target: Position,
        checkCanTargetUnit: bool,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canSetRallyPoint_Unit(
        self_: *mut Unit,
        target: *mut Unit,
        checkCanTargetUnit: bool,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canSetRallyPosition(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canSetRallyUnit(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canSetRallyUnit_Unit(
        self_: *mut Unit,
        targetUnit: *mut Unit,
        checkCanTargetUnit: bool,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canMove(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canMoveGrouped(
        self_: *mut Unit,
        checkCommandibilityGrouped: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canPatrol(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canPatrolGrouped(
        self_: *mut Unit,
        checkCommandibilityGrouped: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canFollow(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canFollow_Unit(
        self_: *mut Unit,
        targetUnit: *mut Unit,
        checkCanTargetUnit: bool,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canGather(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canGather_Unit(
        self_: *mut Unit,
        targetUnit: *mut Unit,
        checkCanTargetUnit: bool,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canReturnCargo(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canHoldPosition(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canStop(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canRepair(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canRepair_Unit(
        self_: *mut Unit,
        targetUnit: *mut Unit,
        checkCanTargetUnit: bool,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canBurrow(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canUnburrow(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canCloak(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canDecloak(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canSiege(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canUnsiege(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canLift(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canLand(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canLand_TilePosition(
        self_: *mut Unit,
        target: TilePosition,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canLoad(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canLoad_Unit(
        self_: *mut Unit,
        targetUnit: *mut Unit,
        checkCanTargetUnit: bool,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canUnloadWithOrWithoutTarget(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canUnloadAtPosition(
        self_: *mut Unit,
        targDropPos: Position,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canUnload(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canUnload_Unit(
        self_: *mut Unit,
        targetUnit: *mut Unit,
        checkCanTargetUnit: bool,
        checkPosition: bool,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canUnloadAll(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canUnloadAllPosition(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canUnloadAllPosition_Position(
        self_: *mut Unit,
        targDropPos: Position,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canRightClick(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canRightClick_Position(
        self_: *mut Unit,
        target: Position,
        checkCanTargetUnit: bool,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canRightClick_Unit(
        self_: *mut Unit,
        target: *mut Unit,
        checkCanTargetUnit: bool,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canRightClickGrouped(
        self_: *mut Unit,
        checkCommandibilityGrouped: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canRightClickGrouped_Position(
        self_: *mut Unit,
        target: Position,
        checkCanTargetUnit: bool,
        checkCanIssueCommandType: bool,
        checkCommandibilityGrouped: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canRightClickGrouped_Unit(
        self_: *mut Unit,
        target: *mut Unit,
        checkCanTargetUnit: bool,
        checkCanIssueCommandType: bool,
        checkCommandibilityGrouped: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canRightClickPosition(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canRightClickPositionGrouped(
        self_: *mut Unit,
        checkCommandibilityGrouped: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canRightClickUnit(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canRightClickUnit_Unit(
        self_: *mut Unit,
        targetUnit: *mut Unit,
        checkCanTargetUnit: bool,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canRightClickUnitGrouped(
        self_: *mut Unit,
        checkCommandibilityGrouped: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canRightClickUnitGrouped_Unit(
        self_: *mut Unit,
        targetUnit: *mut Unit,
        checkCanTargetUnit: bool,
        checkCanIssueCommandType: bool,
        checkCommandibilityGrouped: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canHaltConstruction(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canCancelConstruction(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canCancelAddon(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canCancelTrain(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canCancelTrainSlot(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canCancelTrainSlot_Check(
        self_: *mut Unit,
        slot: ::std::os::raw::c_int,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canCancelMorph(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canCancelResearch(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canCancelUpgrade(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canUseTechWithOrWithoutTarget(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canUseTechWithOrWithoutTarget_TechType(
        self_: *mut Unit,
        tech: TechType,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canUseTech_Position(
        self_: *mut Unit,
        tech: TechType,
        target: Position,
        checkCanTargetUnit: bool,
        checkTargetsType: bool,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canUseTech_Unit(
        self_: *mut Unit,
        tech: TechType,
        target: *mut Unit,
        checkCanTargetUnit: bool,
        checkTargetsType: bool,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canUseTechWithoutTarget(
        self_: *mut Unit,
        tech: TechType,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canUseTechUnit(
        self_: *mut Unit,
        tech: TechType,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canUseTechUnit_Unit(
        self_: *mut Unit,
        tech: TechType,
        targetUnit: *mut Unit,
        checkCanTargetUnit: bool,
        checkTargetsUnits: bool,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canUseTechPosition(
        self_: *mut Unit,
        tech: TechType,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canUseTechPosition_Position(
        self_: *mut Unit,
        tech: TechType,
        target: Position,
        checkTargetsPositions: bool,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_canPlaceCOP(self_: *mut Unit, checkCommandibility: bool) -> bool;
}
extern "C" {
    pub fn Unit_canPlaceCOP_TilePosition(
        self_: *mut Unit,
        target: TilePosition,
        checkCanIssueCommandType: bool,
        checkCommandibility: bool,
    ) -> bool;
}
extern "C" {
    pub fn Unit_registerEvent(
        self_: *mut Unit,
        action: ::std::option::Option<unsafe extern "C" fn(arg1: *mut Unit)>,
        condition: ::std::option::Option<unsafe extern "C" fn(arg1: *mut Unit) -> bool>,
        timesToRun: ::std::os::raw::c_int,
        framesToCheck: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn Bullet_getID(self_: *mut Bullet) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Bullet_exists(self_: *mut Bullet) -> bool;
}
extern "C" {
    pub fn Bullet_getPlayer(self_: *mut Bullet) -> *mut Player;
}
extern "C" {
    pub fn Bullet_getType(self_: *mut Bullet) -> BulletType;
}
extern "C" {
    pub fn Bullet_getSource(self_: *mut Bullet) -> *mut Unit;
}
extern "C" {
    pub fn Bullet_getPosition(self_: *mut Bullet) -> Position;
}
extern "C" {
    pub fn Bullet_getAngle(self_: *mut Bullet) -> f64;
}
extern "C" {
    pub fn Bullet_getVelocityX(self_: *mut Bullet) -> f64;
}
extern "C" {
    pub fn Bullet_getVelocityY(self_: *mut Bullet) -> f64;
}
extern "C" {
    pub fn Bullet_getTarget(self_: *mut Bullet) -> *mut Unit;
}
extern "C" {
    pub fn Bullet_getTargetPosition(self_: *mut Bullet) -> Position;
}
extern "C" {
    pub fn Bullet_getRemoveTimer(self_: *mut Bullet) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Bullet_isVisible(self_: *mut Bullet, player: *mut Player) -> bool;
}
extern "C" {
    pub fn Bullet_registerEvent(
        self_: *mut Bullet,
        action: ::std::option::Option<unsafe extern "C" fn(arg1: *mut Bullet)>,
        condition: ::std::option::Option<unsafe extern "C" fn(arg1: *mut Bullet) -> bool>,
        timesToRun: ::std::os::raw::c_int,
        framesToCheck: ::std::os::raw::c_int,
    );
}
extern "C" {
    pub fn Region_getID(self_: *mut Region) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Region_getRegionGroupID(self_: *mut Region) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Region_getCenter(self_: *mut Region) -> Position;
}
extern "C" {
    pub fn Region_isHigherGround(self_: *mut Region) -> bool;
}
extern "C" {
    pub fn Region_getDefensePriority(self_: *mut Region) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Region_isAccessible(self_: *mut Region) -> bool;
}
extern "C" {
    pub fn Region_getNeighbors(self_: *mut Region) -> *mut RegionIterator;
}
extern "C" {
    pub fn Region_getBoundsLeft(self_: *mut Region) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Region_getBoundsTop(self_: *mut Region) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Region_getBoundsRight(self_: *mut Region) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Region_getBoundsBottom(self_: *mut Region) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Region_getClosestAccessibleRegion(self_: *mut Region) -> *mut Region;
}
extern "C" {
    pub fn Region_getClosestInaccessibleRegion(self_: *mut Region) -> *mut Region;
}
extern "C" {
    pub fn Region_getDistance(self_: *mut Region, other: *mut Region) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn Region_getUnits(self_: *mut Region, pred: UnaryUnitFilter) -> *mut UnitIterator;
}
extern "C" {
    pub fn Region_registerEvent(
        self_: *mut Region,
        action: ::std::option::Option<unsafe extern "C" fn(arg1: *mut Region)>,
        condition: ::std::option::Option<unsafe extern "C" fn(arg1: *mut Region) -> bool>,
        timesToRun: ::std::os::raw::c_int,
        framesToCheck: ::std::os::raw::c_int,
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct AIModule {
    pub vtable: *const AIModule_vtable,
}
#[repr(C)]
pub struct AIModule_vtable {
    pub onStart: ::std::option::Option<unsafe extern "C" fn(module: *mut AIModule)>,
    pub onEnd: ::std::option::Option<unsafe extern "C" fn(module: *mut AIModule, isWinner: bool)>,
    pub onFrame: ::std::option::Option<unsafe extern "C" fn(module: *mut AIModule)>,
    pub onSendText: ::std::option::Option<
        unsafe extern "C" fn(module: *mut AIModule, text: *const ::std::os::raw::c_char),
    >,
    pub onReceiveText: ::std::option::Option<
        unsafe extern "C" fn(
            module: *mut AIModule,
            player: *mut Player,
            text: *const ::std::os::raw::c_char,
        ),
    >,
    pub onPlayerLeft:
        ::std::option::Option<unsafe extern "C" fn(module: *mut AIModule, player: *mut Player)>,
    pub onNukeDetect:
        ::std::option::Option<unsafe extern "C" fn(module: *mut AIModule, target: Position)>,
    pub onUnitDiscover:
        ::std::option::Option<unsafe extern "C" fn(module: *mut AIModule, unit: *mut Unit)>,
    pub onUnitEvade:
        ::std::option::Option<unsafe extern "C" fn(module: *mut AIModule, unit: *mut Unit)>,
    pub onUnitShow:
        ::std::option::Option<unsafe extern "C" fn(module: *mut AIModule, unit: *mut Unit)>,
    pub onUnitHide:
        ::std::option::Option<unsafe extern "C" fn(module: *mut AIModule, unit: *mut Unit)>,
    pub onUnitCreate:
        ::std::option::Option<unsafe extern "C" fn(module: *mut AIModule, unit: *mut Unit)>,
    pub onUnitDestroy:
        ::std::option::Option<unsafe extern "C" fn(module: *mut AIModule, unit: *mut Unit)>,
    pub onUnitMorph:
        ::std::option::Option<unsafe extern "C" fn(module: *mut AIModule, unit: *mut Unit)>,
    pub onUnitRenegade:
        ::std::option::Option<unsafe extern "C" fn(module: *mut AIModule, unit: *mut Unit)>,
    pub onSaveGame: ::std::option::Option<
        unsafe extern "C" fn(module: *mut AIModule, gameName: *const ::std::os::raw::c_char),
    >,
    pub onUnitComplete:
        ::std::option::Option<unsafe extern "C" fn(module: *mut AIModule, unit: *mut Unit)>,
}
extern "C" {
    pub fn createAIModuleWrapper(module: *mut AIModule) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn destroyAIModuleWrapper(module: *mut ::std::os::raw::c_void);
}