ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/socket/item.C
(Generate patch)

Comparing deliantra/server/socket/item.C (file contents):
Revision 1.1 by elmex, Sun Aug 13 17:16:06 2006 UTC vs.
Revision 1.11 by root, Wed Dec 13 21:27:09 2006 UTC

1
2/*
3 * static char *rcsid_item_c =
4 * "$Id: item.C,v 1.1 2006/08/13 17:16:06 elmex Exp $";
5 */
6
7/* 1/*
8 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
9 3
10 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
11 Copyright (C) 1992 Frank Tore Johansen 5 Copyright (C) 1992 Frank Tore Johansen
… …
22 16
23 You should have received a copy of the GNU General Public License 17 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 20
27 The author can be reached via e-mail to crossfire-devel@real-time.com 21 The author can be reached via e-mail to <crossfire@schmorp.de>
28*/ 22*/
29 23
30/** 24/**
31 * \file 25 * \file
32 * Client/server logic. 26 * Client/server logic.
… …
38 * the logic for what items should be sent. 32 * the logic for what items should be sent.
39 */ 33 */
40 34
41 35
42#include <global.h> 36#include <global.h>
43#include <object.h> /* LOOK_OBJ */ 37#include <object.h> /* LOOK_OBJ */
44#include <newclient.h> 38#include <newclient.h>
45#include <newserver.h> 39#include <newserver.h>
46#include <sproto.h> 40#include <sproto.h>
47 41
48/** This is the maximum number of bytes we expect any one item to take up */ 42/** This is the maximum number of bytes we expect any one item to take up */
… …
60 * This is a simple function that we use a lot here. It basically 54 * This is a simple function that we use a lot here. It basically
61 * adds the specified buffer into the socklist, but prepends a 55 * adds the specified buffer into the socklist, but prepends a
62 * single byte in length. If the data is longer than that byte, it is 56 * single byte in length. If the data is longer than that byte, it is
63 * truncated approprately. 57 * truncated approprately.
64 */ 58 */
59inline void
65inline void add_stringlen_to_sockbuf(const char *buf, SockList *sl) 60add_stringlen_to_sockbuf (const char *buf, SockList * sl)
66{ 61{
67 int len; 62 int len;
68 63
69 len=strlen(buf); 64 len = strlen (buf);
70 if (len>255) len=255; 65 if (len > 255)
66 len = 255;
71 SockList_AddChar(sl, (char) len); 67 SockList_AddChar (sl, (char) len);
72 strncpy((char*)sl->buf+sl->len, buf,len); 68 strncpy ((char *) sl->buf + sl->len, buf, len);
73 sl->len += len; 69 sl->len += len;
74} 70}
75 71
76/** 72/**
77 * This is a similar to query_name, but returns flags 73 * This is a similar to query_name, but returns flags
78 * to be sended to client. 74 * to be sended to client.
79 */ 75 */
76unsigned int
80unsigned int query_flags (object *op) 77query_flags (object *op)
81{ 78{
82 unsigned int flags = 0; 79 unsigned int flags = 0;
83 80
84 if(QUERY_FLAG(op,FLAG_APPLIED)) { 81 if (QUERY_FLAG (op, FLAG_APPLIED))
85 switch(op->type) {
86 case BOW:
87 case WAND:
88 case ROD:
89 case HORN:
90 flags = a_readied;
91 break;
92 case WEAPON:
93 flags = a_wielded;
94 break;
95 case SKILL:
96 case ARMOUR:
97 case HELMET:
98 case SHIELD:
99 case RING:
100 case BOOTS:
101 case GLOVES:
102 case AMULET:
103 case GIRDLE:
104 case BRACERS:
105 case CLOAK:
106 flags = a_worn;
107 break;
108 case CONTAINER:
109 flags = a_active;
110 break;
111 default:
112 flags = a_applied;
113 break;
114 }
115 }
116 if (op->type == CONTAINER && ((op->env && op->env->container == op) ||
117 (!op->env && QUERY_FLAG(op,FLAG_APPLIED))))
118 flags |= F_OPEN;
119 82 {
83 switch (op->type)
84 {
85 case BOW:
86 case WAND:
87 case ROD:
88 case HORN:
89 flags = a_readied;
90 break;
91 case WEAPON:
92 flags = a_wielded;
93 break;
94 case SKILL:
95 case ARMOUR:
96 case HELMET:
97 case SHIELD:
98 case RING:
99 case BOOTS:
100 case GLOVES:
101 case AMULET:
102 case GIRDLE:
103 case BRACERS:
104 case CLOAK:
105 flags = a_worn;
106 break;
107 case CONTAINER:
108 flags = a_active;
109 break;
110 default:
111 flags = a_applied;
112 break;
113 }
114 }
115 if (op->type == CONTAINER && ((op->env && op->env->container == op) || (!op->env && QUERY_FLAG (op, FLAG_APPLIED))))
116 flags |= F_OPEN;
117
120 if (QUERY_FLAG(op,FLAG_KNOWN_CURSED)) { 118 if (QUERY_FLAG (op, FLAG_KNOWN_CURSED))
119 {
121 if(QUERY_FLAG(op,FLAG_DAMNED)) 120 if (QUERY_FLAG (op, FLAG_DAMNED))
122 flags |= F_DAMNED; 121 flags |= F_DAMNED;
123 else if(QUERY_FLAG(op,FLAG_CURSED)) 122 else if (QUERY_FLAG (op, FLAG_CURSED))
124 flags |= F_CURSED; 123 flags |= F_CURSED;
125 } 124 }
126 if (QUERY_FLAG(op,FLAG_KNOWN_MAGICAL) && !QUERY_FLAG(op,FLAG_IDENTIFIED)) 125 if (QUERY_FLAG (op, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (op, FLAG_IDENTIFIED))
127 flags |= F_MAGIC; 126 flags |= F_MAGIC;
128 if (QUERY_FLAG(op,FLAG_UNPAID)) 127 if (QUERY_FLAG (op, FLAG_UNPAID))
129 flags |= F_UNPAID; 128 flags |= F_UNPAID;
130 if (QUERY_FLAG(op,FLAG_INV_LOCKED)) 129 if (QUERY_FLAG (op, FLAG_INV_LOCKED))
131 flags |= F_LOCKED; 130 flags |= F_LOCKED;
132 131
133 return flags; 132 return flags;
134} 133}
135 134
136/* Used in the send_look to put object head into SockList 135/* Used in the send_look to put object head into SockList
137 * sl for socket ns. Need socket to know if we need to send 136 * sl for socket ns. Need socket to know if we need to send
138 * animation of face to the client. 137 * animation of face to the client.
139 */ 138 */
139static void
140static void add_object_to_socklist(NewSocket *ns, SockList *sl, object *head) 140add_object_to_socklist (NewSocket * ns, SockList * sl, object *head)
141{ 141{
142 int flags, len, anim_speed; 142 int flags, len, anim_speed;
143 char item_n[MAX_BUF]; 143 char item_n[MAX_BUF];
144 const char *item_p; 144 const char *item_p;
145 145
146 flags = query_flags (head); 146 flags = query_flags (head);
147 if (QUERY_FLAG(head, FLAG_NO_PICK)) 147 if (QUERY_FLAG (head, FLAG_NO_PICK))
148 flags |= F_NOPICK; 148 flags |= F_NOPICK;
149 149
150 if (!(ns->faces_sent[head->face->number] & NS_FACESENT_FACE)) 150 if (!(ns->faces_sent[head->face->number] & NS_FACESENT_FACE))
151 esrv_send_face(ns, head->face->number,0); 151 esrv_send_face (ns, head->face->number, 0);
152 152
153 if (QUERY_FLAG(head,FLAG_ANIMATE) && !ns->anims_sent[head->animation_id]) 153 if (QUERY_FLAG (head, FLAG_ANIMATE) && !ns->anims_sent[head->animation_id])
154 esrv_send_animation(ns, head->animation_id); 154 esrv_send_animation (ns, head->animation_id);
155 155
156 SockList_AddInt(sl, head->count); 156 SockList_AddInt (sl, head->count);
157 SockList_AddInt(sl, flags); 157 SockList_AddInt (sl, flags);
158 SockList_AddInt(sl, QUERY_FLAG(head, FLAG_NO_PICK) ? -1 : WEIGHT(head)); 158 SockList_AddInt (sl, QUERY_FLAG (head, FLAG_NO_PICK) ? -1 : WEIGHT (head));
159 SockList_AddInt(sl, head->face->number); 159 SockList_AddInt (sl, head->face->number);
160 160
161 if (!head->custom_name) { 161 if (!head->custom_name)
162 {
162 strncpy(item_n,query_base_name(head, 0),127); 163 strncpy (item_n, query_base_name (head, 0), 127);
163 item_n[127]=0; 164 item_n[127] = 0;
164 len=strlen(item_n); 165 len = strlen (item_n);
165 item_p=query_base_name(head, 1); 166 item_p = query_base_name (head, 1);
166 } else { 167 }
168 else
169 {
167 strncpy(item_n,head->custom_name,127); 170 strncpy (item_n, head->custom_name, 127);
168 item_n[127]=0; 171 item_n[127] = 0;
169 len=strlen(item_n); 172 len = strlen (item_n);
170 item_p=head->custom_name; 173 item_p = head->custom_name;
171 } 174 }
172 strncpy(item_n+len+1, item_p, 127); 175 strncpy (item_n + len + 1, item_p, 127);
173 item_n[254]=0; 176 item_n[254] = 0;
174 len += strlen(item_n+1+len) + 1; 177 len += strlen (item_n + 1 + len) + 1;
175 SockList_AddChar(sl, (char ) len); 178 SockList_AddChar (sl, (char) len);
176 memcpy(sl->buf+sl->len, item_n, len); 179 memcpy (sl->buf + sl->len, item_n, len);
177 sl->len += len; 180 sl->len += len;
178 181
179 SockList_AddShort(sl,head->animation_id); 182 SockList_AddShort (sl, head->animation_id);
180 anim_speed=0; 183 anim_speed = 0;
181 if (QUERY_FLAG(head,FLAG_ANIMATE)) { 184 if (QUERY_FLAG (head, FLAG_ANIMATE))
182 if (head->anim_speed) anim_speed=head->anim_speed;
183 else {
184 if (FABS(head->speed)<0.001) anim_speed=255;
185 else if (FABS(head->speed)>=1.0) anim_speed=1;
186 else anim_speed = (int) (1.0/FABS(head->speed));
187 }
188 if (anim_speed>255) anim_speed=255;
189 } 185 {
186 if (head->anim_speed)
187 anim_speed = head->anim_speed;
188 else
189 {
190 if (FABS (head->speed) < 0.001)
191 anim_speed = 255;
192 else if (FABS (head->speed) >= 1.0)
193 anim_speed = 1;
194 else
195 anim_speed = (int) (1.0 / FABS (head->speed));
196 }
197 if (anim_speed > 255)
198 anim_speed = 255;
199 }
190 SockList_AddChar(sl, (char) anim_speed); 200 SockList_AddChar (sl, (char) anim_speed);
191 SockList_AddInt(sl, head->nrof); 201 SockList_AddInt (sl, head->nrof);
192 202
193 if (ns->itemcmd == 2) 203 if (ns->itemcmd == 2)
194 SockList_AddShort(sl, head->client_type); 204 SockList_AddShort (sl, head->client_type);
195 205
196 SET_FLAG(head, FLAG_CLIENT_SENT); 206 SET_FLAG (head, FLAG_CLIENT_SENT);
197} 207}
198 208
199 209
200/** 210/**
201 * Send the look window. Don't need to do animations here 211 * Send the look window. Don't need to do animations here
202 * This sends all the faces to the client, not just updates. This is 212 * This sends all the faces to the client, not just updates. This is
203 * because object ordering would otherwise be inconsistent 213 * because object ordering would otherwise be inconsistent
204 */ 214 */
205 215
216void
206void esrv_draw_look(object *pl) 217esrv_draw_look (object *pl)
207{ 218{
208 object *tmp, *last; 219 object *tmp, *last;
209 int got_one=0,start_look=0, end_look=0; 220 int got_one = 0, start_look = 0, end_look = 0;
210 SockList sl; 221 SockList sl;
211 char buf[MAX_BUF]; 222 char buf[MAX_BUF];
212 223
213 if (!pl->contr->socket.update_look) { 224 if (!pl->contr->socket.update_look)
225 {
214 LOG(llevDebug,"esrv_draw_look called when update_look was not set\n"); 226 LOG (llevDebug, "esrv_draw_look called when update_look was not set\n");
215 return; 227 return;
216 } else { 228 }
229 else
230 {
217 pl->contr->socket.update_look=0; 231 pl->contr->socket.update_look = 0;
218 } 232 }
219 233
220 if(QUERY_FLAG(pl, FLAG_REMOVED) || pl->map == NULL || 234 if (QUERY_FLAG (pl, FLAG_REMOVED) || pl->map == NULL || pl->map->in_memory != MAP_IN_MEMORY || out_of_map (pl->map, pl->x, pl->y))
221 pl->map->in_memory != MAP_IN_MEMORY || out_of_map(pl->map,pl->x,pl->y))
222 return; 235 return;
223 236
224 if (pl->contr->transport)
225 for (tmp=pl->contr->transport->inv; tmp && tmp->above;tmp=tmp->above) ;
226 else
227 for (tmp=get_map_ob(pl->map,pl->x,pl->y); tmp && tmp->above;tmp=tmp->above) ; 237 for (tmp = get_map_ob (pl->map, pl->x, pl->y); tmp && tmp->above; tmp = tmp->above);
228 238
229 sl.buf= (unsigned char *) malloc(MAXSOCKBUF); 239 sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
230 240
231 Write_String_To_Socket(&pl->contr->socket, "delinv 0", strlen("delinv 0")); 241 Write_String_To_Socket (&pl->contr->socket, "delinv 0", strlen ("delinv 0"));
232 sprintf((char*)sl.buf,"item%d ", pl->contr->socket.itemcmd); 242 sprintf ((char *) sl.buf, "item%d ", pl->contr->socket.itemcmd);
233 sl.len=strlen((char*)sl.buf); 243 sl.len = strlen ((char *) sl.buf);
234 244
235 SockList_AddInt(&sl, 0); 245 SockList_AddInt (&sl, 0);
236 246
237 if (!(pl->contr->socket.faces_sent[empty_face->number]&NS_FACESENT_FACE)) 247 if (!(pl->contr->socket.faces_sent[empty_face->number] & NS_FACESENT_FACE))
238 esrv_send_face(&pl->contr->socket, empty_face->number,0); 248 esrv_send_face (&pl->contr->socket, empty_face->number, 0);
239 249
240 if (pl->contr->socket.look_position) { 250 if (pl->contr->socket.look_position)
251 {
241 SockList_AddInt(&sl, 0x80000000 | (pl->contr->socket.look_position- NUM_LOOK_OBJECTS)); 252 SockList_AddInt (&sl, 0x80000000 | (pl->contr->socket.look_position - NUM_LOOK_OBJECTS));
242 SockList_AddInt(&sl, 0); 253 SockList_AddInt (&sl, 0);
243 SockList_AddInt(&sl, (uint32) -1); 254 SockList_AddInt (&sl, (uint32) - 1);
244 SockList_AddInt(&sl, empty_face->number); 255 SockList_AddInt (&sl, empty_face->number);
245 sprintf(buf,"Click here to see %d previous items", NUM_LOOK_OBJECTS); 256 sprintf (buf, "Click here to see %d previous items", NUM_LOOK_OBJECTS);
246 add_stringlen_to_sockbuf(buf, &sl); 257 add_stringlen_to_sockbuf (buf, &sl);
247 SockList_AddShort(&sl,0);
248 SockList_AddChar(&sl, 0);
249 SockList_AddInt(&sl, 0);
250 if (pl->contr->socket.itemcmd == 2)
251 SockList_AddShort(&sl, 0); 258 SockList_AddShort (&sl, 0);
259 SockList_AddChar (&sl, 0);
260 SockList_AddInt (&sl, 0);
261 if (pl->contr->socket.itemcmd == 2)
262 SockList_AddShort (&sl, 0);
252 } 263 }
253 264
254 if (pl->contr->transport) {
255 add_object_to_socklist(&pl->contr->socket, &sl, pl->contr->transport);
256 got_one++;
257 }
258
259 for (last=NULL; tmp!=last; tmp=tmp->below) { 265 for (last = NULL; tmp != last; tmp = tmp->below)
266 {
260 object *head; 267 object *head;
261 268
262 if (QUERY_FLAG(tmp, FLAG_IS_FLOOR) && !last) { 269 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) && !last)
270 {
263 last = tmp->below; /* assumes double floor mode */ 271 last = tmp->below; /* assumes double floor mode */
264 if (last && QUERY_FLAG(last, FLAG_IS_FLOOR)) 272 if (last && QUERY_FLAG (last, FLAG_IS_FLOOR))
265 last = last->below; 273 last = last->below;
266 } 274 }
267 if (LOOK_OBJ(tmp)) { 275 if (LOOK_OBJ (tmp))
276 {
268 if (++start_look < pl->contr->socket.look_position) continue; 277 if (++start_look < pl->contr->socket.look_position)
278 continue;
269 end_look++; 279 end_look++;
270 if (end_look > NUM_LOOK_OBJECTS) { 280 if (end_look > NUM_LOOK_OBJECTS)
281 {
271 /* What we basically do is make a 'fake' object - when the user applies it, 282 /* What we basically do is make a 'fake' object - when the user applies it,
272 * we notice the special tag the object has, and act accordingly. 283 * we notice the special tag the object has, and act accordingly.
273 */ 284 */
274 SockList_AddInt(&sl, 0x80000000 | (pl->contr->socket.look_position+ NUM_LOOK_OBJECTS)); 285 SockList_AddInt (&sl, 0x80000000 | (pl->contr->socket.look_position + NUM_LOOK_OBJECTS));
275 SockList_AddInt(&sl, 0); 286 SockList_AddInt (&sl, 0);
276 SockList_AddInt(&sl, (uint32) -1); 287 SockList_AddInt (&sl, (uint32) - 1);
277 SockList_AddInt(&sl, empty_face->number); 288 SockList_AddInt (&sl, empty_face->number);
278 sprintf(buf,"Click here to see next group of items"); 289 sprintf (buf, "Click here to see next group of items");
279 add_stringlen_to_sockbuf(buf, &sl); 290 add_stringlen_to_sockbuf (buf, &sl);
280 SockList_AddShort(&sl,0);
281 SockList_AddChar(&sl, 0);
282 SockList_AddInt(&sl, 0);
283 if (pl->contr->socket.itemcmd == 2)
284 SockList_AddShort(&sl, 0); 291 SockList_AddShort (&sl, 0);
285 break; 292 SockList_AddChar (&sl, 0);
286 } 293 SockList_AddInt (&sl, 0);
287 if (tmp->head) head = tmp->head; 294 if (pl->contr->socket.itemcmd == 2)
288 else head = tmp; 295 SockList_AddShort (&sl, 0);
296 break;
297 }
298 if (tmp->head)
299 head = tmp->head;
300 else
301 head = tmp;
289 302
290 add_object_to_socklist(&pl->contr->socket, &sl, head); 303 add_object_to_socklist (&pl->contr->socket, &sl, head);
291 got_one++; 304 got_one++;
292 305
293 if (sl.len >= (MAXSOCKBUF-MAXITEMLEN)) { 306 if (sl.len >= (MAXSOCKBUF - MAXITEMLEN))
307 {
294 Send_With_Handling(&pl->contr->socket, &sl); 308 Send_With_Handling (&pl->contr->socket, &sl);
295 sprintf((char*)sl.buf,"item%d ", pl->contr->socket.itemcmd); 309 sprintf ((char *) sl.buf, "item%d ", pl->contr->socket.itemcmd);
296 sl.len=strlen((char*)sl.buf); 310 sl.len = strlen ((char *) sl.buf);
297 SockList_AddInt(&sl, 0); 311 SockList_AddInt (&sl, 0);
298 got_one=0; 312 got_one = 0;
313 }
314 } /* If LOOK_OBJ() */
299 } 315 }
300 } /* If LOOK_OBJ() */
301 }
302 if (got_one) 316 if (got_one)
303 Send_With_Handling(&pl->contr->socket, &sl); 317 Send_With_Handling (&pl->contr->socket, &sl);
304 318
305 free(sl.buf); 319 free (sl.buf);
306} 320}
307 321
308/** 322/**
309 * Sends whole inventory. 323 * Sends whole inventory.
310 */ 324 */
325void
311void esrv_send_inventory(object *pl, object *op) 326esrv_send_inventory (object *pl, object *op)
312{ 327{
313 object *tmp; 328 object *tmp;
314 int got_one=0; 329 int got_one = 0;
315 SockList sl; 330 SockList sl;
316 331
317 sl.buf= (unsigned char *) malloc(MAXSOCKBUF); 332 sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
318 333
319 sprintf((char*)sl.buf,"delinv %d", op->count); 334 sprintf ((char *) sl.buf, "delinv %d", op->count);
320 sl.len=strlen((char*)sl.buf); 335 sl.len = strlen ((char *) sl.buf);
336 Send_With_Handling (&pl->contr->socket, &sl);
337
338 sprintf ((char *) sl.buf, "item%d ", pl->contr->socket.itemcmd);
339 sl.len = strlen ((char *) sl.buf);
340
341 SockList_AddInt (&sl, op->count);
342
343 for (tmp = op->inv; tmp; tmp = tmp->below)
344 {
345 object *head;
346
347 if (tmp->head)
348 head = tmp->head;
349 else
350 head = tmp;
351
352 if (LOOK_OBJ (head))
353 {
354 add_object_to_socklist (&pl->contr->socket, &sl, head);
355
356 got_one++;
357
358 /* IT is possible for players to accumulate a huge amount of
359 * items (especially with some of the bags out there) to
360 * overflow the buffer. IF so, send multiple item commands.
361 */
362 if (sl.len >= (MAXSOCKBUF - MAXITEMLEN))
363 {
364 Send_With_Handling (&pl->contr->socket, &sl);
365 sprintf ((char *) sl.buf, "item%d ", pl->contr->socket.itemcmd);
366 sl.len = strlen ((char *) sl.buf);
367 SockList_AddInt (&sl, op->count);
368 got_one = 0;
369 }
370 } /* If LOOK_OBJ() */
371 }
372 if (got_one)
321 Send_With_Handling(&pl->contr->socket, &sl); 373 Send_With_Handling (&pl->contr->socket, &sl);
322
323 sprintf((char*)sl.buf,"item%d ", pl->contr->socket.itemcmd);
324 sl.len=strlen((char*)sl.buf);
325
326 SockList_AddInt(&sl, op->count);
327
328 for (tmp=op->inv; tmp; tmp=tmp->below) {
329 object *head;
330
331 if (tmp->head) head = tmp->head;
332 else head = tmp;
333
334 if (LOOK_OBJ(head)) {
335 add_object_to_socklist(&pl->contr->socket, &sl, head);
336
337 got_one++;
338
339 /* IT is possible for players to accumulate a huge amount of
340 * items (especially with some of the bags out there) to
341 * overflow the buffer. IF so, send multiple item commands.
342 */
343 if (sl.len >= (MAXSOCKBUF-MAXITEMLEN)) {
344 Send_With_Handling(&pl->contr->socket, &sl);
345 sprintf((char*)sl.buf,"item%d ", pl->contr->socket.itemcmd);
346 sl.len=strlen((char*)sl.buf);
347 SockList_AddInt(&sl, op->count);
348 got_one=0;
349 }
350 } /* If LOOK_OBJ() */
351 }
352 if (got_one)
353 Send_With_Handling(&pl->contr->socket, &sl);
354 free(sl.buf); 374 free (sl.buf);
355} 375}
356 376
357/** 377/**
358 * Updates object *op for player *pl. 378 * Updates object *op for player *pl.
359 * 379 *
360 * flags is a list of values to update 380 * flags is a list of values to update
361 * to the client (as defined in newclient.h - might as well use the 381 * to the client (as defined in newclient.h - might as well use the
362 * same value both places. 382 * same value both places.
363 */ 383 */
364 384
385void
365void esrv_update_item(int flags, object *pl, object *op) 386esrv_update_item (int flags, object *pl, object *op)
366{ 387{
367 SockList sl; 388 SockList sl;
368 389
369 /* If we have a request to send the player item, skip a few checks. */ 390 /* If we have a request to send the player item, skip a few checks. */
370 if (op!=pl) { 391 if (op != pl)
392 {
371 if (! LOOK_OBJ(op)) 393 if (!LOOK_OBJ (op))
372 return; 394 return;
373 /* we remove the check for op->env, because in theory, the object 395 /* we remove the check for op->env, because in theory, the object
374 * is hopefully in the same place, so the client should preserve 396 * is hopefully in the same place, so the client should preserve
375 * order. 397 * order.
376 */ 398 */
377 } 399 }
400
378 if (!QUERY_FLAG(op, FLAG_CLIENT_SENT)) { 401 if (!QUERY_FLAG (op, FLAG_CLIENT_SENT))
402 {
379 /* FLAG_CLIENT_SENT is debug only. We are using it to see where 403 /* FLAG_CLIENT_SENT is debug only. We are using it to see where
380 * this is happening - we can set a breakpoint here in the debugger 404 * this is happening - we can set a breakpoint here in the debugger
381 * and track back the call. 405 * and track back the call.
382 */ 406 */
383 LOG(llevDebug,"We have not sent item %s (%d)\n", op->name, op->count); 407 LOG (llevDebug, "We have not sent item %s (%d)\n", &op->name, op->count);
384 } 408 }
409
385 sl.buf= (unsigned char *) malloc(MAXSOCKBUF); 410 sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
386 411
387 strcpy((char*)sl.buf,"upditem "); 412 strcpy ((char *) sl.buf, "upditem ");
388 sl.len=strlen((char*)sl.buf); 413 sl.len = strlen ((char *) sl.buf);
389 414
390 SockList_AddChar(&sl, (char) flags); 415 SockList_AddChar (&sl, (char) flags);
391 416
392 if (op->head) op=op->head; 417 if (op->head)
418 op = op->head;
393 419
394 SockList_AddInt(&sl, op->count); 420 SockList_AddInt (&sl, op->count);
395 421
396 if (flags & UPD_LOCATION) 422 if (flags & UPD_LOCATION)
397 SockList_AddInt(&sl, op->env? op->env->count:0); 423 SockList_AddInt (&sl, op->env ? op->env->count : 0);
398 424
399 if (flags & UPD_FLAGS) 425 if (flags & UPD_FLAGS)
400 SockList_AddInt(&sl, query_flags(op)); 426 SockList_AddInt (&sl, query_flags (op));
401 427
402 if (flags & UPD_WEIGHT) { 428 if (flags & UPD_WEIGHT)
429 {
403 sint32 weight = WEIGHT(op); 430 sint32 weight = WEIGHT (op);
404 431
405 /* TRANSPORTS are odd - they sort of look like containers, yet can't be
406 * picked up. So we don't to send the weight, as it is odd that you see
407 * weight sometimes and not other (the draw_look won't send it
408 * for example.
409 */
410 SockList_AddInt(&sl, QUERY_FLAG(op, FLAG_NO_PICK) ? -1 : weight); 432 SockList_AddInt (&sl, QUERY_FLAG (op, FLAG_NO_PICK) ? -1 : weight);
411 if (pl == op) { 433 if (pl == op)
434 {
412 op->contr->last_weight = weight; 435 op->contr->last_weight = weight;
413 } 436 }
414 } 437 }
415 438
416 if (flags & UPD_FACE) { 439 if (flags & UPD_FACE)
440 {
417 if (!(pl->contr->socket.faces_sent[op->face->number] & NS_FACESENT_FACE)) 441 if (!(pl->contr->socket.faces_sent[op->face->number] & NS_FACESENT_FACE))
418 esrv_send_face(&pl->contr->socket, op->face->number,0); 442 esrv_send_face (&pl->contr->socket, op->face->number, 0);
419 SockList_AddInt(&sl, op->face->number); 443 SockList_AddInt (&sl, op->face->number);
420 } 444 }
445
421 if (flags & UPD_NAME) { 446 if (flags & UPD_NAME)
422 int len; 447 {
448 int len;
423 const char *item_p; 449 const char *item_p;
424 char item_n[MAX_BUF]; 450 char item_n[MAX_BUF];
425 451
426 if (!op->custom_name) { 452 if (!op->custom_name)
453 {
427 strncpy(item_n,query_base_name(op, 0),127); 454 strncpy (item_n, query_base_name (op, 0), 127);
428 item_n[127]=0; 455 item_n[127] = 0;
429 len=strlen(item_n); 456 len = strlen (item_n);
430 item_p=query_base_name(op, 1); 457 item_p = query_base_name (op, 1);
431 } 458 }
432 else { 459 else
460 {
433 strncpy(item_n,op->custom_name,127); 461 strncpy (item_n, op->custom_name, 127);
434 item_n[127]=0; 462 item_n[127] = 0;
435 len=strlen(item_n); 463 len = strlen (item_n);
436 item_p=op->custom_name; 464 item_p = op->custom_name;
437 } 465 }
438 466
439 strncpy(item_n+len+1, item_p, 127); 467 strncpy (item_n + len + 1, item_p, 127);
440 item_n[254]=0; 468 item_n[254] = 0;
441 len += strlen(item_n+1+len) + 1; 469 len += strlen (item_n + 1 + len) + 1;
442 SockList_AddChar(&sl, (char)len); 470 SockList_AddChar (&sl, (char) len);
443 memcpy(sl.buf+sl.len, item_n, len); 471 memcpy (sl.buf + sl.len, item_n, len);
444 sl.len += len; 472 sl.len += len;
445 } 473 }
474
446 if (flags & UPD_ANIM) 475 if (flags & UPD_ANIM)
447 SockList_AddShort(&sl,op->animation_id); 476 SockList_AddShort (&sl, op->animation_id);
448 477
449 if (flags & UPD_ANIMSPEED) { 478 if (flags & UPD_ANIMSPEED)
479 {
450 int anim_speed=0; 480 int anim_speed = 0;
481
451 if (QUERY_FLAG(op,FLAG_ANIMATE)) { 482 if (QUERY_FLAG (op, FLAG_ANIMATE))
452 if (op->anim_speed) anim_speed=op->anim_speed; 483 {
453 else { 484 if (op->anim_speed)
454 if (FABS(op->speed)<0.001) anim_speed=255; 485 anim_speed = op->anim_speed;
455 else if (FABS(op->speed)>=1.0) anim_speed=1; 486 else
487 {
488 if (FABS (op->speed) < 0.001)
489 anim_speed = 255;
490 else if (FABS (op->speed) >= 1.0)
491 anim_speed = 1;
492 else
456 else anim_speed = (int) (1.0/FABS(op->speed)); 493 anim_speed = (int) (1.0 / FABS (op->speed));
494 }
495 if (anim_speed > 255)
496 anim_speed = 255;
497 }
498 SockList_AddChar (&sl, (char) anim_speed);
457 } 499 }
458 if (anim_speed>255) anim_speed=255;
459 }
460 SockList_AddChar(&sl, (char)anim_speed);
461 }
462 if (flags & UPD_NROF) 500 if (flags & UPD_NROF)
463 SockList_AddInt(&sl, op->nrof); 501 SockList_AddInt (&sl, op->nrof);
464 502
465 Send_With_Handling(&pl->contr->socket, &sl); 503 Send_With_Handling (&pl->contr->socket, &sl);
466 free(sl.buf); 504 free (sl.buf);
467} 505}
468 506
469/** 507/**
470 * Sends item's info to player. 508 * Sends item's info to player.
471 */ 509 */
510void
472void esrv_send_item(object *pl, object*op) 511esrv_send_item (object *pl, object *op)
473{ 512{
474 SockList sl; 513 SockList sl;
475 514
476 /* If this is not the player object, do some more checks */ 515 /* If this is not the player object, do some more checks */
477 if (op!=pl) { 516 if (op != pl)
517 {
478 /* We only send 'visibile' objects to the client */ 518 /* We only send 'visibile' objects to the client */
479 if (! LOOK_OBJ(op)) 519 if (!LOOK_OBJ (op))
480 return; 520 return;
481 /* if the item is on the ground, mark that the look needs to 521 /* if the item is on the ground, mark that the look needs to
482 * be updated. 522 * be updated.
483 */ 523 */
484 if (!op->env) { 524 if (!op->env)
525 {
485 pl->contr->socket.update_look=1; 526 pl->contr->socket.update_look = 1;
486 return; 527 return;
487 } 528 }
488 } 529 }
489 530
490 sl.buf= (unsigned char *) malloc(MAXSOCKBUF); 531 sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
491 532
492 sprintf((char*)sl.buf,"item%d ", pl->contr->socket.itemcmd); 533 sprintf ((char *) sl.buf, "item%d ", pl->contr->socket.itemcmd);
493 sl.len=strlen((char*)sl.buf); 534 sl.len = strlen ((char *) sl.buf);
494 535
495 if (op->head) op=op->head; 536 if (op->head)
537 op = op->head;
496 538
497 SockList_AddInt(&sl, op->env? op->env->count:0); 539 SockList_AddInt (&sl, op->env ? op->env->count : 0);
498 540
499 add_object_to_socklist(&pl->contr->socket, &sl, op); 541 add_object_to_socklist (&pl->contr->socket, &sl, op);
500 542
501 Send_With_Handling(&pl->contr->socket, &sl); 543 Send_With_Handling (&pl->contr->socket, &sl);
502 SET_FLAG(op, FLAG_CLIENT_SENT); 544 SET_FLAG (op, FLAG_CLIENT_SENT);
503 free(sl.buf); 545 free (sl.buf);
504} 546}
505 547
506/** 548/**
507 * Tells the client to delete an item. Uses the item 549 * Tells the client to delete an item. Uses the item
508 * command with a -1 location. 550 * command with a -1 location.
509 */ 551 */
510 552
553void
511void esrv_del_item(player *pl, int tag) 554esrv_del_item (player *pl, int tag)
512{ 555{
513 SockList sl; 556 SockList sl;
514 557
515 sl.buf= (unsigned char *) malloc(MAXSOCKBUF); 558 sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
516 559
517 strcpy((char*)sl.buf,"delitem "); 560 strcpy ((char *) sl.buf, "delitem ");
518 sl.len=strlen((char*)sl.buf); 561 sl.len = strlen ((char *) sl.buf);
519 SockList_AddInt(&sl, tag); 562 SockList_AddInt (&sl, tag);
520 563
521 Send_With_Handling(&pl->socket, &sl); 564 Send_With_Handling (&pl->socket, &sl);
522 free(sl.buf); 565 free (sl.buf);
523} 566}
524 567
525 568
526/******************************************************************************* 569/*******************************************************************************
527 * 570 *
… …
532/** 575/**
533 * Takes a player and object count (tag) and returns the actual object 576 * Takes a player and object count (tag) and returns the actual object
534 * pointer, or null if it can't be found. 577 * pointer, or null if it can't be found.
535 */ 578 */
536 579
580object *
537object *esrv_get_ob_from_count(object *pl, tag_t count) 581esrv_get_ob_from_count (object *pl, tag_t count)
538{ 582{
539 object *op, *tmp; 583 object *op, *tmp;
540 584
541 if (pl->count == count) 585 if (pl->count == count)
542 return pl; 586 return pl;
543 587
544 for(op = pl->inv; op; op = op->below) 588 for (op = pl->inv; op; op = op->below)
545 if (op->count == count) 589 if (op->count == count)
546 return op; 590 return op;
547 else if (op->type == CONTAINER && pl->container == op) 591 else if (op->type == CONTAINER && pl->container == op)
548 for(tmp = op->inv; tmp; tmp = tmp->below) 592 for (tmp = op->inv; tmp; tmp = tmp->below)
549 if (tmp->count == count) 593 if (tmp->count == count)
550 return tmp; 594 return tmp;
551 595
552 for(op = get_map_ob (pl->map, pl->x, pl->y); op; op = op->above) 596 for (op = get_map_ob (pl->map, pl->x, pl->y); op; op = op->above)
553 if (op->head != NULL && op->head->count == count) 597 if (op->head != NULL && op->head->count == count)
554 return op; 598 return op;
555 else if (op->count == count) 599 else if (op->count == count)
556 return op; 600 return op;
557 else if (op->type == CONTAINER && pl->container == op) 601 else if (op->type == CONTAINER && pl->container == op)
558 for(tmp = op->inv; tmp; tmp = tmp->below) 602 for (tmp = op->inv; tmp; tmp = tmp->below)
559 if (tmp->count == count)
560 return tmp;
561
562 if (pl->contr->transport) {
563 for(tmp = pl->contr->transport->inv; tmp; tmp = tmp->below)
564 if (tmp->count == count) 603 if (tmp->count == count)
565 return tmp; 604 return tmp;
566 } 605
567 return NULL; 606 return NULL;
568} 607}
569 608
570 609
571/** Client wants to examine some object. So lets do so. */ 610/** Client wants to examine some object. So lets do so. */
611void
572void ExamineCmd(char *buf, int len,player *pl) 612ExamineCmd (char *buf, int len, player *pl)
573{ 613{
574 long tag = atoi(buf); 614 tag_t tag = atoi (buf);
615
616 /* If the high bit is set, player examined a pseudo object. */
617 if (tag & 0x80000000)
618 return;
619
575 object *op = esrv_get_ob_from_count(pl->ob, tag); 620 object *op = esrv_get_ob_from_count (pl->ob, tag);
576 621
577 if (!op) { 622 if (!op)
623 {
578 LOG(llevDebug, "Player '%s' tried to examine the unknown object (%ld)\n", 624 LOG (llevDebug, "Player '%s' tried to examine the unknown object (%ld)\n", &pl->ob->name, tag);
579 pl->ob->name, tag); 625 return;
580 return;
581 } 626 }
627
582 examine (pl->ob, op); 628 examine (pl->ob, op);
583} 629}
584 630
585/** Client wants to apply some object. Lets do so. */ 631/** Client wants to apply some object. Lets do so. */
632void
586void ApplyCmd(char *buf, int len,player *pl) 633ApplyCmd (char *buf, int len, player *pl)
587{ 634{
588 uint32 tag = atoi(buf); 635 tag_t tag = atoi (buf);
589 object *op = esrv_get_ob_from_count(pl->ob, tag);
590 636
591 /* sort of a hack, but if the player saves and the player then manually 637 /* sort of a hack, but if the player saves and the player then manually
592 * applies a savebed (or otherwise tries to do stuff), we run into trouble. 638 * applies a savebed (or otherwise tries to do stuff), we run into trouble.
593 */ 639 */
594 if (QUERY_FLAG(pl->ob, FLAG_REMOVED)) return; 640 if (QUERY_FLAG (pl->ob, FLAG_REMOVED))
641 return;
595 642
596 /* If the high bit is set, player applied a pseudo object. */ 643 /* If the high bit is set, player applied a pseudo object. */
597 if (tag & 0x80000000) { 644 if (tag & 0x80000000)
645 {
598 pl->socket.look_position = tag & 0x7fffffff; 646 pl->socket.look_position = tag & 0x7fffffff;
599 pl->socket.update_look = 1; 647 pl->socket.update_look = 1;
600 return; 648 return;
601 } 649 }
602 650
651 object *op = esrv_get_ob_from_count (pl->ob, tag);
652
603 if (!op) { 653 if (!op)
654 {
604 LOG(llevDebug, "Player '%s' tried to apply the unknown object (%d)\n", 655 LOG (llevDebug, "Player '%s' tried to apply the unknown object (%d)\n", &pl->ob->name, tag);
605 pl->ob->name, tag); 656 return;
606 return;
607 } 657 }
658
608 player_apply (pl->ob, op, 0, 0); 659 player_apply (pl->ob, op, 0, 0);
609} 660}
610 661
611/** Client wants to apply some object. Lets do so. */ 662/** Client wants to apply some object. Lets do so. */
663void
612void LockItem(uint8 *data, int len,player *pl) 664LockItem (uint8 * data, int len, player *pl)
613{ 665{
614 int flag, tag; 666 int flag, tag;
615 object *op; 667 object *op;
616 668
617 flag = data[0]; 669 flag = data[0];
618 tag = GetInt_String(data+1); 670 tag = GetInt_String (data + 1);
619 op = esrv_get_ob_from_count(pl->ob, tag); 671 op = esrv_get_ob_from_count (pl->ob, tag);
620 672
621 if (!op) { 673 if (!op)
674 {
622 new_draw_info(NDI_UNIQUE, 0, pl->ob,"Could not find object to lock/unlock"); 675 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Could not find object to lock/unlock");
623 return; 676 return;
624 } 677 }
625 if (!flag) 678 if (!flag)
626 CLEAR_FLAG(op,FLAG_INV_LOCKED); 679 CLEAR_FLAG (op, FLAG_INV_LOCKED);
627 else 680 else
628 SET_FLAG(op,FLAG_INV_LOCKED); 681 SET_FLAG (op, FLAG_INV_LOCKED);
629 esrv_update_item(UPD_FLAGS, pl->ob, op); 682 esrv_update_item (UPD_FLAGS, pl->ob, op);
630} 683}
631 684
632/** Client wants to apply some object. Lets do so. */ 685/** Client wants to apply some object. Lets do so. */
686void
633void MarkItem(uint8 *data, int len,player *pl) 687MarkItem (uint8 * data, int len, player *pl)
634{ 688{
635 int tag; 689 int tag;
636 object *op; 690 object *op;
637 691
638 tag = GetInt_String(data); 692 tag = GetInt_String (data);
639 op = esrv_get_ob_from_count(pl->ob, tag); 693 op = esrv_get_ob_from_count (pl->ob, tag);
694
640 if (!op) { 695 if (!op)
696 {
641 new_draw_info(NDI_UNIQUE, 0, pl->ob,"Could not find object to mark"); 697 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Could not find object to mark");
642 return; 698 return;
643 } 699 }
700
644 pl->mark = op; 701 pl->mark = op;
645 pl->mark_count = op->count;
646 new_draw_info_format(NDI_UNIQUE, 0, pl->ob, "Marked item %s", query_name(op)); 702 new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "Marked item %s", query_name (op));
647} 703}
648 704
649 705
650/** 706/**
651 * look_at prints items on the specified square. 707 * look_at prints items on the specified square.
652 * 708 *
653 * [ removed EARTHWALL check and added check for containers inventory. 709 * [ removed EARTHWALL check and added check for containers inventory.
654 * Tero.Haatanen@lut.fi ] 710 * Tero.Haatanen@lut.fi ]
655 */ 711 */
712void
656void look_at(object *op,int dx,int dy) { 713look_at (object *op, int dx, int dy)
714{
657 object *tmp; 715 object *tmp;
658 int flag=0; 716 int flag = 0;
659 sint16 x,y; 717 sint16 x, y;
660 mapstruct *m; 718 maptile *m;
661 719
662 x = op->x + dx; 720 x = op->x + dx;
663 y = op->y + dy; 721 y = op->y + dy;
664 722
665 if (out_of_map(op->map, x, y)) return; 723 if (out_of_map (op->map, x, y))
724 return;
666 725
667 m = get_map_from_coord(op->map, &x, &y); 726 m = get_map_from_coord (op->map, &x, &y);
668 if (!m) return; 727 if (!m)
728 return;
669 729
670 for(tmp=get_map_ob(m, x ,y);tmp!=NULL&&tmp->above!=NULL; 730 for (tmp = get_map_ob (m, x, y); tmp != NULL && tmp->above != NULL; tmp = tmp->above);
671 tmp=tmp->above);
672 731
673 for ( ; tmp != NULL; tmp=tmp->below ) { 732 for (; tmp != NULL; tmp = tmp->below)
733 {
674 if (tmp->invisible && !QUERY_FLAG(op, FLAG_WIZ)) continue; 734 if (tmp->invisible && !QUERY_FLAG (op, FLAG_WIZ))
735 continue;
675 736
676 if(!flag) { 737 if (!flag)
677 if(dx||dy) 738 {
739 if (dx || dy)
678 new_draw_info(NDI_UNIQUE, 0,op,"There you see:"); 740 new_draw_info (NDI_UNIQUE, 0, op, "There you see:");
679 else { 741 else
680 clear_win_info(op); 742 {
743 clear_win_info (op);
681 new_draw_info(NDI_UNIQUE, 0,op,"You see:"); 744 new_draw_info (NDI_UNIQUE, 0, op, "You see:");
682 } 745 }
683 flag=1; 746 flag = 1;
684 } 747 }
685 748
686 if (QUERY_FLAG(op, FLAG_WIZ)) 749 if (QUERY_FLAG (op, FLAG_WIZ))
687 new_draw_info_format(NDI_UNIQUE,0, op, "- %s (%d).",query_name(tmp),tmp->count); 750 new_draw_info_format (NDI_UNIQUE, 0, op, "- %s (%d).", query_name (tmp), tmp->count);
688 else 751 else
689 new_draw_info_format(NDI_UNIQUE,0, op, "- %s.",query_name(tmp)); 752 new_draw_info_format (NDI_UNIQUE, 0, op, "- %s.", query_name (tmp));
690 753
691 if (((tmp->inv!=NULL || (tmp->head && tmp->head->inv)) && 754 if (((tmp->inv != NULL || (tmp->head && tmp->head->inv)) &&
692 (tmp->type != CONTAINER && tmp->type!=FLESH)) || QUERY_FLAG(op, FLAG_WIZ)) 755 (tmp->type != CONTAINER && tmp->type != FLESH)) || QUERY_FLAG (op, FLAG_WIZ))
693 inventory(op,tmp->head==NULL?tmp:tmp->head); 756 inventory (op, tmp->head == NULL ? tmp : tmp->head);
694 757
695 if(QUERY_FLAG(tmp, FLAG_IS_FLOOR)&&!QUERY_FLAG(op, FLAG_WIZ)) /* don't continue under the floor */ 758 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) && !QUERY_FLAG (op, FLAG_WIZ)) /* don't continue under the floor */
696 break; 759 break;
697 } 760 }
698 761
699 if(!flag) { 762 if (!flag)
700 if(dx||dy) 763 {
764 if (dx || dy)
701 new_draw_info(NDI_UNIQUE, 0,op,"You see nothing there."); 765 new_draw_info (NDI_UNIQUE, 0, op, "You see nothing there.");
702 else 766 else
703 new_draw_info(NDI_UNIQUE, 0,op,"You see nothing."); 767 new_draw_info (NDI_UNIQUE, 0, op, "You see nothing.");
704 } 768 }
705} 769}
706 770
707 771
708 772
709/** Client wants to look at some object. Lets do so. */ 773/** Client wants to look at some object. Lets do so. */
774void
710void LookAt(char *buf, int len,player *pl) 775LookAt (char *buf, int len, player *pl)
711{ 776{
712 int dx, dy; 777 int dx, dy;
713 char *cp; 778 char *cp;
714 779
715 dx=atoi(buf); 780 dx = atoi (buf);
716 if (!(cp=strchr(buf,' '))) { 781 if (!(cp = strchr (buf, ' ')))
717 return;
718 } 782 {
783 return;
784 }
719 dy=atoi(cp); 785 dy = atoi (cp);
720 786
721 if (FABS(dx) > pl->socket.mapx / 2 || FABS(dy) > pl->socket.mapy / 2) 787 if (FABS (dx) > pl->socket.mapx / 2 || FABS (dy) > pl->socket.mapy / 2)
788 return;
789
790 if (pl->blocked_los[dx + pl->socket.mapx / 2][dy + pl->socket.mapy / 2])
791 return;
792
793 look_at (pl->ob, dx, dy);
794}
795
796/** Move an object to a new location */
797void
798esrv_move_object (object *pl, tag_t to, tag_t tag, long nrof)
799{
800 object *op, *env;
801
802 op = esrv_get_ob_from_count (pl, tag);
803 if (!op)
804 {
805 LOG (llevDebug, "Player '%s' tried to move an unknown object (%ld)\n", &pl->name, tag);
806 return;
807 }
808
809 if (!to)
810 { /* drop it to the ground */
811
812/* LOG(llevDebug, "Drop it on the ground.\n");*/
813
814 if (op->map && !op->env)
815 {
816
817/* LOG(llevDebug,"Dropping object to ground that is already on ground\n");*/
722 return; 818 return;
723 819 }
724 if(pl->blocked_los[dx + pl->socket.mapx / 2][dy + pl->socket.mapy / 2])
725 return;
726
727 look_at(pl->ob, dx, dy);
728}
729
730/** Move an object to a new location */
731void esrv_move_object (object *pl, tag_t to, tag_t tag, long nrof)
732{
733 object *op, *env;
734
735 op = esrv_get_ob_from_count(pl, tag);
736 if (!op) {
737 LOG(llevDebug, "Player '%s' tried to move an unknown object (%ld)\n",
738 pl->name, tag);
739 return;
740 }
741
742 /* If on a transport, you don't drop to the ground - you drop to the
743 * transport.
744 */
745 if (!to && !pl->contr->transport) { /* drop it to the ground */
746/* LOG(llevDebug, "Drop it on the ground.\n");*/
747
748 if (op->map && !op->env) {
749/* LOG(llevDebug,"Dropping object to ground that is already on ground\n");*/
750 return;
751 }
752 /* If it is an active container, then we should drop all objects 820 /* If it is an active container, then we should drop all objects
753 * in the container and not the container itself. 821 * in the container and not the container itself.
754 */ 822 */
755 if (op->inv && QUERY_FLAG(op, FLAG_APPLIED)) { 823 if (op->inv && QUERY_FLAG (op, FLAG_APPLIED))
824 {
756 object *current, *next; 825 object *current, *next;
826
757 for (current=op->inv; current!=NULL; current=next) { 827 for (current = op->inv; current != NULL; current = next)
758 next=current->below; 828 {
829 next = current->below;
759 drop_object(pl, current, 0); 830 drop_object (pl, current, 0);
760 } 831 }
761 esrv_update_item(UPD_WEIGHT, pl, op); 832 esrv_update_item (UPD_WEIGHT, pl, op);
762 } 833 }
763 else { 834 else
835 {
764 drop_object (pl, op, nrof); 836 drop_object (pl, op, nrof);
765 } 837 }
766 return; 838 return;
767 } else if (to == pl->count) { /* pick it up to the inventory */ 839 }
840 else if (to == pl->count)
841 { /* pick it up to the inventory */
768 /* return if player has already picked it up */ 842 /* return if player has already picked it up */
769 if (op->env == pl) return; 843 if (op->env == pl)
844 return;
770 845
771 pl->contr->count = nrof; 846 pl->contr->count = nrof;
772 pick_up(pl, op); 847 pick_up (pl, op);
773 return ; 848 return;
774 } 849 }
775 /* If not dropped or picked up, we are putting it into a sack */
776 if (pl->contr->transport) {
777 if (can_pick(pl, op) && transport_can_hold(pl->contr->transport, op, nrof)) {
778 put_object_in_sack (pl, pl->contr->transport, op, nrof);
779 }
780 } else {
781 env = esrv_get_ob_from_count(pl, to); 850 env = esrv_get_ob_from_count (pl, to);
782 if (!env) { 851 if (!env)
783 LOG(llevDebug, 852 {
784 "Player '%s' tried to move object to the unknown location (%d)\n", 853 LOG (llevDebug, "Player '%s' tried to move object to the unknown location (%d)\n", &pl->name, to);
785 pl->name, to);
786 return; 854 return;
787 } 855 }
788 /* put_object_in_sack presumes that necessary sanity checking 856 /* put_object_in_sack presumes that necessary sanity checking
789 * has already been done (eg, it can be picked up and fits in 857 * has already been done (eg, it can be picked up and fits in
790 * in a sack, so check for those things. We should also check 858 * in a sack, so check for those things. We should also check
791 * an make sure env is in fact a container for that matter. 859 * an make sure env is in fact a container for that matter.
792 */ 860 */
793 if (env->type == CONTAINER
794 && can_pick(pl, op) && sack_can_hold(pl, env, op, nrof)) { 861 if (env->type == CONTAINER && can_pick (pl, op) && sack_can_hold (pl, env, op, nrof))
862 {
795 put_object_in_sack (pl, env, op, nrof); 863 put_object_in_sack (pl, env, op, nrof);
796 }
797 } 864 }
798} 865}
799
800

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines