____                _       __
    / __ )____  _____   | |     / /___ ___________
   / __  / __ \/ ___/   | | /| / / __ `/ ___/ ___/
  / /_/ / /_/ (__  )    | |/ |/ / /_/ / /  (__  )
 /_____/\____/____/     |__/|__/\__,_/_/  /____/

       A futuristic real-time strategy game.
          This file is part of Bos Wars.

(C) Copyright 2001-2007 by the Bos Wars and Stratagus Project. Distributed under the "GNU General Public License"

---

script_player.cpp

Go to the documentation of this file.

//     ____                _       __               
//    / __ )____  _____   | |     / /___ ___________
//   / __  / __ \/ ___/   | | /| / / __ `/ ___/ ___/
//  / /_/ / /_/ (__  )    | |/ |/ / /_/ / /  (__  ) 
// /_____/\____/____/     |__/|__/\__,_/_/  /____/  
//                                              
//       A futuristic real-time strategy game.
//          This file is part of Bos Wars.
//
//
//      (c) Copyright 2001-2007 by Lutz Sammer and Jimmy Salmon
//
//      This program is free software; you can redistribute it and/or modify
//      it under the terms of the GNU General Public License as published by
//      the Free Software Foundation; only version 2 of the License.
//
//      This program is distributed in the hope that it will be useful,
//      but WITHOUT ANY WARRANTY; without even the implied warranty of
//      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//      GNU General Public License for more details.
//
//      You should have received a copy of the GNU General Public License
//      along with this program; if not, write to the Free Software
//      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
//      02111-1307, USA.
//


/*----------------------------------------------------------------------------
--  Includes
----------------------------------------------------------------------------*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "stratagus.h"
#include "unittype.h"
#include "unit_cache.h"
#include "player.h"
#include "script.h"
#include "ai.h"
#include "actions.h"
#include "commands.h"

/*----------------------------------------------------------------------------
--  Variables
----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------
--  Functions
----------------------------------------------------------------------------*/

