Constants.hh

/*
** TowBowlTactics, a turn-based strategy football game.
**
** Copyright (C) 2006-2010 The TBT Team.
**
** 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; either version 2
** of the License, or (at your option) any later version.
**
** The complete GNU General Public Licence Notice can be found as the
** `NOTICE' file in the root directory.
**
** The TBT Team consists of people listed in the `AUTHORS' file.
*/

#ifndef CONSTANTS_HH_
# define CONSTANTS_HH_

# include "rules/BaseRules.hh"


enum {
  GS_UNASSIGNED = 0,

  GS_INITGAME,      
  GS_INITHALF,      
  GS_DRAWKICKER,    
  GS_INITKICKOFF,   
  GS_KICKOFF,       
  GS_TOUCHBACK,     
  GS_TOUCHDOOOWN,   
  GS_CELEBRATE,     
  GS_TURN,          
// Team state.
  GS_REROLL,        
  GS_BLOCK,         
  GS_PUSH,          
  GS_FOLLOW,        
  GS_SKILL,         

  GS_LAST = GS_SKILL
};

extern const char *bb5_gamestate_str[1 + GS_LAST];

const int MAX_PERIOD       = 5;

extern const char *bb5_period_str[1 + MAX_PERIOD];

// Field limits.
const int COLS             = 15;  
const int ROWS             = 26;  
const int SIDE             = 4;   

// Team identifiants.
const int HOME             = 0;   
const int VISITOR          = 1;   

const int MAX_PLAYER       = 16;

// Constants that can be returned by the API.
const int INVALID_REQUEST  = -4;  
const int BAD_TEAM         = -3;  
const int BAD_PLAYER       = -2;  
const int BAD_ARGUMENT     = -1;  
const int SUCCESS          = 0;   

enum {
  MSG_CHAT = 0,       
  MSG_DEBUG,          
  MSG_ILLEGAL,        
  MSG_INITGAME,       
  MSG_INITHALF,       
  MSG_DRAWKICKER,     
  MSG_INITKICKOFF,    
  MSG_TOUCHBACK,      
  MSG_CHEATDICE,      
  MSG_RESULT,         
  MSG_BLOCKRESULT,    
  MSG_BLOCKDICE,      
  MSG_FOLLOW,         
  MSG_REROLL,         
  MSG_NEWTURN,        
  MSG_ENDTURN,        
  MSG_ENDGAME,        
  MSG_CANCELGAME,     
  MSG_BALLCOORD,      
  MSG_BALLOWNER,      
  MSG_WEATHER,        
  MSG_TIMER,          
  MSG_TURNOVER,       
  MSG_TOUCHDOOOWN,    
  MSG_TEAMINFO,       
  MSG_PLAYERCREATE,   
  MSG_PLAYERCOORD,    
  MSG_PLAYERKNOCKED,  
  MSG_PLAYERSTATUS,   
  MSG_PLAYERMAREMAIN, 
  MSG_SKILL,          
  MSG_ROLLINFO, // FIXME: complete usage ... TODO: remember which usage ... if any ...
  MSG_MOVETURNMARKER, 
  MSG_ILLEGALPROC,    
  MSG_ACTION,         
  MSG_EFFORT,         
  MSG_REQUESTPROCESSED,
  MSG_MOVE,           
  MSG_STANDUP,        
  MSG_BLOCK,          
  MSG_BLOCKPUSH,      
  MSG_MULTIBLOCK,     
  MSG_FOUL,           
  MSG_HANDOFF,        
  MSG_PASS,           

  RULES_TOKEN_LAST
};

extern const char *bb5_token_str[RULES_TOKEN_LAST];

enum eStatus {
  STA_UNASSIGNED = 0,

  // Common status
  STA_RESERVE,    
  STA_STANDING,   
  STA_PRONE,      
  STA_STUNNED,    
  STA_KO,         
  STA_INJURED,    
  STA_SENTOFF,    

  STA_LAST = STA_SENTOFF

  // skill/trait related... for futur usage
  //STA_ROOTED,
  //STA_BONEHEAD,
  //STA_STUPID,
  //STA_GAZE
};

extern const char *bb5_playerstatus_str[1 + STA_LAST];

enum eAction {
  ACT_UNASSIGNED = 0,

  ACT_MOVE,     
  ACT_BLOCK,    
  ACT_BLITZ,    
  ACT_FOUL,     
  ACT_PASS,     
  ACT_TRANSMIT, 

  ACT_LAST = ACT_TRANSMIT
};

extern const char *bb5_action_str[1 + ACT_LAST];

enum eEffort {
  EFF_UNASSIGNED = 0,

  EFF_BLOCK,      
  EFF_FOUL,       
  EFF_HANDOFF,    
  EFF_MOVE,       
  EFF_STANDUP,    
  EFF_THROW,      

  EFF_LAST = EFF_THROW

  // extra rules efforts:
  //EFF_GATHER,
  //EFF_GOFORIT,
  //EFF_LEAP,
  //EFF_THROWTM,
};

extern const char *bb5_effort_str[1 + EFF_LAST];

enum eRoll {
  R_UNASSIGNED = 0,

  R_ARMOUR,   
  R_BLOCK,    
  R_CATCH,    
  R_DODGE,    
  R_INJURY,   
  R_PICKUP,   
  R_REGENERATE, 
  R_STANDUP,  
  R_TAME,     
  R_THROW,    
  R_WAKEUP,   

