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.2 by root, Tue Aug 29 07:34:01 2006 UTC vs.
Revision 1.8 by root, Sat Sep 16 22:24:13 2006 UTC

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

Diff Legend

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