script.h

Go to the documentation of this file.

//       _________ __                 __
//      /   _____//  |_____________ _/  |______     ____  __ __  ______
//      \_____  \\   __\_  __ \__  \\   __\__  \   / ___\|  |  \/  ___/
//      /        \|  |  |  | \// __ \|  |  / __ \_/ /_/  >  |  /\___ |
//     /_______  /|__|  |__|  (____  /__| (____  /\___  /|____//____  >
//             \/                  \/          \//_____/            \/
//  ______________________                           ______________________
//                        T H E   W A R   B E G I N S
//         Stratagus - A free fantasy real time strategy game engine
//
//
//      (c) Copyright 1998-2006 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.
//
 
#ifndef __SCRIPT_H__
#define __SCRIPT_H__
 
 
/*----------------------------------------------------------------------------
--  Includes
----------------------------------------------------------------------------*/
 
#include <string>
#ifdef __cplusplus
extern "C" {
#endif
#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>
#ifdef __cplusplus
}
#endif
 
/*----------------------------------------------------------------------------
--  Declarations
----------------------------------------------------------------------------*/
 
class CUnit;
class CUnitType;
class CFile;
class CFont;
 
struct LuaUserData {
        int Type;
        void *Data;
};
 
enum {
        LuaUnitType = 100,
        LuaSoundType
};
 
extern lua_State *Lua;
 
extern int LuaLoadFile(const std::string &file, const std::string &strArg = "", bool exitOnError = true);
extern int LuaCall(int narg, int clear, bool exitOnError = true);
extern int LuaCall(lua_State *L, int narg, int nresults, int base, bool exitOnError = true);
 
#define LuaError(l, args) \
        do { \
                PrintFunction(); \
                fprintf(stdout, args); \
                fprintf(stdout, "\n"); \
                lua_pushfstring(l, args); lua_error(l); \
        } while (0)
 
#define LuaCheckArgs(l, args) \
        do { \
                if (lua_gettop(l) != args) { \
                        LuaError(l, "incorrect argument"); \
                } \
        } while (0)
 
#if LUA_VERSION_NUM <= 501
 
inline size_t lua_rawlen(lua_State *l, int index)
{
        return luaL_getn(l, index);
}
 
#endif
 
enum ENumber {
        ENumber_Lua,         
        ENumber_Dir,         
        ENumber_Add,         
        ENumber_Sub,         
        ENumber_Mul,         
        ENumber_Div,         
        ENumber_Min,         
        ENumber_Max,         
        ENumber_Rand,        
 
        ENumber_Gt,          
        ENumber_GtEq,        
        ENumber_Lt,          
        ENumber_LtEq,        
        ENumber_Eq,          
        ENumber_NEq,         
 
        ENumber_VideoTextLength, 
        ENumber_StringFind,      
 
        ENumber_UnitStat,    
        ENumber_TypeStat,    
 
        ENumber_NumIf,       
 
        ENumber_PlayerData   
};
 
enum EUnit {
        EUnit_Ref           
        // FIXME: add others.
};
 
enum EString {
        EString_Lua,          
        EString_Dir,          
        EString_Concat,       
        EString_String,       
        EString_InverseVideo, 
        EString_If,           
        EString_UnitName,     
        EString_SubString,    
        EString_Line,         
        EString_PlayerName    
        // add more...
};
 
enum ES_GameInfo {
        ES_GameInfo_Objectives       
};
 
enum EnumVariable {
        VariableValue = 0,  
        VariableMax,        
        VariableIncrease,   
        VariableDiff,       
        VariablePercent,    
        VariableName        
};
 
enum EnumUnit {
        UnitRefItSelf = 0,      
        UnitRefInside,          
        UnitRefContainer,       
        UnitRefWorker,          
        UnitRefGoal             
};
 
struct NumberDesc;
 
struct UnitDesc;
 
struct StringDesc;
 
struct BinOp {
        NumberDesc *Left;           
        NumberDesc *Right;          
};
 