static int CclPlayer(lua_State *l)
{
    const char *value;
    CPlayer *player;
    int i;
    int args;
    int j;
    int subargs;
    int k;

    args = lua_gettop(l);
    j = 0;

    i = LuaToNumber(l, j + 1);
    ++j;
    player = &Players[i];
    if (NumPlayers <= i) {
        NumPlayers = i + 1;
    }
    player->Index = i;
    memset(player->Units, 0, sizeof(player->Units));

    //
    //  Parse the list: (still everything could be changed!)
    //
    for (; j < args; ++j) {
        value = LuaToString(l, j + 1);
        ++j;

        if (!strcmp(value, "name")) {
            player->SetName(LuaToString(l, j + 1));
        } else if (!strcmp(value, "type")) {
            value = LuaToString(l, j + 1);
            if (!strcmp(value, "neutral")) {
                player->Type = PlayerNeutral;
            } else if (!strcmp(value, "nobody")) {
                player->Type = PlayerNobody;
            } else if (!strcmp(value, "computer")) {
                player->Type = PlayerComputer;
            } else if (!strcmp(value, "person")) {
                player->Type = PlayerPerson;
            } else if (!strcmp(value, "rescue-passive")) {
                player->Type = PlayerRescuePassive;
            } else if (!strcmp(value, "rescue-active")) {
                player->Type = PlayerRescueActive;
            } else {
                LuaError(l, "Unsupported tag: %s" _C_ value);
            }
        } else if (!strcmp(value, "ai-name")) {
            player->AiName = LuaToString(l, j + 1);
        } else if (!strcmp(value, "team")) {
            player->Team = LuaToNumber(l, j + 1);
        } else if (!strcmp(value, "enemy")) {
            value = LuaToString(l, j + 1);
            for (i = 0; i < PlayerMax && *value; ++i, ++value) {
                if (*value == '-' || *value == '_' || *value == ' ') {
                    player->Enemy &= ~(1 << i);
                } else {
                    player->Enemy |= (1 << i);
                }
            }
        } else if (!strcmp(value, "allied")) {
            value = LuaToString(l, j + 1);
            for (i = 0; i < PlayerMax && *value; ++i, ++value) {
                if (*value == '-' || *value == '_' || *value == ' ') {
                    player->Allied &= ~(1 << i);
                } else {
                    player->Allied |= (1 << i);
                }
            }
        } else if (!strcmp(value, "shared-vision")) {
            value = LuaToString(l, j + 1);
            for (i = 0; i < PlayerMax && *value; ++i, ++value) {
                if (*value == '-' || *value == '_' || *value == ' ') {
                    player->SharedVision &= ~(1 << i);
                } else {
                    player->SharedVision |= (1 << i);
                }
            }
        } else if (!strcmp(value, "start")) {
            if (!lua_istable(l, j + 1) || lua_objlen(l, j + 1) != 2) {
                LuaError(l, "incorrect argument");
            }
            lua_rawgeti(l, j + 1, 1);
            player->StartX = LuaToNumber(l, -1);
            lua_pop(l, 1);
            lua_rawgeti(l, j + 1, 2);
            player->StartY = LuaToNumber(l, -1);
            lua_pop(l, 1);
        } else if (!strcmp(value, "production-rate")) {
            if (!lua_istable(l, j + 1)) {
                LuaError(l, "incorrect argument");
            }
            subargs = lua_objlen(l, j + 1);
            for (k = 0; k < subargs; ++k) {
                lua_rawgeti(l, j + 1, k + 1);
                value = LuaToString(l, -1);
                lua_pop(l, 1);
                ++k;

                for (i = 0; i < MaxCosts; ++i) {
                    if (value == DefaultResourceNames[i]) {
                        lua_rawgeti(l, j + 1, k + 1);
                        player->ProductionRate[i] = LuaToNumber(l, -1);
                        lua_pop(l, 1);
                        break;
                    }
                }
                if (i == MaxCosts) {
                    LuaError(l, "Unsupported tag: %s" _C_ value);
                }
            }
        } else if (!strcmp(value, "stored-resources")) {
            if (!lua_istable(l, j + 1)) {
                LuaError(l, "incorrect argument");
            }
            subargs = lua_objlen(l, j + 1);
            for (k = 0; k < subargs; ++k) {
                lua_rawgeti(l, j + 1, k + 1);
                value = LuaToString(l, -1);
                lua_pop(l, 1);
                ++k;

                for (i = 0; i < MaxCosts; ++i) {
                    if (value == DefaultResourceNames[i]) {
                        lua_rawgeti(l, j + 1, k + 1);
                        player->StoredResources[i] = LuaToNumber(l, -1);
                        lua_pop(l, 1);
                        break;
                    }
                }
                if (i == MaxCosts) {
                    LuaError(l, "Unsupported tag: %s" _C_ value);
                }
            }
        } else if (!strcmp(value, "storage-capacity")) {
            if (!lua_istable(l, j + 1)) {
                LuaError(l, "incorrect argument");
            }
            subargs = lua_objlen(l, j + 1);
            for (k = 0; k < subargs; ++k) {
                lua_rawgeti(l, j + 1, k + 1);
                value = LuaToString(l, -1);
                lua_pop(l, 1);
                ++k;

                for (i = 0; i < MaxCosts; ++i) {
                    if (value == DefaultResourceNames[i]) {
                        lua_rawgeti(l, j + 1, k + 1);
                        player->StorageCapacity[i] = LuaToNumber(l, -1);
                        lua_pop(l, 1);
                        break;
                    }
                }
                if (i == MaxCosts) {
                    LuaError(l, "Unsupported tag: %s" _C_ value);
                }
            }
        } else if (!strcmp(value, "ai-enabled")) {
            player->AiEnabled = 1;
            --j;
        } else if (!strcmp(value, "ai-disabled")) {
            player->AiEnabled = 0;
            --j;
        } else if (!strcmp(value, "unit-limit")) {
            player->UnitLimit = LuaToNumber(l, j + 1);
        } else if (!strcmp(value, "building-limit")) {
            player->BuildingLimit = LuaToNumber(l, j + 1);
        } else if (!strcmp(value, "total-unit-limit")) {
            player->TotalUnitLimit = LuaToNumber(l, j + 1);
        } else if (!strcmp(value, "score")) {
            player->Score = LuaToNumber(l, j + 1);
        } else if (!strcmp(value, "total-units")) {
            player->TotalUnits = LuaToNumber(l, j + 1);
        } else if (!strcmp(value, "total-buildings")) {
            player->TotalBuildings = LuaToNumber(l, j + 1);
        } else if (!strcmp(value, "total-razings")) {
            player->TotalRazings = LuaToNumber(l, j + 1);
        } else if (!strcmp(value, "total-kills")) {
            player->TotalKills = LuaToNumber(l, j + 1);
        } else if (!strcmp(value, "total-resources")) {
            if (!lua_istable(l, j + 1)) {
                LuaError(l, "incorrect argument");
            }
            subargs = lua_objlen(l, j + 1);
            if (subargs != MaxCosts) {
                LuaError(l, "Wrong number of total-resources: %d" _C_ i);
            }
            for (k = 0; k < subargs; ++k) {
                lua_rawgeti(l, j + 1, k + 1);
                player->TotalResources[k] = LuaToNumber(l, -1);
                lua_pop(l, 1);
            }
        } else if (!strcmp(value, "color")) {
            int r;
            int g;
            int b;

            if (!lua_istable(l, j + 1) || lua_objlen(l, j + 1) != 3) {
                LuaError(l, "incorrect argument");
            }
            lua_rawgeti(l, j + 1, 1);
            r = LuaToNumber(l, -1);
            lua_pop(l, 1);
            lua_rawgeti(l, j + 1, 2);
            g = LuaToNumber(l, -1);
            lua_pop(l, 1);
            lua_rawgeti(l, j + 1, 3);
            b = LuaToNumber(l, -1);
            lua_pop(l, 1);
            player->Color = Video.MapRGB(TheScreen->format, r, g, b);
        } else {
           LuaError(l, "Unsupported tag: %s" _C_ value);
        }
    }

    return 0;
}

