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

Diff Legend

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