struct NumberDesc {
        ENumber e;       
        union {
                unsigned int Index; 
                int Val;       
                NumberDesc *N; 
                BinOp binOp;   
                struct {
                        UnitDesc *Unit;            
                        int Index;                 
                        EnumVariable Component;    
                        int Loc;                   
                } UnitStat;
                struct {
                        CUnitType **Type;           
                        int Index;                 
                        EnumVariable Component;    
                        int Loc;                   
                } TypeStat;
                struct {
                        StringDesc *String; 
                        CFont *Font;        
                } VideoTextLength;
                struct {
                        StringDesc *String; 
                        char C;             
                } StringFind;
                struct {
                        NumberDesc *Cond;   
                        NumberDesc *BTrue;  
                        NumberDesc *BFalse; 
                } NumIf; 
                struct {
                        NumberDesc *Player;   
                        StringDesc *DataType; 
                        StringDesc *ResType;  
                } PlayerData; 
        } D;
};
 
struct UnitDesc {
        EUnit e;       
        union {
                CUnit **AUnit; 
        } D;
};
 
struct StringDesc {
        EString e;       
        union {
                unsigned int Index; 
                char *Val;       
                struct {
                        StringDesc **Strings;  
                        int n;                 
                } Concat; 
                NumberDesc *Number;  
                StringDesc *String;  
                UnitDesc *Unit;      
                struct {
                        NumberDesc *Cond;  
                        StringDesc *BTrue;  
                        StringDesc *BFalse; 
                } If; 
                struct {
                        StringDesc *String;  
                        NumberDesc *Begin;   
                        NumberDesc *End;     
                } SubString; 
                struct {
                        StringDesc *String;  
                        NumberDesc *Line;    
                        NumberDesc *MaxLen;  
                        CFont *Font;         
                } Line; 
                ES_GameInfo GameInfoType;
                NumberDesc *PlayerName;  
        } D;
};
 
/*----------------------------------------------------------------------------
--  Variables
----------------------------------------------------------------------------*/
 
extern int CclInConfigFile;        
 
/*----------------------------------------------------------------------------
--  Functions
----------------------------------------------------------------------------*/
 
extern const char *LuaToString(lua_State *l, int narg);
extern int LuaToNumber(lua_State *l, int narg);
extern float LuaToFloat(lua_State *l, int narg);
extern unsigned int LuaToUnsignedNumber(lua_State *l, int narg);
extern bool LuaToBoolean(lua_State *l, int narg);
 
extern const char *LuaToString(lua_State *l, int index, int subIndex);
extern int LuaToNumber(lua_State *l, int index, int subIndex);
extern unsigned int LuaToUnsignedNumber(lua_State *l, int index, int subIndex);
extern bool LuaToBoolean(lua_State *l, int index, int subIndex);
 
extern void LuaGarbageCollect();  
extern void InitLua();                
extern void LoadCcl(const std::string &filename, const std::string &luaArgStr = "");  
extern void SavePreferences();        
extern int CclCommand(const std::string &command, bool exitOnError = true);
 
extern void ScriptRegister();
 
extern std::string SaveGlobal(lua_State *l); 
 
CUnit *CclGetUnitFromRef(lua_State *l);
 
template <typename T>
static void CclGetPos(lua_State *l, T *x , T *y, const int offset = -1)
{
        if (!lua_istable(l, offset) || lua_rawlen(l, offset) != 2) {
                LuaError(l, "incorrect argument");
        }
        *x = LuaToNumber(l, offset, 1);
        *y = LuaToNumber(l, offset, 2);
}
 
extern NumberDesc *Damage;  
 
extern EnumVariable Str2EnumVariable(lua_State *l, const char *s);
extern NumberDesc *CclParseNumberDesc(lua_State *l); 
extern UnitDesc *CclParseUnitDesc(lua_State *l);     
extern CUnitType **CclParseTypeDesc(lua_State *l);   
StringDesc *CclParseStringDesc(lua_State *l);        
 
extern int EvalNumber(const NumberDesc *numberdesc); 
extern CUnit *EvalUnit(const UnitDesc *unitdesc);    
std::string EvalString(const StringDesc *s);         
 
void FreeNumberDesc(NumberDesc *number);  
void FreeUnitDesc(UnitDesc *unitdesc);    
void FreeStringDesc(StringDesc *s);       
 
 
#endif // !__SCRIPT_H__