static int CclChangeUnitsOwner(lua_State *l)
{
    CUnit *table[UnitMax];
    int n;
    int oldp;
    int newp;
    int x1;
    int y1;
    int x2;
    int y2;

    LuaCheckArgs(l, 4);
    if (!lua_istable(l, 1) || !lua_istable(l, 2)) {
        LuaError(l, "incorrect argument");
    }
    if (lua_objlen(l, 1) != 2) {
        LuaError(l, "incorrect argument");
    }
    lua_rawgeti(l, 1, 1);
    x1 = LuaToNumber(l, -1);
    lua_pop(l, 1);
    lua_rawgeti(l, 1, 1);
    y1 = LuaToNumber(l, -1);
    lua_pop(l, 1);

    if (lua_objlen(l, 2) != 2) {
        LuaError(l, "incorrect argument");
    }
    lua_rawgeti(l, 2, 1);
    x2 = LuaToNumber(l, -1);
    lua_pop(l, 1);
    lua_rawgeti(l, 2, 1);
    y2 = LuaToNumber(l, -1);
    lua_pop(l, 1);

    n = UnitCache.Select(x1, y1, x2 + 1, y2 + 1, table, UnitMax);
    oldp = LuaToNumber(l, 3);
    newp = LuaToNumber(l, 4);
    while (n) {
        if (table[n - 1]->Player->Index == oldp) {
            table[n - 1]->ChangeOwner(&Players[newp]);
        }
        --n;
    }

    return 0;
}

static int CclSetMaxSelectable(lua_State *l)
{
    LuaCheckArgs(l, 1);
    MaxSelectable = LuaToNumber(l, 1);

    lua_pushnumber(l, MaxSelectable);
    return 1;
}

static int CclSetAllPlayersUnitLimit(lua_State *l)
{
    int i;

    LuaCheckArgs(l, 1);
    for (i = 0; i < PlayerMax; ++i) {
        Players[i].UnitLimit = LuaToNumber(l, 1);
    }

    lua_pushnumber(l, lua_tonumber(l, 1));
    return 1;
}

static int CclSetAllPlayersBuildingLimit(lua_State *l)
{
    int i;

    LuaCheckArgs(l, 1);
    for (i = 0; i < PlayerMax; ++i) {
        Players[i].BuildingLimit = LuaToNumber(l, 1);
    }

    lua_pushnumber(l, lua_tonumber(l, 1));
    return 1;
}

static int CclSetAllPlayersTotalUnitLimit(lua_State *l)
{
    int i;

    LuaCheckArgs(l, 1);
    for (i = 0; i < PlayerMax; ++i) {
        Players[i].TotalUnitLimit = LuaToNumber(l, 1);
    }

    lua_pushnumber(l, lua_tonumber(l, 1));
    return 1;
}

static int CclSetDiplomacy(lua_State *l)
{
    int plynr;
    int base;
    const char *state;

    LuaCheckArgs(l, 3);
    base = LuaToNumber(l, 1);
    plynr = LuaToNumber(l, 3);
    state = LuaToString(l, 2);

    if (!strcmp(state, "allied")) {
        SendCommandDiplomacy(base, DiplomacyAllied, plynr);
    } else if (!strcmp(state, "neutral")) {
        SendCommandDiplomacy(base, DiplomacyNeutral, plynr);
    } else if (!strcmp(state, "crazy")) {
        SendCommandDiplomacy(base, DiplomacyCrazy, plynr);
    } else if (!strcmp(state, "enemy")) {
        SendCommandDiplomacy(base, DiplomacyEnemy, plynr);
    }

    return 0;
}

