trunk/html/client_8h_source.html

#ifndef _CLIENT_H

#define _CLIENT_H


#include "config.h"


// This is required for 'newclient.h' to expose client variables.

#define CLIENT_TYPES_H


#include <fcntl.h>

#include <glib.h>

#include <stdbool.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/time.h>

#include <sys/types.h>

#include <time.h>

#include <unistd.h>


#include <gio/gio.h>


#ifdef WIN32

#  include <winsock2.h>

#endif


#include "item.h"

#include "shared/newclient.h"

#include "version.h"


#ifndef SOL_TCP

#define SOL_TCP IPPROTO_TCP

#endif


#define MAX_BUF 256

#define BIG_BUF 1024


/* used to register gui callbacks to extended texts

 * (which are supposed to be handled more friendly than raw text)*/

typedef void (*ExtTextManager)(int flag, int type, int subtype, char* message);


typedef struct TextManager{

    int type;

    ExtTextManager callback;

    struct TextManager* next;

} TextManager;


/* This is how often the client checks for X events, as well as how often

 * it performs animations (or will).  This value can be most anything.

 * IT is only configurable because the exact value it needs to be set to

 * has to be figured out.  This value is in microseconds (100,000 microseconds=

 * 0.1 seconds

 */

#define MAX_TIME 100000


/* This is the default port to connect to the server with. */

#define EPORT 13327


/* This is the default port to connect to the server with in string form. */

#define DEFPORT "13327"


#define VERSION_CS 1023

#define VERSION_SC 1030


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

#define SC_MOVETO  3


typedef struct Animations {

    guint16  flags;

    guint8   num_animations;

    guint8   speed;

    guint8   speed_left;

    guint8   phase;

    guint16  *faces;


} Animations;


extern Animations animations[MAXANIM];


#define COMMAND_MAX 255


typedef struct {

    GSocketConnection* fd;

    int cs_version, sc_version;

    guint16 command_sent, command_received;

    int command_time;

    char* servername;

    gint8 dir[COMMAND_MAX];    //< Direction of sent movement command (or -1) for local prediction

} ClientSocket;


extern ClientSocket csocket;


extern char *sound_server;

extern const char *cache_dir, *config_dir;


typedef enum {

    Playing,            //< including account login, character selection

    Reply_One, Reply_Many, Configure_Keys, Command_Mode,

    Metaserver_Select   //< only when metaserver window is up

} Input_State;


typedef enum {

  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_AUTO_AFK         32

#define CONFIG_INV_MENU         33

#define CONFIG_MUSIC_VOL        34

#define CONFIG_SERVER_TICKS     35      //< Send "setup tick 1" for the server to send ticks, else generate our own

#define CONFIG_NUMS             36


#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 gint16 want_config[CONFIG_NUMS], use_config[CONFIG_NUMS];


extern const char *const config_names[CONFIG_NUMS];

typedef struct Stat_struct {

    gint8 Str;

    gint8 Dex;

    gint8 Con;

    gint8 Wis;

    gint8 Cha;

    gint8 Int;

    gint8 Pow;

    gint8 wc;

    gint8 ac;

    gint8 level;

    gint16 hp;

    gint16 maxhp;

    gint16 sp;

    gint16 maxsp;

    gint16 grace;

    gint16 maxgrace;

    gint64 exp;

    gint16 food;

    gint16 dam;

    gint32 speed;

    gint32 weapon_sp;

    guint32 attuned;

    guint32 repelled;

    guint32 denied;

    guint16 flags;

    gint16 resists[30];

    guint32 resist_change:1;

    gint16 skill_level[MAX_SKILL];

    gint64 skill_exp[MAX_SKILL];

    guint32 weight_limit;

} Stats;


typedef struct Spell_struct {

    struct Spell_struct *next;

    char name[256];

    char message[10000];

    guint32 tag;

    guint16 level;

    guint16 time;

    guint16 sp;

    guint16 grace;

    guint16 dam;

    guint8 skill_number;

    char *skill;

    guint32 path;

    gint32 face;

    guint8 usage;

    char requirements[256];

} Spell;


typedef struct Player_Struct {

    item        *ob;

    item        *below;

    item        *container;

    guint16      count_left;

    Input_State input_state;

    char        last_command[MAX_BUF];

    char        input_text[MAX_BUF];

    item        *ranges[range_size];

    guint8       ready_spell;

    char        spells[255][40];

    Stats       stats;

    Spell       *spelldata;

    char        title[MAX_BUF];

    char        range[MAX_BUF];

    guint32      spells_updated;

    guint32      fire_on:1;

    guint32      run_on:1;

    guint32      meta_on:1;

    guint32      alt_on:1;

    guint32      no_echo:1;

    guint32      count;

    guint16      mmapx, mmapy;

    guint16      pmapx, pmapy;

    guint8       *magicmap;

    guint8       showmagic;

    guint16      mapxres,mapyres;

    char        *name;

} Client_Player;


#define MAX_FACE_SETS   20

#define MAX_IMAGE_SIZE 320


typedef struct FaceSets_struct {

    guint8   setnum;

    guint8   fallback;

    char    *prefix;

    char    *fullname;

    char    *size;

    char    *extension;

    char    *comment;

} FaceSets;


typedef struct Face_Information_struct {

    guint8   faceset;

    char    *want_faceset;

    gint16  num_images;

    guint32  bmaps_checksum, old_bmaps_checksum;

    gint16  cache_hits, cache_misses;

    guint8   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 {

    LOG_DEBUG = 0,

    LOG_INFO = 1,

    LOG_WARNING = 2,

    LOG_ERROR = 3,

    LOG_CRITICAL = 4

} LogLevel;


#define NUM_RESISTS 18


extern const char *const resists_name[NUM_RESISTS];

extern char *meta_server;

extern int serverloginmethod, wantloginmethod;


typedef struct {

    const char *name;

    int         value;

} NameMapping;


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


extern guint64   *exp_table;

extern guint16   exp_table_max;


#define MAP_MAX_SIZE 25


#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;

    guint32  checksum;

    guint32  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 */

    guint8       cs_value;       /* within the protocol, the CS_STAT value */

    guint8       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 */

    gint8   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;

extern int maxfd;


/* 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


#define CLIENT_ERROR client_error_quark()


inline GQuark client_error_quark() {

    return g_quark_from_static_string("client-error-quark");

}


enum ClientError {

    CLIENT_ERROR_TOOBIG

};


/* We need to declare most of the structs before we can include this */

#include "proto.h"


extern void client_connect(const char *hostname);


extern void client_disconnect(void);


extern void client_negotiate(int sound);


extern void client_mapsize(int width, int height);


extern void client_run(void);


extern bool client_write(const void *buf, int len);


extern bool client_is_connected(void);


extern GSource *client_get_source(void);


extern GTimer* global_time;


extern bool debug_protocol;

char *printable(void *data, int len);


#endif