  R_LAST = R_WAKEUP
};

extern const char *bb5_roll_str[1 + R_LAST];

enum eSkill {
  SK_UNASSIGNED = 0,

  SK_BLOCK,         
  SK_CATCH,         
  SK_CLAWS,         

  SK_DODGE,         

  SK_GUARD,         
  SK_HORNS,         
  SK_MIGHTYBLOW,    

  SK_PASS,          
  SK_REGENERATION,  
  SK_SUREHANDS,     
  SK_STRONGARM,     
  SK_STUNTY,        

  SK_TACKLE,        
  SK_TITCHY,        

  SK_THICKSKULL,    
  SK_WILDANIMAL,    


  SK_LAST = SK_WILDANIMAL
};

extern const char *bb5_skill_str[1 + SK_LAST];

enum eTurnOverMotive {
  TOM_UNASSIGNED = 0,

  TOM_KNOCKEDDOWN,    
  TOM_LOSTBALL,       


  TOM_FAILEDPICKUP,   
  TOM_TOUCHDOOOWN,    
  TOM_TIMEEXCEEDED,   
  TOM_FUMBLEDPASS,    
  TOM_THROWNTMFAILED, 

  TOM_EJECTEDFORAFOUL,

  TOM_LAST = TOM_EJECTEDFORAFOUL
};

extern const char *bb5_turnovermotive_str[1 + TOM_LAST];

enum eError {
  ERR_UNASSIGNED = 0,

  ERR_UNREADABLE,               
  ERR_WRONGCONTEXT,             
  ERR_INVALIDTEAMINFO,          
  ERR_ALREADYEXISTS,            
  ERR_INVALIDPLAYERINFO,        
  ERR_NONEXISTENTPLAYER,        
  ERR_CANNOTENTERINPLAY,        
  ERR_ALREADYHERE,              
  ERR_PLAYERSINOPPOSITEHALF,    
  ERR_TOOMANYPLAYERSINWIDEZONE, 
  ERR_LINEOFSCRIMMAGENOTFILLED, 
  ERR_TOOMANYPLAYERSINTHEFIELD, 
  ERR_TOOMANYPLAYERSINRESERVE,  
  ERR_INVALIDBALLPLACEMENT,     
  ERR_CANNOTCARRYTHEBALL,       
  ERR_HASPLAYED,                
  ERR_ISPLAYING,                
  ERR_SINGLEACTIONUSED,         
  ERR_ACTIONMISSEFFORT,         
  ERR_NOTACTIVEPLAYER,          
  ERR_SINGLEEFFORTUSED,         
  ERR_PLAYERSTATUS,             
  ERR_NONEXISTENTTARGET,        
  ERR_DOESNTOWNTHEBALL,         
  ERR_CANTPASSTOTHECROWD,       
  ERR_CANTPASSTHATFARAWAY,      
  ERR_NOTENOUGHMOVEMENT,        
  ERR_NOTADJACENTSQUARE,        
  ERR_NOTEMPTYSQUARE,           
  ERR_USEDTEAMREROLL,           
  ERR_NOTSKILLED,               
  ERR_USEDSKILL,                

  ERR_LAST = ERR_USEDSKILL
};

extern const char *bb5_error_str[1 + ERR_LAST];


/*
** Messages (Packet) used to control game state.
*/

DECLARE_PACKET(MSG_INITGAME, MsgInitGame)
  int time_per_turn;  
END_PACKET;

DECLARE_PACKET(MSG_INITHALF, MsgInitHalf)
  int cur_half; 
END_PACKET;

DECLARE_PACKET(MSG_DRAWKICKER, MsgDrawKicker);
  int kickoff;
END_PACKET;

DECLARE_PACKET(MSG_INITKICKOFF, MsgInitKickoff);
  int place_team; 
END_PACKET;

DECLARE_EMPTY_PACKET(MSG_TOUCHBACK, MsgTouchBack);

DECLARE_PACKET(MSG_NEWTURN, MsgNewTurn)
  int cur_half; 
  int cur_turn; 
END_PACKET;

DECLARE_EMPTY_PACKET(MSG_REQUESTPROCESSED, MsgRequestProcessed);

DECLARE_EMPTY_PACKET(MSG_ENDTURN, MsgEndTurn);

DECLARE_PACKET(MSG_ENDGAME, MsgEndGame)
  bool evacuated; 
END_PACKET;

DECLARE_EMPTY_PACKET(MSG_CANCELGAME, MsgCancelGame);

DECLARE_PACKET(MSG_TIMER, MsgTimer)
  bool pause;         
  int time_remaining; 
END_PACKET;

DECLARE_PACKET(MSG_TURNOVER, MsgTurnOver)
  int motive; 
END_PACKET;

DECLARE_EMPTY_PACKET(MSG_MOVETURNMARKER, MsgMoveTurnMarker);

DECLARE_EMPTY_PACKET(MSG_ILLEGALPROC, MsgIllegalProc);

DECLARE_PACKET(MSG_CHAT, MsgChat)
  int msg[32];  
END_PACKET;

DECLARE_EMPTY_PACKET(MSG_DEBUG, MsgDebug);

// A coach tried something forbidden.
DECLARE_PACKET(MSG_ILLEGAL, MsgIllegal)
  int was_token;  
  int error;      
END_PACKET;


#endif /* !CONSTANTS_HH_ */