1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
/* $Id: mapdata.h,v 1.2 2006/05/15 05:57:43 mwedel Exp $ */
/*
Crossfire client, a client program for the crossfire program.
Copyright (C) 2005 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
*/
#ifndef MAP_H
#define MAP_H
#include "client-types.h"
/** The protocol supports 10 layers, so set MAXLAYERS accordingly.
*/
#define MAXLAYERS 10
/* Map1 only used 3 layers. Trying to use 10 seems to cause
* problems for that code.
*/
#define MAP1_LAYERS 3
struct MapCellLayer {
sint16 face;
sint8 size_x;
sint8 size_y;
/* Link into animation information.
* animation is provided to us from the server in the map2 command.
* animation_speed is also provided.
* animation_left is how many ticks until animation changes - generated
* by client.
* animation_phase is current phase.
*/
sint16 animation;
uint8 animation_speed;
uint8 animation_left;
uint8 animation_phase;
};
/** The heads[] in the mapcell is used for single part objects
* or the head piece for multipart. The easiest way to think about
* it is that the heads[] contains the map information as specifically
* sent from the server. For the heads value, the size_x and size_y
* represent how many spaces (up and to the left) that image extends
* into.
* The tails are values that the client fills in - if we get
* a big head value, we fill in the tails value so that the display
* logic can easily redraw one space. In this case, the size_ values
* are offsets that point to the head. In this way, the draw logic
* can look at the size of the image, look at these values, and
* know what portion of it to draw.
*/
struct MapCell
{
struct MapCellLayer heads[MAXLAYERS];
struct MapCellLayer tails[MAXLAYERS];
uint16 smooth[MAXLAYERS];
uint8 darkness; /* darkness: 0=fully illuminated, 255=pitch blank */
uint8 need_update:1; /* set if tile should be redrawn */
uint8 have_darkness:1; /* set if darkness information was set */
uint8 need_resmooth:1; /* same has need update but for smoothing only */
uint8 cleared:1; /* If set, this is a fog cell. */
};
struct Map
{
/* Store size of map so we know if map_size has changed
* since the last time we allocated this;
*/
int x;
int y;
struct MapCell **cells;
};
extern struct Map the_map;
/**
* Initializes the module. Allocates memory for the_map. This functions must be
* called before any other function is used.
*/
void mapdata_init(void);
/**
* Resets all stored information.
*/
void mapdata_reset(void);
/**
* Sets the current display size. Must be called whenever a new display size
* was negotiated with the server.
*/
void mapdata_set_size(int viewx, int viewy);
/**
* Updates a tile. Must be called for each entry of a map command received from
* the server.
*/
void mapdata_set_face(int x, int y, int darkness, sint16 face0, sint16 face1, sint16 face2);
/**
* Scrolls the map view. Must be called whenever a map_scroll command was
* received from the server.
*/
void mapdata_scroll(int dx, int dy);
/**
* Clears the map view. Must be called whenever a newmap command was received
* from the server.
*/
void mapdata_newmap(void);
/**
* Checks whether the given coordinates are within the current display size (as
* set by mapdata_set_size).
*/
int mapdata_is_inside(int x, int y);
/**
* Returns the face to display at a given location. This function returns the
* "head" information, i.e. the face information sent by the server.
*/
sint16 mapdata_face(int x, int y, int layer);
/**
* Returns the face to display at a given location. This function returns the
* "tail" information, i.e. big faces expanded by the client.
*
* *ww and *hh return the offset of the current tile relative to the head;
* 0 <= *ww < (width of face), 0 <= *hh < (height of face).
*
* When drawing the map view, this function must be used instead than a direct
* access to the_map.cells[]. This is because the_map.cells[] eventually still
* contains obsolete (fog of war) big face information; this function detects
* and clears such faces.
*/
sint16 mapdata_bigface(int x, int y, int layer, int *ww, int *hh);
#endif
|