static int CclDiplomacy(lua_State *l)
{
    lua_pushnumber(l, ThisPlayer->Index);
    lua_insert(l, 1);
    return CclSetDiplomacy(l);
}

static int CclSetSharedVision(lua_State *l)
{
    int plynr;
    int base;
    bool shared;

    LuaCheckArgs(l, 3);

    base = LuaToNumber(l, 1);
    shared = LuaToBoolean(l, 2);
    plynr = LuaToNumber(l, 3);

    SendCommandSharedVision(base, shared, plynr);

    return 0;
}

static int CclSharedVision(lua_State *l)
{
    lua_pushnumber(l, ThisPlayer->Index);
    lua_insert(l, 1);
    return CclSetSharedVision(l);
}

static int CclDefinePlayerColors(lua_State *l)
{
    int i;
    int args;
    int j;
    int numcolors;

    LuaCheckArgs(l, 1);
    if (!lua_istable(l, 1)) {
        LuaError(l, "incorrect argument");
    }

    args = lua_objlen(l, 1);
    for (i = 0; i < args; ++i) {
        lua_rawgeti(l, 1, i + 1);
        PlayerColorNames[i / 2] = LuaToString(l, -1);
        lua_pop(l, 1);
        ++i;
        lua_rawgeti(l, 1, i + 1);
        if (!lua_istable(l, -1)) {
            LuaError(l, "incorrect argument");
        }
        numcolors = lua_objlen(l, -1);
        if (numcolors != PlayerColorIndexCount) {
            LuaError(l, "You should use %d colors (See DefinePlayerColorIndex())" _C_ PlayerColorIndexCount);
        }
        for (j = 0; j < numcolors; ++j) {
            lua_rawgeti(l, -1, j + 1);
            if (!lua_istable(l, -1) || lua_objlen(l, -1) != 3) {
                LuaError(l, "incorrect argument");
            }
            lua_rawgeti(l, -1, 1);
            lua_rawgeti(l, -2, 2);
            lua_rawgeti(l, -3, 3);
            PlayerColorsRGB[i / 2][j].r = LuaToNumber(l, -3);
            PlayerColorsRGB[i / 2][j].g = LuaToNumber(l, -2);
            PlayerColorsRGB[i / 2][j].b = LuaToNumber(l, -1);
            lua_pop(l, 3 + 1);
        }
    }

    return 0;
}

static int CclNewPlayerColors(lua_State *l)
{
    LuaCheckArgs(l, 0);
    SetPlayersPalette();

    return 0;
}

static int CclDefinePlayerColorIndex(lua_State *l)
{
    int i;

    LuaCheckArgs(l, 2);
    PlayerColorIndexStart = LuaToNumber(l, 1);
    PlayerColorIndexCount = LuaToNumber(l, 2);

    for (i = 0; i < PlayerMax; ++i) {
        delete[] PlayerColorsRGB[i];
        PlayerColorsRGB[i] = new SDL_Color[PlayerColorIndexCount];
        memset(PlayerColorsRGB[i], 0, PlayerColorIndexCount * sizeof(SDL_Color));
        delete[] PlayerColors[i];
        PlayerColors[i] = new Uint32[PlayerColorIndexCount];
        memset(PlayerColorsRGB[i], 0, PlayerColorIndexCount * sizeof(Uint32));
    }
    return 0;
}

// ----------------------------------------------------------------------------

void PlayerCclRegister(void)
{
    lua_register(Lua, "Player", CclPlayer);
    lua_register(Lua, "ChangeUnitsOwner", CclChangeUnitsOwner);

    lua_register(Lua, "SetMaxSelectable", CclSetMaxSelectable);

    lua_register(Lua, "SetAllPlayersUnitLimit",
        CclSetAllPlayersUnitLimit);
    lua_register(Lua, "SetAllPlayersBuildingLimit",
        CclSetAllPlayersBuildingLimit);
    lua_register(Lua, "SetAllPlayersTotalUnitLimit",
        CclSetAllPlayersTotalUnitLimit);

    lua_register(Lua, "SetDiplomacy", CclSetDiplomacy);
    lua_register(Lua, "Diplomacy", CclDiplomacy);
    lua_register(Lua, "SetSharedVision", CclSetSharedVision);
    lua_register(Lua, "SharedVision", CclSharedVision);

    lua_register(Lua, "DefinePlayerColors", CclDefinePlayerColors);
    lua_register(Lua, "DefinePlayerColorIndex", CclDefinePlayerColorIndex);

    lua_register(Lua, "NewColors", CclNewPlayerColors);
}

---