/home/leaf/crossfire/client/trunk/common/client.h

Go to the documentation of this file.

/*
 * static char *rcsid_common_client_h =
 *   "$Id: client.h 14099 2010-11-15 07:21:33Z mwedel $";
 */
/*
    Crossfire client, a client program for the crossfire program.

    Copyright (C) 2001,2007,2010 Mark Wedel & Crossfire Development 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.

    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., 675 Mass Ave, Cambridge, MA 02139, USA.

    The author can be reached via e-mail to crossfire-devel@real-time.com
*/

#include <config.h>
#include <version.h>
#include <client-types.h>
#include <shared/newclient.h>
#include <item.h>

#ifdef HAVE_DMALLOC_H
#  include <dmalloc.h>
#endif

#define MULTKEYS

#define VERSION_CS 1023
#define VERSION_SC 1029

extern char VERSION_INFO[256];

#define COMMAND_WINDOW 10

#define STRINGCOMMAND 0

#define MAX_SKILL CS_NUM_SKILLS

#define MAXANIM 2000

#define SC_NORMAL  0
#define SC_FIRERUN 1
#define SC_ALWAYS  2

typedef struct Animations {
    uint16  flags;
    uint8   num_animations;             
    uint8   speed;
    uint8   speed_left;
    uint8   phase;
    uint16  *faces;

} Animations;

extern Animations animations[MAXANIM];

#define CAN_SMOOTH(__SQUARE,__LEVEL) ( (                                       \
                                            (__SQUARE.heads[__LEVEL].face==0)  \
                                            && (__LEVEL >0)                    \
                                        )                                      \
                                        || (__SQUARE.smooth[layer])            \
                                     )

typedef struct ClientSocket {
    int fd;
    SockList    inbuf;
    int cs_version, sc_version;         
    int command_sent, command_received; 
    int command_time;                   
    char* servername;
} ClientSocket;

extern ClientSocket csocket;

extern char *server, *client_libdir,*image_file, *sound_server;

typedef enum Input_State {
    Playing, Reply_One, Reply_Many, Configure_Keys, Command_Mode,
    Metaserver_Select
} Input_State;

typedef enum rangetype {
  range_bottom = -1, range_none = 0, range_bow = 1, range_magic = 2,
  range_wand = 3, range_rod = 4, range_scroll = 5, range_horn = 6,
  range_steal = 7,
  range_size = 8
} rangetype;

#define CONFIG_DOWNLOAD         1
#define CONFIG_ECHO             2
#define CONFIG_FASTTCP          3
#define CONFIG_CWINDOW          4
#define CONFIG_CACHE            5
#define CONFIG_FOGWAR           6
#define CONFIG_ICONSCALE        7
#define CONFIG_MAPSCALE         8
#define CONFIG_POPUPS           9
#define CONFIG_DISPLAYMODE      10     
#define CONFIG_SHOWICON         11
#define CONFIG_TOOLTIPS         12
#define CONFIG_SOUND            13
#define CONFIG_SPLITINFO        14
#define CONFIG_SPLITWIN         15
#define CONFIG_SHOWGRID         16
#define CONFIG_LIGHTING         17      
#define CONFIG_TRIMINFO         18
#define CONFIG_MAPWIDTH         19
#define CONFIG_MAPHEIGHT        20
#define CONFIG_FOODBEEP         21
#define CONFIG_DARKNESS         22
#define CONFIG_PORT             23      
#define CONFIG_GRAD_COLOR       24
#define CONFIG_RESISTS          25
#define CONFIG_SMOOTH           26
#define CONFIG_SPLASH           27
#define CONFIG_APPLY_CONTAINER  28      
#define CONFIG_MAPSCROLL        29      
#define CONFIG_SIGNPOPUP        30
#define CONFIG_TIMESTAMP        31
#define CONFIG_NUMS             32      


#define CFG_LT_NONE         0
#define CFG_LT_TILE         1
#define CFG_LT_PIXEL        2
#define CFG_LT_PIXEL_BEST   3

#define CFG_DM_PIXMAP       0
#define CFG_DM_SDL          1
#define CFG_DM_OPENGL       2

extern sint16 want_config[CONFIG_NUMS], use_config[CONFIG_NUMS];

