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.13 by root, Thu Dec 14 00:13:26 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 sl << uint32 (head->count)
157 SockList_AddInt(sl, flags); 157 << uint32 (flags)
158 SockList_AddInt(sl, QUERY_FLAG(head, FLAG_NO_PICK) ? -1 : WEIGHT(head)); 158 << uint32 (QUERY_FLAG (head, FLAG_NO_PICK) ? -1 : WEIGHT (head))
159 SockList_AddInt(sl, head->face->number); 159 << uint32 (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 }
175
172 strncpy(item_n+len+1, item_p, 127); 176 strncpy (item_n + len + 1, item_p, 127);
173 item_n[254]=0; 177 item_n[254] = 0;
174 len += strlen(item_n+1+len) + 1; 178 len += strlen (item_n + 1 + len) + 1;
175 SockList_AddChar(sl, (char ) len);
176 memcpy(sl->buf+sl->len, item_n, len);
177 sl->len += len;
178 179
179 SockList_AddShort(sl,head->animation_id); 180 sl << data8 (item_n, len)
181 << uint16 (head->animation_id);
182
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 {
190 SockList_AddChar(sl, (char) anim_speed); 186 if (head->anim_speed)
191 SockList_AddInt(sl, head->nrof); 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 }
192 197
198 if (anim_speed > 255)
199 anim_speed = 255;
200 }
201
202 sl << uint8 (anim_speed)
203 << uint32 (head->nrof);
204
193 if (ns->itemcmd == 2) 205 if (ns.itemcmd == 2)
194 SockList_AddShort(sl, head->client_type); 206 sl << uint16 (head->client_type);
195 207
196 SET_FLAG(head, FLAG_CLIENT_SENT); 208 SET_FLAG (head, FLAG_CLIENT_SENT);
197} 209}
198 210
199 211
200/** 212/**
201 * Send the look window. Don't need to do animations here 213 * 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 214 * This sends all the faces to the client, not just updates. This is
203 * because object ordering would otherwise be inconsistent 215 * because object ordering would otherwise be inconsistent
204 */ 216 */
205 217
218void
206void esrv_draw_look(object *pl) 219esrv_draw_look (object *pl)
207{ 220{
208 object *tmp, *last; 221 object *tmp, *last;
209 int got_one=0,start_look=0, end_look=0; 222 int got_one = 0, start_look = 0, end_look = 0;
210 SockList sl;
211 char buf[MAX_BUF]; 223 char buf[MAX_BUF];
212 224
213 if (!pl->contr->socket.update_look) { 225 if (!pl->contr->socket.update_look)
226 {
214 LOG(llevDebug,"esrv_draw_look called when update_look was not set\n"); 227 LOG (llevDebug, "esrv_draw_look called when update_look was not set\n");
215 return; 228 return;
216 } else { 229 }
230 else
217 pl->contr->socket.update_look=0; 231 pl->contr->socket.update_look = 0;
218 }
219 232
220 if(QUERY_FLAG(pl, FLAG_REMOVED) || pl->map == NULL || 233 if (QUERY_FLAG (pl, FLAG_REMOVED)
221 pl->map->in_memory != MAP_IN_MEMORY || out_of_map(pl->map,pl->x,pl->y)) 234 || !pl->map
235 || pl->map->in_memory != MAP_IN_MEMORY
236 || out_of_map (pl->map, pl->x, pl->y))
222 return; 237 return;
223 238
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) ; 239 for (tmp = get_map_ob (pl->map, pl->x, pl->y); tmp && tmp->above; tmp = tmp->above);
228 240
229 sl.buf= (unsigned char *) malloc(MAXSOCKBUF); 241 SockList sl (MAXSOCKBUF);
230 242
231 Write_String_To_Socket(&pl->contr->socket, "delinv 0", strlen("delinv 0")); 243 Write_String_To_Socket (&pl->contr->socket, "delinv 0", sizeof ("delinv 0") - 1);
244
232 sprintf((char*)sl.buf,"item%d ", pl->contr->socket.itemcmd); 245 sl.printf ("item%d ", pl->contr->socket.itemcmd);
233 sl.len=strlen((char*)sl.buf);
234 246
235 SockList_AddInt(&sl, 0); 247 sl << uint32 (0);
236 248
237 if (!(pl->contr->socket.faces_sent[empty_face->number]&NS_FACESENT_FACE)) 249 if (!(pl->contr->socket.faces_sent[empty_face->number] & NS_FACESENT_FACE))
238 esrv_send_face(&pl->contr->socket, empty_face->number,0); 250 esrv_send_face (&pl->contr->socket, empty_face->number, 0);
239 251
240 if (pl->contr->socket.look_position) { 252 if (pl->contr->socket.look_position)
253 {
241 SockList_AddInt(&sl, 0x80000000 | (pl->contr->socket.look_position- NUM_LOOK_OBJECTS)); 254 sl << uint32 (0x80000000 | (pl->contr->socket.look_position - NUM_LOOK_OBJECTS))
242 SockList_AddInt(&sl, 0); 255 << uint32 (0)
243 SockList_AddInt(&sl, (uint32) -1); 256 << sint32 (-1)
244 SockList_AddInt(&sl, empty_face->number); 257 << uint32 (empty_face->number);
258
245 sprintf(buf,"Click here to see %d previous items", NUM_LOOK_OBJECTS); 259 sl.printf ("Click here to see %d previous items", NUM_LOOK_OBJECTS);
246 add_stringlen_to_sockbuf(buf, &sl); 260
247 SockList_AddShort(&sl,0); 261 sl << uint16 (0)
248 SockList_AddChar(&sl, 0); 262 << uint8 (0)
249 SockList_AddInt(&sl, 0); 263 << uint32 (0);
264
250 if (pl->contr->socket.itemcmd == 2) 265 if (pl->contr->socket.itemcmd == 2)
251 SockList_AddShort(&sl, 0); 266 sl << uint16 (0);
252 } 267 }
253 268
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) { 269 for (last = NULL; tmp != last; tmp = tmp->below)
270 {
260 object *head; 271 object *head;
261 272
262 if (QUERY_FLAG(tmp, FLAG_IS_FLOOR) && !last) { 273 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) && !last)
274 {
263 last = tmp->below; /* assumes double floor mode */ 275 last = tmp->below; /* assumes double floor mode */
264 if (last && QUERY_FLAG(last, FLAG_IS_FLOOR)) 276 if (last && QUERY_FLAG (last, FLAG_IS_FLOOR))
265 last = last->below; 277 last = last->below;
266 } 278 }
279
267 if (LOOK_OBJ(tmp)) { 280 if (LOOK_OBJ (tmp))
281 {
268 if (++start_look < pl->contr->socket.look_position) continue; 282 if (++start_look < pl->contr->socket.look_position)
283 continue;
284
269 end_look++; 285 end_look++;
286
270 if (end_look > NUM_LOOK_OBJECTS) { 287 if (end_look > NUM_LOOK_OBJECTS)
288 {
271 /* What we basically do is make a 'fake' object - when the user applies it, 289 /* 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. 290 * we notice the special tag the object has, and act accordingly.
273 */ 291 */
274 SockList_AddInt(&sl, 0x80000000 | (pl->contr->socket.look_position+ NUM_LOOK_OBJECTS)); 292 SockList_AddInt (&sl, 0x80000000 | (pl->contr->socket.look_position + NUM_LOOK_OBJECTS));
275 SockList_AddInt(&sl, 0); 293 SockList_AddInt (&sl, 0);
276 SockList_AddInt(&sl, (uint32) -1); 294 SockList_AddInt (&sl, (uint32) - 1);
277 SockList_AddInt(&sl, empty_face->number); 295 SockList_AddInt (&sl, empty_face->number);
278 sprintf(buf,"Click here to see next group of items"); 296 sprintf (buf, "Click here to see next group of items");
279 add_stringlen_to_sockbuf(buf, &sl); 297 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); 298 SockList_AddShort (&sl, 0);
285 break; 299 SockList_AddChar (&sl, 0);
286 } 300 SockList_AddInt (&sl, 0);
287 if (tmp->head) head = tmp->head; 301 if (pl->contr->socket.itemcmd == 2)
288 else head = tmp; 302 SockList_AddShort (&sl, 0);
303 break;
304 }
305 if (tmp->head)
306 head = tmp->head;
307 else
308 head = tmp;
289 309
290 add_object_to_socklist(&pl->contr->socket, &sl, head); 310 add_object_to_socklist (pl->contr->socket, sl, head);
291 got_one++; 311 got_one++;
292 312
293 if (sl.len >= (MAXSOCKBUF-MAXITEMLEN)) { 313 if (sl.len >= (MAXSOCKBUF - MAXITEMLEN))
314 {
294 Send_With_Handling(&pl->contr->socket, &sl); 315 Send_With_Handling (&pl->contr->socket, &sl);
295 sprintf((char*)sl.buf,"item%d ", pl->contr->socket.itemcmd); 316 sprintf ((char *) sl.buf, "item%d ", pl->contr->socket.itemcmd);
296 sl.len=strlen((char*)sl.buf); 317 sl.len = strlen ((char *) sl.buf);
297 SockList_AddInt(&sl, 0); 318 SockList_AddInt (&sl, 0);
298 got_one=0; 319 got_one = 0;
320 }
321 } /* If LOOK_OBJ() */
299 } 322 }
300 } /* If LOOK_OBJ() */ 323
301 }
302 if (got_one) 324 if (got_one)
303 Send_With_Handling(&pl->contr->socket, &sl); 325 Send_With_Handling (&pl->contr->socket, &sl);
304 326
305 free(sl.buf); 327 sl.free ();
306} 328}
307 329
308/** 330/**
309 * Sends whole inventory. 331 * Sends whole inventory.
310 */ 332 */
333void
311void esrv_send_inventory(object *pl, object *op) 334esrv_send_inventory (object *pl, object *op)
312{ 335{
313 object *tmp; 336 object *tmp;
314 int got_one=0; 337 int got_one = 0;
315 SockList sl; 338 SockList sl;
316 339
317 sl.buf= (unsigned char *) malloc(MAXSOCKBUF); 340 sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
318 341
319 sprintf((char*)sl.buf,"delinv %d", op->count); 342 sprintf ((char *) sl.buf, "delinv %d", op->count);
320 sl.len=strlen((char*)sl.buf); 343 sl.len = strlen ((char *) sl.buf);
344 Send_With_Handling (&pl->contr->socket, &sl);
345
346 sprintf ((char *) sl.buf, "item%d ", pl->contr->socket.itemcmd);
347 sl.len = strlen ((char *) sl.buf);
348
349 SockList_AddInt (&sl, op->count);
350
351 for (tmp = op->inv; tmp; tmp = tmp->below)
352 {
353 object *head;
354
355 if (tmp->head)
356 head = tmp->head;
357 else
358 head = tmp;
359
360 if (LOOK_OBJ (head))
361 {
362 add_object_to_socklist (pl->contr->socket, sl, head);
363
364 got_one++;
365
366 /* IT is possible for players to accumulate a huge amount of
367 * items (especially with some of the bags out there) to
368 * overflow the buffer. IF so, send multiple item commands.
369 */
370 if (sl.len >= (MAXSOCKBUF - MAXITEMLEN))
371 {
372 Send_With_Handling (&pl->contr->socket, &sl);
373 sprintf ((char *) sl.buf, "item%d ", pl->contr->socket.itemcmd);
374 sl.len = strlen ((char *) sl.buf);
375 SockList_AddInt (&sl, op->count);
376 got_one = 0;
377 }
378 } /* If LOOK_OBJ() */
379 }
380 if (got_one)
321 Send_With_Handling(&pl->contr->socket, &sl); 381 Send_With_Handling (&pl->contr->socket, &sl);
322 382 sl.free ();
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);
355} 383}
356 384
357/** 385/**
358 * Updates object *op for player *pl. 386 * Updates object *op for player *pl.
359 * 387 *
360 * flags is a list of values to update 388 * flags is a list of values to update
361 * to the client (as defined in newclient.h - might as well use the 389 * to the client (as defined in newclient.h - might as well use the
362 * same value both places. 390 * same value both places.
363 */ 391 */
364 392
393void
365void esrv_update_item(int flags, object *pl, object *op) 394esrv_update_item (int flags, object *pl, object *op)
366{ 395{
367 SockList sl; 396 SockList sl;
368 397
369 /* If we have a request to send the player item, skip a few checks. */ 398 /* If we have a request to send the player item, skip a few checks. */
370 if (op!=pl) { 399 if (op != pl)
400 {
371 if (! LOOK_OBJ(op)) 401 if (!LOOK_OBJ (op))
372 return; 402 return;
373 /* we remove the check for op->env, because in theory, the object 403 /* we remove the check for op->env, because in theory, the object
374 * is hopefully in the same place, so the client should preserve 404 * is hopefully in the same place, so the client should preserve
375 * order. 405 * order.
376 */ 406 */
377 } 407 }
408
378 if (!QUERY_FLAG(op, FLAG_CLIENT_SENT)) { 409 if (!QUERY_FLAG (op, FLAG_CLIENT_SENT))
410 {
379 /* FLAG_CLIENT_SENT is debug only. We are using it to see where 411 /* 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 412 * this is happening - we can set a breakpoint here in the debugger
381 * and track back the call. 413 * and track back the call.
382 */ 414 */
383 LOG(llevDebug,"We have not sent item %s (%d)\n", op->name, op->count); 415 LOG (llevDebug, "We have not sent item %s (%d)\n", &op->name, op->count);
384 } 416 }
417
385 sl.buf= (unsigned char *) malloc(MAXSOCKBUF); 418 sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
386 419
387 strcpy((char*)sl.buf,"upditem "); 420 strcpy ((char *) sl.buf, "upditem ");
388 sl.len=strlen((char*)sl.buf); 421 sl.len = strlen ((char *) sl.buf);
389 422
390 SockList_AddChar(&sl, (char) flags); 423 SockList_AddChar (&sl, (char) flags);
391 424
392 if (op->head) op=op->head; 425 if (op->head)
426 op = op->head;
393 427
394 SockList_AddInt(&sl, op->count); 428 SockList_AddInt (&sl, op->count);
395 429
396 if (flags & UPD_LOCATION) 430 if (flags & UPD_LOCATION)
397 SockList_AddInt(&sl, op->env? op->env->count:0); 431 SockList_AddInt (&sl, op->env ? op->env->count : 0);
398 432
399 if (flags & UPD_FLAGS) 433 if (flags & UPD_FLAGS)
400 SockList_AddInt(&sl, query_flags(op)); 434 SockList_AddInt (&sl, query_flags (op));
401 435
402 if (flags & UPD_WEIGHT) { 436 if (flags & UPD_WEIGHT)
437 {
403 sint32 weight = WEIGHT(op); 438 sint32 weight = WEIGHT (op);
404 439
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); 440 SockList_AddInt (&sl, QUERY_FLAG (op, FLAG_NO_PICK) ? -1 : weight);
411 if (pl == op) { 441 if (pl == op)
442 {
412 op->contr->last_weight = weight; 443 op->contr->last_weight = weight;
413 } 444 }
414 } 445 }
415 446
416 if (flags & UPD_FACE) { 447 if (flags & UPD_FACE)
448 {
417 if (!(pl->contr->socket.faces_sent[op->face->number] & NS_FACESENT_FACE)) 449 if (!(pl->contr->socket.faces_sent[op->face->number] & NS_FACESENT_FACE))
418 esrv_send_face(&pl->contr->socket, op->face->number,0); 450 esrv_send_face (&pl->contr->socket, op->face->number, 0);
419 SockList_AddInt(&sl, op->face->number); 451 SockList_AddInt (&sl, op->face->number);
420 } 452 }
453
421 if (flags & UPD_NAME) { 454 if (flags & UPD_NAME)
422 int len; 455 {
456 int len;
423 const char *item_p; 457 const char *item_p;
424 char item_n[MAX_BUF]; 458 char item_n[MAX_BUF];
425 459
426 if (!op->custom_name) { 460 if (!op->custom_name)
461 {
427 strncpy(item_n,query_base_name(op, 0),127); 462 strncpy (item_n, query_base_name (op, 0), 127);
428 item_n[127]=0; 463 item_n[127] = 0;
429 len=strlen(item_n); 464 len = strlen (item_n);
430 item_p=query_base_name(op, 1); 465 item_p = query_base_name (op, 1);
431 } 466 }
432 else { 467 else
468 {
433 strncpy(item_n,op->custom_name,127); 469 strncpy (item_n, op->custom_name, 127);
434 item_n[127]=0; 470 item_n[127] = 0;
435 len=strlen(item_n); 471 len = strlen (item_n);
436 item_p=op->custom_name; 472 item_p = op->custom_name;
437 } 473 }
438 474
439 strncpy(item_n+len+1, item_p, 127); 475 strncpy (item_n + len + 1, item_p, 127);
440 item_n[254]=0; 476 item_n[254] = 0;
441 len += strlen(item_n+1+len) + 1; 477 len += strlen (item_n + 1 + len) + 1;
442 SockList_AddChar(&sl, (char)len); 478 SockList_AddChar (&sl, (char) len);
443 memcpy(sl.buf+sl.len, item_n, len); 479 memcpy (sl.buf + sl.len, item_n, len);
444 sl.len += len; 480 sl.len += len;
445 } 481 }
482
446 if (flags & UPD_ANIM) 483 if (flags & UPD_ANIM)
447 SockList_AddShort(&sl,op->animation_id); 484 SockList_AddShort (&sl, op->animation_id);
448 485
449 if (flags & UPD_ANIMSPEED) { 486 if (flags & UPD_ANIMSPEED)
487 {
450 int anim_speed=0; 488 int anim_speed = 0;
489
451 if (QUERY_FLAG(op,FLAG_ANIMATE)) { 490 if (QUERY_FLAG (op, FLAG_ANIMATE))
452 if (op->anim_speed) anim_speed=op->anim_speed; 491 {
453 else { 492 if (op->anim_speed)
454 if (FABS(op->speed)<0.001) anim_speed=255; 493 anim_speed = op->anim_speed;
455 else if (FABS(op->speed)>=1.0) anim_speed=1; 494 else
495 {
496 if (FABS (op->speed) < 0.001)
497 anim_speed = 255;
498 else if (FABS (op->speed) >= 1.0)
499 anim_speed = 1;
500 else
456 else anim_speed = (int) (1.0/FABS(op->speed)); 501 anim_speed = (int) (1.0 / FABS (op->speed));
502 }
503 if (anim_speed > 255)
504 anim_speed = 255;
505 }
506 SockList_AddChar (&sl, (char) anim_speed);
457 } 507 }
458 if (anim_speed>255) anim_speed=255;
459 }
460 SockList_AddChar(&sl, (char)anim_speed);
461 }
462 if (flags & UPD_NROF) 508 if (flags & UPD_NROF)
463 SockList_AddInt(&sl, op->nrof); 509 SockList_AddInt (&sl, op->nrof);
464 510
465 Send_With_Handling(&pl->contr->socket, &sl); 511 Send_With_Handling (&pl->contr->socket, &sl);
466 free(sl.buf); 512 sl.free ();
467} 513}
468 514
469/** 515/**
470 * Sends item's info to player. 516 * Sends item's info to player.
471 */ 517 */
518void
472void esrv_send_item(object *pl, object*op) 519esrv_send_item (object *pl, object *op)
473{ 520{
474 SockList sl; 521 SockList sl;
475 522
476 /* If this is not the player object, do some more checks */ 523 /* If this is not the player object, do some more checks */
477 if (op!=pl) { 524 if (op != pl)
525 {
478 /* We only send 'visibile' objects to the client */ 526 /* We only send 'visibile' objects to the client */
479 if (! LOOK_OBJ(op)) 527 if (!LOOK_OBJ (op))
480 return; 528 return;
481 /* if the item is on the ground, mark that the look needs to 529 /* if the item is on the ground, mark that the look needs to
482 * be updated. 530 * be updated.
483 */ 531 */
484 if (!op->env) { 532 if (!op->env)
533 {
485 pl->contr->socket.update_look=1; 534 pl->contr->socket.update_look = 1;
486 return; 535 return;
487 } 536 }
488 } 537 }
489 538
490 sl.buf= (unsigned char *) malloc(MAXSOCKBUF); 539 sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
491 540
492 sprintf((char*)sl.buf,"item%d ", pl->contr->socket.itemcmd); 541 sprintf ((char *) sl.buf, "item%d ", pl->contr->socket.itemcmd);
493 sl.len=strlen((char*)sl.buf); 542 sl.len = strlen ((char *) sl.buf);
494 543
495 if (op->head) op=op->head; 544 if (op->head)
545 op = op->head;
496 546
497 SockList_AddInt(&sl, op->env? op->env->count:0); 547 SockList_AddInt (&sl, op->env ? op->env->count : 0);
498 548
499 add_object_to_socklist(&pl->contr->socket, &sl, op); 549 add_object_to_socklist (pl->contr->socket, sl, op);
500 550
501 Send_With_Handling(&pl->contr->socket, &sl); 551 Send_With_Handling (&pl->contr->socket, &sl);
502 SET_FLAG(op, FLAG_CLIENT_SENT); 552 SET_FLAG (op, FLAG_CLIENT_SENT);
503 free(sl.buf); 553
554 sl.free ();
504} 555}
505 556
506/** 557/**
507 * Tells the client to delete an item. Uses the item 558 * Tells the client to delete an item. Uses the item
508 * command with a -1 location. 559 * command with a -1 location.
509 */ 560 */
510 561
562void
511void esrv_del_item(player *pl, int tag) 563esrv_del_item (player *pl, int tag)
512{ 564{
513 SockList sl; 565 SockList sl;
514 566
515 sl.buf= (unsigned char *) malloc(MAXSOCKBUF); 567 sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
516 568
517 strcpy((char*)sl.buf,"delitem "); 569 strcpy ((char *) sl.buf, "delitem ");
518 sl.len=strlen((char*)sl.buf); 570 sl.len = strlen ((char *) sl.buf);
519 SockList_AddInt(&sl, tag); 571 SockList_AddInt (&sl, tag);
520 572
521 Send_With_Handling(&pl->socket, &sl); 573 Send_With_Handling (&pl->socket, &sl);
522 free(sl.buf); 574 sl.free ();
523} 575}
524 576
525 577
526/******************************************************************************* 578/*******************************************************************************
527 * 579 *
… …
532/** 584/**
533 * Takes a player and object count (tag) and returns the actual object 585 * Takes a player and object count (tag) and returns the actual object
534 * pointer, or null if it can't be found. 586 * pointer, or null if it can't be found.
535 */ 587 */
536 588
589object *
537object *esrv_get_ob_from_count(object *pl, tag_t count) 590esrv_get_ob_from_count (object *pl, tag_t count)
538{ 591{
539 object *op, *tmp; 592 object *op, *tmp;
540 593
541 if (pl->count == count) 594 if (pl->count == count)
542 return pl; 595 return pl;
543 596
544 for(op = pl->inv; op; op = op->below) 597 for (op = pl->inv; op; op = op->below)
545 if (op->count == count) 598 if (op->count == count)
546 return op; 599 return op;
547 else if (op->type == CONTAINER && pl->container == op) 600 else if (op->type == CONTAINER && pl->container == op)
548 for(tmp = op->inv; tmp; tmp = tmp->below) 601 for (tmp = op->inv; tmp; tmp = tmp->below)
549 if (tmp->count == count) 602 if (tmp->count == count)
550 return tmp; 603 return tmp;
551 604
552 for(op = get_map_ob (pl->map, pl->x, pl->y); op; op = op->above) 605 for (op = get_map_ob (pl->map, pl->x, pl->y); op; op = op->above)
553 if (op->head != NULL && op->head->count == count) 606 if (op->head != NULL && op->head->count == count)
554 return op; 607 return op;
555 else if (op->count == count) 608 else if (op->count == count)
556 return op; 609 return op;
557 else if (op->type == CONTAINER && pl->container == op) 610 else if (op->type == CONTAINER && pl->container == op)
558 for(tmp = op->inv; tmp; tmp = tmp->below) 611 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) 612 if (tmp->count == count)
565 return tmp; 613 return tmp;
566 } 614
567 return NULL; 615 return NULL;
568} 616}
569 617
570 618
571/** Client wants to examine some object. So lets do so. */ 619/** Client wants to examine some object. So lets do so. */
620void
572void ExamineCmd(char *buf, int len,player *pl) 621ExamineCmd (char *buf, int len, player *pl)
573{ 622{
574 long tag = atoi(buf); 623 tag_t tag = atoi (buf);
624
625 /* If the high bit is set, player examined a pseudo object. */
626 if (tag & 0x80000000)
627 return;
628
575 object *op = esrv_get_ob_from_count(pl->ob, tag); 629 object *op = esrv_get_ob_from_count (pl->ob, tag);
576 630
577 if (!op) { 631 if (!op)
632 {
578 LOG(llevDebug, "Player '%s' tried to examine the unknown object (%ld)\n", 633 LOG (llevDebug, "Player '%s' tried to examine the unknown object (%ld)\n", &pl->ob->name, tag);
579 pl->ob->name, tag); 634 return;
580 return;
581 } 635 }
636
582 examine (pl->ob, op); 637 examine (pl->ob, op);
583} 638}
584 639
585/** Client wants to apply some object. Lets do so. */ 640/** Client wants to apply some object. Lets do so. */
641void
586void ApplyCmd(char *buf, int len,player *pl) 642ApplyCmd (char *buf, int len, player *pl)
587{ 643{
588 uint32 tag = atoi(buf); 644 tag_t tag = atoi (buf);
589 object *op = esrv_get_ob_from_count(pl->ob, tag);
590 645
591 /* sort of a hack, but if the player saves and the player then manually 646 /* 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. 647 * applies a savebed (or otherwise tries to do stuff), we run into trouble.
593 */ 648 */
594 if (QUERY_FLAG(pl->ob, FLAG_REMOVED)) return; 649 if (QUERY_FLAG (pl->ob, FLAG_REMOVED))
650 return;
595 651
596 /* If the high bit is set, player applied a pseudo object. */ 652 /* If the high bit is set, player applied a pseudo object. */
597 if (tag & 0x80000000) { 653 if (tag & 0x80000000)
654 {
598 pl->socket.look_position = tag & 0x7fffffff; 655 pl->socket.look_position = tag & 0x7fffffff;
599 pl->socket.update_look = 1; 656 pl->socket.update_look = 1;
600 return; 657 return;
601 } 658 }
602 659
660 object *op = esrv_get_ob_from_count (pl->ob, tag);
661
603 if (!op) { 662 if (!op)
663 {
604 LOG(llevDebug, "Player '%s' tried to apply the unknown object (%d)\n", 664 LOG (llevDebug, "Player '%s' tried to apply the unknown object (%d)\n", &pl->ob->name, tag);
605 pl->ob->name, tag); 665 return;
606 return;
607 } 666 }
667
608 player_apply (pl->ob, op, 0, 0); 668 player_apply (pl->ob, op, 0, 0);
609} 669}
610 670
611/** Client wants to apply some object. Lets do so. */ 671/** Client wants to apply some object. Lets do so. */
672void
612void LockItem(uint8 *data, int len,player *pl) 673LockItem (uint8 *data, int len, player *pl)
613{ 674{
614 int flag, tag;
615 object *op;
616
617 flag = data[0]; 675 int flag = data[0];
618 tag = GetInt_String(data+1); 676 tag_t tag = net_uint32 (data + 1);
619 op = esrv_get_ob_from_count(pl->ob, tag); 677 object *op = esrv_get_ob_from_count (pl->ob, tag);
620 678
621 if (!op) { 679 if (!op)
680 {
622 new_draw_info(NDI_UNIQUE, 0, pl->ob,"Could not find object to lock/unlock"); 681 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Could not find object to lock/unlock");
623 return; 682 return;
624 } 683 }
684
625 if (!flag) 685 if (!flag)
626 CLEAR_FLAG(op,FLAG_INV_LOCKED); 686 CLEAR_FLAG (op, FLAG_INV_LOCKED);
627 else 687 else
628 SET_FLAG(op,FLAG_INV_LOCKED); 688 SET_FLAG (op, FLAG_INV_LOCKED);
689
629 esrv_update_item(UPD_FLAGS, pl->ob, op); 690 esrv_update_item (UPD_FLAGS, pl->ob, op);
630} 691}
631 692
632/** Client wants to apply some object. Lets do so. */ 693/** Client wants to apply some object. Lets do so. */
694void
633void MarkItem(uint8 *data, int len,player *pl) 695MarkItem (uint8 * data, int len, player *pl)
634{ 696{
635 int tag; 697 tag_t tag = net_uint32 (data);
636 object *op;
637
638 tag = GetInt_String(data);
639 op = esrv_get_ob_from_count(pl->ob, tag); 698 object *op = esrv_get_ob_from_count (pl->ob, tag);
699
640 if (!op) { 700 if (!op)
701 {
641 new_draw_info(NDI_UNIQUE, 0, pl->ob,"Could not find object to mark"); 702 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Could not find object to mark");
642 return; 703 return;
643 } 704 }
705
644 pl->mark = op; 706 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)); 707 new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "Marked item %s", query_name (op));
647} 708}
648
649 709
650/** 710/**
651 * look_at prints items on the specified square. 711 * look_at prints items on the specified square.
652 * 712 *
653 * [ removed EARTHWALL check and added check for containers inventory. 713 * [ removed EARTHWALL check and added check for containers inventory.
654 * Tero.Haatanen@lut.fi ] 714 * Tero.Haatanen@lut.fi ]
655 */ 715 */
716void
656void look_at(object *op,int dx,int dy) { 717look_at (object *op, int dx, int dy)
718{
657 object *tmp; 719 object *tmp;
658 int flag=0; 720 int flag = 0;
659 sint16 x,y; 721 sint16 x, y;
660 mapstruct *m; 722 maptile *m;
661 723
662 x = op->x + dx; 724 x = op->x + dx;
663 y = op->y + dy; 725 y = op->y + dy;
664 726
665 if (out_of_map(op->map, x, y)) return; 727 if (out_of_map (op->map, x, y))
728 return;
666 729
667 m = get_map_from_coord(op->map, &x, &y); 730 m = get_map_from_coord (op->map, &x, &y);
668 if (!m) return; 731 if (!m)
732 return;
669 733
670 for(tmp=get_map_ob(m, x ,y);tmp!=NULL&&tmp->above!=NULL; 734 for (tmp = get_map_ob (m, x, y); tmp != NULL && tmp->above != NULL; tmp = tmp->above);
671 tmp=tmp->above);
672 735
673 for ( ; tmp != NULL; tmp=tmp->below ) { 736 for (; tmp != NULL; tmp = tmp->below)
737 {
674 if (tmp->invisible && !QUERY_FLAG(op, FLAG_WIZ)) continue; 738 if (tmp->invisible && !QUERY_FLAG (op, FLAG_WIZ))
739 continue;
675 740
676 if(!flag) { 741 if (!flag)
677 if(dx||dy) 742 {
743 if (dx || dy)
678 new_draw_info(NDI_UNIQUE, 0,op,"There you see:"); 744 new_draw_info (NDI_UNIQUE, 0, op, "There you see:");
679 else { 745 else
680 clear_win_info(op); 746 {
747 clear_win_info (op);
681 new_draw_info(NDI_UNIQUE, 0,op,"You see:"); 748 new_draw_info (NDI_UNIQUE, 0, op, "You see:");
682 } 749 }
683 flag=1; 750 flag = 1;
684 } 751 }
685 752
686 if (QUERY_FLAG(op, FLAG_WIZ)) 753 if (QUERY_FLAG (op, FLAG_WIZ))
687 new_draw_info_format(NDI_UNIQUE,0, op, "- %s (%d).",query_name(tmp),tmp->count); 754 new_draw_info_format (NDI_UNIQUE, 0, op, "- %s (%d).", query_name (tmp), tmp->count);
688 else 755 else
689 new_draw_info_format(NDI_UNIQUE,0, op, "- %s.",query_name(tmp)); 756 new_draw_info_format (NDI_UNIQUE, 0, op, "- %s.", query_name (tmp));
690 757
691 if (((tmp->inv!=NULL || (tmp->head && tmp->head->inv)) && 758 if (((tmp->inv != NULL || (tmp->head && tmp->head->inv)) &&
692 (tmp->type != CONTAINER && tmp->type!=FLESH)) || QUERY_FLAG(op, FLAG_WIZ)) 759 (tmp->type != CONTAINER && tmp->type != FLESH)) || QUERY_FLAG (op, FLAG_WIZ))
693 inventory(op,tmp->head==NULL?tmp:tmp->head); 760 inventory (op, tmp->head == NULL ? tmp : tmp->head);
694 761
695 if(QUERY_FLAG(tmp, FLAG_IS_FLOOR)&&!QUERY_FLAG(op, FLAG_WIZ)) /* don't continue under the floor */ 762 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) && !QUERY_FLAG (op, FLAG_WIZ)) /* don't continue under the floor */
696 break; 763 break;
697 } 764 }
698 765
699 if(!flag) { 766 if (!flag)
700 if(dx||dy) 767 {
768 if (dx || dy)
701 new_draw_info(NDI_UNIQUE, 0,op,"You see nothing there."); 769 new_draw_info (NDI_UNIQUE, 0, op, "You see nothing there.");
702 else 770 else
703 new_draw_info(NDI_UNIQUE, 0,op,"You see nothing."); 771 new_draw_info (NDI_UNIQUE, 0, op, "You see nothing.");
704 } 772 }
705} 773}
706 774
707 775
708 776
709/** Client wants to look at some object. Lets do so. */ 777/** Client wants to look at some object. Lets do so. */
778void
710void LookAt(char *buf, int len,player *pl) 779LookAt (char *buf, int len, player *pl)
711{ 780{
712 int dx, dy; 781 int dx, dy;
713 char *cp; 782 char *cp;
714 783
715 dx=atoi(buf); 784 dx = atoi (buf);
716 if (!(cp=strchr(buf,' '))) { 785 if (!(cp = strchr (buf, ' ')))
717 return;
718 } 786 {
787 return;
788 }
719 dy=atoi(cp); 789 dy = atoi (cp);
720 790
721 if (FABS(dx) > pl->socket.mapx / 2 || FABS(dy) > pl->socket.mapy / 2) 791 if (FABS (dx) > pl->socket.mapx / 2 || FABS (dy) > pl->socket.mapy / 2)
792 return;
793
794 if (pl->blocked_los[dx + pl->socket.mapx / 2][dy + pl->socket.mapy / 2])
795 return;
796
797 look_at (pl->ob, dx, dy);
798}
799
800/** Move an object to a new location */
801void
802esrv_move_object (object *pl, tag_t to, tag_t tag, long nrof)
803{
804 object *op, *env;
805
806 op = esrv_get_ob_from_count (pl, tag);
807 if (!op)
808 {
809 LOG (llevDebug, "Player '%s' tried to move an unknown object (%ld)\n", &pl->name, tag);
810 return;
811 }
812
813 if (!to)
814 { /* drop it to the ground */
815
816/* LOG(llevDebug, "Drop it on the ground.\n");*/
817
818 if (op->map && !op->env)
819 {
820
821/* LOG(llevDebug,"Dropping object to ground that is already on ground\n");*/
722 return; 822 return;
723 823 }
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 824 /* If it is an active container, then we should drop all objects
753 * in the container and not the container itself. 825 * in the container and not the container itself.
754 */ 826 */
755 if (op->inv && QUERY_FLAG(op, FLAG_APPLIED)) { 827 if (op->inv && QUERY_FLAG (op, FLAG_APPLIED))
828 {
756 object *current, *next; 829 object *current, *next;
830
757 for (current=op->inv; current!=NULL; current=next) { 831 for (current = op->inv; current != NULL; current = next)
758 next=current->below; 832 {
833 next = current->below;
759 drop_object(pl, current, 0); 834 drop_object (pl, current, 0);
760 } 835 }
761 esrv_update_item(UPD_WEIGHT, pl, op); 836 esrv_update_item (UPD_WEIGHT, pl, op);
762 } 837 }
763 else { 838 else
839 {
764 drop_object (pl, op, nrof); 840 drop_object (pl, op, nrof);
765 } 841 }
766 return; 842 return;
767 } else if (to == pl->count) { /* pick it up to the inventory */ 843 }
844 else if (to == pl->count)
845 { /* pick it up to the inventory */
768 /* return if player has already picked it up */ 846 /* return if player has already picked it up */
769 if (op->env == pl) return; 847 if (op->env == pl)
848 return;
770 849
771 pl->contr->count = nrof; 850 pl->contr->count = nrof;
772 pick_up(pl, op); 851 pick_up (pl, op);
773 return ; 852 return;
774 } 853 }
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); 854 env = esrv_get_ob_from_count (pl, to);
782 if (!env) { 855 if (!env)
783 LOG(llevDebug, 856 {
784 "Player '%s' tried to move object to the unknown location (%d)\n", 857 LOG (llevDebug, "Player '%s' tried to move object to the unknown location (%d)\n", &pl->name, to);
785 pl->name, to);
786 return; 858 return;
787 } 859 }
788 /* put_object_in_sack presumes that necessary sanity checking 860 /* put_object_in_sack presumes that necessary sanity checking
789 * has already been done (eg, it can be picked up and fits in 861 * 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 862 * 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. 863 * an make sure env is in fact a container for that matter.
792 */ 864 */
793 if (env->type == CONTAINER
794 && can_pick(pl, op) && sack_can_hold(pl, env, op, nrof)) { 865 if (env->type == CONTAINER && can_pick (pl, op) && sack_can_hold (pl, env, op, nrof))
866 {
795 put_object_in_sack (pl, env, op, nrof); 867 put_object_in_sack (pl, env, op, nrof);
796 }
797 } 868 }
798} 869}
799
800

Diff Legend

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