extern const char *const config_names[CONFIG_NUMS]; 
typedef struct Stat_struct {
    sint8 Str;                          
    sint8 Dex;                          
    sint8 Con;                          
    sint8 Wis;                          
    sint8 Cha;                          
    sint8 Int;                          
    sint8 Pow;                          
    sint8 wc;                           
    sint8 ac;                           
    sint8 level;                        
    sint16 hp;                          
    sint16 maxhp;                       
    sint16 sp;                          
    sint16 maxsp;                       
    sint16 grace;                       
    sint16 maxgrace;                    
    sint64 exp;                         
    sint16 food;                        
    sint16 dam;                         
    sint32 speed;                       
    sint32 weapon_sp;                   
    uint32 attuned;                     
    uint32 repelled;                    
    uint32 denied;                      
    uint16 flags;                       
    sint16 resists[30];                 
    uint32 resist_change:1;             
    sint16 skill_level[MAX_SKILL];      
    sint64 skill_exp[MAX_SKILL];        
    uint32 weight_limit;                
} Stats;

typedef struct Spell_struct {
    struct Spell_struct *next;
    char name[256];                     
    char message[10000];                
    uint32 tag;                         
    uint16 level;                       
    uint16 time;                        
    uint16 sp;                          
    uint16 grace;                       
    uint16 dam;                         
    uint8 skill_number;                 
    char *skill;                        
    uint32 path;                        
    sint32 face;                        
    uint8 usage;                        
    char requirements[256];             
} Spell;

typedef struct Player_Struct {
    item        *ob;                    
    item        *below;                 
    item        *container;             
    uint16      count_left;             
    Input_State input_state;            
    char        last_command[MAX_BUF];  
    char        input_text[MAX_BUF];    
    item        *ranges[range_size];    
    uint8       ready_spell;            
    char        spells[255][40];        
    Stats       stats;                  
    Spell       *spelldata;             
    char        title[MAX_BUF];         
    char        range[MAX_BUF];         
    uint32      spells_updated;         
    uint32      fire_on:1;              
    uint32      run_on:1;               
    uint32      meta_on:1;              
    uint32      alt_on:1;               
    uint32      no_echo:1;              
    uint32      count;                  
    uint16      mmapx, mmapy;           
    uint16      pmapx, pmapy;           
    uint8       *magicmap;              
    uint8       showmagic;              
    uint16      mapxres,mapyres;        
#ifdef MULTKEYS
    char    name[ 40 ];                 
#endif
} Client_Player;

#define MAX_FACE_SETS   20
#define MAX_IMAGE_SIZE 320              

typedef struct FaceSets_struct {
    uint8   setnum;                     
    uint8   fallback;                   
    char    *prefix;                    
    char    *fullname;                  
    char    *size;                      
    char    *extension;                 
    char    *comment;                   
} FaceSets;

typedef struct Face_Information_struct {
    uint8   faceset;
    char    *want_faceset;
    sint16  num_images;
    uint32  bmaps_checksum, old_bmaps_checksum;
    sint16  cache_hits, cache_misses;
    uint8   have_faceset_info;          
    FaceSets    facesets[MAX_FACE_SETS];
} Face_Information;

extern Face_Information face_info;

extern Client_Player cpl;               
extern char *skill_names[MAX_SKILL];

extern int last_used_skills[MAX_SKILL+1]; 
typedef enum LogLevel {
  LOG_DEBUG = 0, LOG_INFO = 1, LOG_WARNING = 2, LOG_ERROR = 3, LOG_CRITICAL = 4
} LogLevel;

typedef struct LogEntry {
    char* message;
    char* origin;
    LogLevel level;
    struct LogEntry* next;
} LogEntry;
extern LogEntry* LogFirst;
extern LogEntry* LogLast;
extern int logcount;
typedef void (*LogListener)(LogEntry*);
#define MAX_LOGS 200
#define LOG_APPEND(_Entry) if (LogLast) {\
    LogLast->next=_Entry;\
  } else {\
    LogFirst=_Entry;\
  };\
  LogLast=_Entry;_Entry->next=NULL;\
  if (++logcount > MAX_LOGS)\
  {\
      LogEntry* old = LogFirst;\
      LogFirst = LogFirst -> next;\
      if (old->message) free (old->message);\
      if (old->origin) free (old->origin);\
  }
#define LOG_NEW_ENTRY (LogEntry*)calloc(1,sizeof(LogEntry))
#define LOG_SETMESSAGE(_Entry,_msg) free(_Entry->message);_Entry->message=strdup(_msg)
#define LOG_SETORIGIN(_Entry,_orig) free(_Entry->origin);_Entry->origin=strdup(_orig)

typedef struct PipeLog {
    char* name;
    LogLevel level;
    int log;                            
}PipeLog;

#define CHILD_STDIN      1
#define CHILD_STDOUT     2
#define CHILD_STDERR     4
#define CHILD_SILENTFAIL 8
#define CHILD_TUBE       (CHILD_STDIN|CHILD_STDOUT|CHILD_STDERR)
typedef struct ChildProcess{
    char* name;
    int flag;
    int pid;
    int tube[3];
    PipeLog logger[3];
    struct ChildProcess* next;
}ChildProcess;

#define CHILD_PIPEIN(__child)  (__child->tube[0])
#define CHILD_PIPEOUT(__child) (__child->tube[1])
#define CHILD_PIPEERR(__child) (__child->tube[2])

#define NUM_RESISTS 18

extern const char *const resists_name[NUM_RESISTS];
extern char *meta_server;
extern int meta_port;
extern int metaserver_on, metaserver2_on, serverloginmethod, wantloginmethod;
extern uint32   tick;

typedef struct {
    const char *name;
    int         value;
} NameMapping;

extern NameMapping skill_mapping[MAX_SKILL], resist_mapping[NUM_RESISTS];

extern uint64   *exp_table;
extern uint16   exp_table_max;

#define MAP_MAX_SIZE 31

#define MIN_ALLOCATED_MAP_SIZE  MAP_MAX_SIZE * 2

#define MAX_MAP_OFFSET  8

/* Start of map handling code.
 *
 * For the most part, this actually is not window system specific, but
 * certainly how the client wants to store this may vary.
 */

#define MAXPIXMAPNUM 10000

typedef struct Cache_Entry {
    char    *filename;
    uint32  checksum;
    uint32  ispublic:1;
    void    *image_data;
    struct Cache_Entry  *next;
} Cache_Entry;

#define RI_IMAGE_INFO 0x1
#define RI_IMAGE_SUMS 0x2

extern int  replyinfo_status, requestinfo_sent, replyinfo_last_face;

typedef struct PlayerPosition {
  int x;
  int y;
} PlayerPosition;

extern PlayerPosition pl_pos;

typedef struct Msg_Type_Names {
    int        type;                    
    int        subtype;                 
    const char *style_name;             
} Msg_Type_Names;

extern TextManager* firstTextManager;

/* declared/handled in commands.c .  These variables are documented
 * in that file - the data they present is created by the command
 * code, but consumed by the GUI code.
 */
extern char *motd, *news, *rules;
extern char *motd, *news, *rules;       /* Declared/handled in commands.c */
extern int num_races, used_races, num_classes, used_classes;
extern int stat_points, stat_min, stat_maximum;



/*
 * This structure is used to hold race/class adjustment info, as
 * received by the requestinfo command.  We get the same info
 * for both races and class, so it simplifies code to share a structure.
 */
/* This is how many stats (str, dex, con, etc) that are present
 * in the create character window.
 */
#define NUM_NEW_CHAR_STATS  7

struct Stat_Mapping {
    const char  *widget_suffix; /* within the glade file, suffix used on widget */
    uint8       cs_value;       /* within the protocol, the CS_STAT value */
    uint8       rc_offset;      /* Offset into the stat_adj array */
};

extern struct Stat_Mapping stat_mapping[NUM_NEW_CHAR_STATS];

struct RC_Choice {
    char *choice_name;                  /* name to respond, eg, race_choice_1 */
    char *choice_desc;                  /* Longer description of choice */
    int num_values;                     /* How many values we have */
    char **value_arch;    /* Array arch names */
    char **value_desc;    /* Array of description */
};

typedef struct Race_Class_Info {
    char    *arch_name;     /* Name of the archetype this correponds to */
    char    *public_name;   /* Public (human readadable) name */
    char    *description;   /* Description of the race/class */
    sint8   stat_adj[NUM_NEW_CHAR_STATS];   /* Adjustment values */
    int     num_rc_choice;                  /* Size of following array */
    struct RC_Choice    *rc_choice;         /* array of choices */
} Race_Class_Info;

typedef struct Starting_Map_Info {
    char    *arch_name;     /* Name of archetype for this map */
    char    *public_name;   /* Name of the human readable name */
    char    *description;   /* Description of this map */
} Starting_Map_Info;

extern Race_Class_Info *races, *classes;
extern Starting_Map_Info *starting_map_info;
extern int starting_map_number;

/* End of commands.c data, start of other declarations */
#ifndef MIN
#define MIN(X__,Y__) ( (X__)<(Y__)?(X__):(Y__) )
#endif

#define INFO_NEWS  1
#define INFO_MOTD  2
#define INFO_RULES 3

#ifndef WIN32
#define CONVERT_FILESPEC_TO_OS_FORMAT(path)
#else
extern void replace_chars_with_string(
   char* buffer, const uint16 buffer_size,
       const char find, const char* replace);
#define CONVERT_FILESPEC_TO_OS_FORMAT(path) \
   replace_chars_with_string((path), sizeof(path), '/', "\\")
#endif

#ifndef CPROTO
/* We need to declare most of the structs before we can include this */
#include <proto.h>
#endif