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.6 by root, Tue Sep 12 19:20:09 2006 UTC vs.
Revision 1.23 by root, Fri Dec 15 19:59:20 2006 UTC

… …
16 16
17 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
18 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 20
21 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>
22*/ 22*/
23 23
24/** 24/**
25 * \file 25 * \file
26 * Client/server logic. 26 * Client/server logic.
… …
33 */ 33 */
34 34
35 35
36#include <global.h> 36#include <global.h>
37#include <object.h> /* LOOK_OBJ */ 37#include <object.h> /* LOOK_OBJ */
38#include <newclient.h>
39#include <newserver.h>
40#include <sproto.h> 38#include <sproto.h>
41 39
42/** This is the maximum number of bytes we expect any one item to take up */ 40/** This is the maximum number of bytes we expect any one item to take up */
43#define MAXITEMLEN 300 41#define MAXITEMLEN 300
44 42
45/******************************************************************************* 43/*******************************************************************************
46 * 44 *
47 * Functions related to sending object data to the client. 45 * Functions related to sending object data to the client.
48 * 46 *
49 ******************************************************************************/ 47 ******************************************************************************/
50
51/**
52 * Adds string to socklist.
53 *
54 * This is a simple function that we use a lot here. It basically
55 * adds the specified buffer into the socklist, but prepends a
56 * single byte in length. If the data is longer than that byte, it is
57 * truncated approprately.
58 */
59inline void
60add_stringlen_to_sockbuf (const char *buf, SockList * sl)
61{
62 int len;
63
64 len = strlen (buf);
65 if (len > 255)
66 len = 255;
67 SockList_AddChar (sl, (char) len);
68 strncpy ((char *) sl->buf + sl->len, buf, len);
69 sl->len += len;
70}
71 48
72/** 49/**
73 * This is a similar to query_name, but returns flags 50 * This is a similar to query_name, but returns flags
74 * to be sended to client. 51 * to be sended to client.
75 */ 52 */
… …
130 flags |= F_LOCKED; 107 flags |= F_LOCKED;
131 108
132 return flags; 109 return flags;
133} 110}
134 111
135/* Used in the send_look to put object head into SockList 112/* Used in the send_look to put object head into packet
136 * sl for socket ns. Need socket to know if we need to send 113 * sl for socket ns. Need socket to know if we need to send
137 * animation of face to the client. 114 * animation of face to the client.
138 */ 115 */
139static void 116static void
140add_object_to_socklist (NewSocket * ns, SockList * sl, object *head) 117add_object_to_socklist (client &ns, packet &sl, object *head)
141{ 118{
142 int flags, len, anim_speed; 119 int flags, len, anim_speed;
143 char item_n[MAX_BUF]; 120 char item_n[MAX_BUF];
144 const char *item_p; 121 const char *item_p;
145 122
146 flags = query_flags (head); 123 flags = query_flags (head);
147 if (QUERY_FLAG (head, FLAG_NO_PICK)) 124 if (QUERY_FLAG (head, FLAG_NO_PICK))
148 flags |= F_NOPICK; 125 flags |= F_NOPICK;
149 126
150 if (!(ns->faces_sent[head->face->number] & NS_FACESENT_FACE)) 127 if (!(ns.faces_sent[head->face->number] & NS_FACESENT_FACE))
151 esrv_send_face (ns, head->face->number, 0); 128 esrv_send_face (&ns, head->face->number, 0);
152 129
153 if (QUERY_FLAG (head, FLAG_ANIMATE) && !ns->anims_sent[head->animation_id]) 130 if (QUERY_FLAG (head, FLAG_ANIMATE) && !ns.anims_sent[head->animation_id])
154 esrv_send_animation (ns, head->animation_id); 131 esrv_send_animation (&ns, head->animation_id);
155 132
156 SockList_AddInt (sl, head->count); 133 sl << uint32 (head->count)
157 SockList_AddInt (sl, flags); 134 << uint32 (flags)
158 SockList_AddInt (sl, QUERY_FLAG (head, FLAG_NO_PICK) ? -1 : WEIGHT (head)); 135 << uint32 (QUERY_FLAG (head, FLAG_NO_PICK) ? -1 : WEIGHT (head))
159 SockList_AddInt (sl, head->face->number); 136 << uint32 (head->face->number);
160 137
161 if (!head->custom_name) 138 if (!head->custom_name)
162 { 139 {
163 strncpy (item_n, query_base_name (head, 0), 127); 140 strncpy (item_n, query_base_name (head, 0), 127);
164 item_n[127] = 0; 141 item_n[127] = 0;
… …
170 strncpy (item_n, head->custom_name, 127); 147 strncpy (item_n, head->custom_name, 127);
171 item_n[127] = 0; 148 item_n[127] = 0;
172 len = strlen (item_n); 149 len = strlen (item_n);
173 item_p = head->custom_name; 150 item_p = head->custom_name;
174 } 151 }
152
175 strncpy (item_n + len + 1, item_p, 127); 153 strncpy (item_n + len + 1, item_p, 127);
176 item_n[254] = 0; 154 item_n[254] = 0;
177 len += strlen (item_n + 1 + len) + 1; 155 len += strlen (item_n + 1 + len) + 1;
178 SockList_AddChar (sl, (char) len);
179 memcpy (sl->buf + sl->len, item_n, len);
180 sl->len += len;
181 156
182 SockList_AddShort (sl, head->animation_id); 157 sl << data8 (item_n, len)
158 << uint16 (head->animation_id);
159
183 anim_speed = 0; 160 anim_speed = 0;
184 if (QUERY_FLAG (head, FLAG_ANIMATE)) 161 if (QUERY_FLAG (head, FLAG_ANIMATE))
185 { 162 {
186 if (head->anim_speed) 163 if (head->anim_speed)
187 anim_speed = head->anim_speed; 164 anim_speed = head->anim_speed;
… …
192 else if (FABS (head->speed) >= 1.0) 169 else if (FABS (head->speed) >= 1.0)
193 anim_speed = 1; 170 anim_speed = 1;
194 else 171 else
195 anim_speed = (int) (1.0 / FABS (head->speed)); 172 anim_speed = (int) (1.0 / FABS (head->speed));
196 } 173 }
174
197 if (anim_speed > 255) 175 if (anim_speed > 255)
198 anim_speed = 255; 176 anim_speed = 255;
199 } 177 }
200 SockList_AddChar (sl, (char) anim_speed);
201 SockList_AddInt (sl, head->nrof);
202 178
179 sl << uint8 (anim_speed)
180 << uint32 (head->nrof);
181
203 if (ns->itemcmd == 2) 182 if (ns.itemcmd == 2)
204 SockList_AddShort (sl, head->client_type); 183 sl << uint16 (head->client_type);
205 184
206 SET_FLAG (head, FLAG_CLIENT_SENT); 185 SET_FLAG (head, FLAG_CLIENT_SENT);
207} 186}
208 187
209 188
… …
216void 195void
217esrv_draw_look (object *pl) 196esrv_draw_look (object *pl)
218{ 197{
219 object *tmp, *last; 198 object *tmp, *last;
220 int got_one = 0, start_look = 0, end_look = 0; 199 int got_one = 0, start_look = 0, end_look = 0;
221 SockList sl;
222 char buf[MAX_BUF]; 200 char buf[MAX_BUF];
223 201
224 if (!pl->contr->socket.update_look) 202 if (!pl->contr->socket->update_look)
225 { 203 {
226 LOG (llevDebug, "esrv_draw_look called when update_look was not set\n"); 204 LOG (llevDebug, "esrv_draw_look called when update_look was not set\n");
227 return; 205 return;
228 } 206 }
229 else 207 else
230 {
231 pl->contr->socket.update_look = 0; 208 pl->contr->socket->update_look = 0;
232 }
233 209
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)) 210 if (QUERY_FLAG (pl, FLAG_REMOVED)
211 || !pl->map
212 || pl->map->in_memory != MAP_IN_MEMORY
213 || out_of_map (pl->map, pl->x, pl->y))
235 return; 214 return;
236 215
237 for (tmp = get_map_ob (pl->map, pl->x, pl->y); tmp && tmp->above; tmp = tmp->above); 216 for (tmp = get_map_ob (pl->map, pl->x, pl->y); tmp && tmp->above; tmp = tmp->above)
217 ;
238 218
239 sl.buf = (unsigned char *) malloc (MAXSOCKBUF); 219 packet sl;
240 220
241 Write_String_To_Socket (&pl->contr->socket, "delinv 0", strlen ("delinv 0")); 221 pl->contr->socket->send_packet ("delinv 0");
222
242 sprintf ((char *) sl.buf, "item%d ", pl->contr->socket.itemcmd); 223 sl.printf ("item%d ", pl->contr->socket->itemcmd);
243 sl.len = strlen ((char *) sl.buf);
244 224
245 SockList_AddInt (&sl, 0); 225 sl << uint32 (0);
246 226
247 if (!(pl->contr->socket.faces_sent[empty_face->number] & NS_FACESENT_FACE)) 227 if (!(pl->contr->socket->faces_sent[empty_face->number] & NS_FACESENT_FACE))
248 esrv_send_face (&pl->contr->socket, empty_face->number, 0); 228 esrv_send_face (pl->contr->socket, empty_face->number, 0);
249 229
250 if (pl->contr->socket.look_position) 230 if (pl->contr->socket->look_position)
251 { 231 {
252 SockList_AddInt (&sl, 0x80000000 | (pl->contr->socket.look_position - NUM_LOOK_OBJECTS)); 232 char buf[80];
253 SockList_AddInt (&sl, 0);
254 SockList_AddInt (&sl, (uint32) - 1);
255 SockList_AddInt (&sl, empty_face->number);
256 sprintf (buf, "Click here to see %d previous items", NUM_LOOK_OBJECTS); 233 snprintf (buf, 80, "Apply this to see %d previous items", NUM_LOOK_OBJECTS);
257 add_stringlen_to_sockbuf (buf, &sl); 234
258 SockList_AddShort (&sl, 0); 235 sl << uint32 (0x80000000 | (pl->contr->socket->look_position - NUM_LOOK_OBJECTS))
259 SockList_AddChar (&sl, 0); 236 << uint32 (0)
260 SockList_AddInt (&sl, 0); 237 << sint32 (-1)
238 << uint32 (empty_face->number)
239 << data8 (buf)
240 << uint16 (0)
241 << uint8 (0)
242 << uint32 (0);
243
261 if (pl->contr->socket.itemcmd == 2) 244 if (pl->contr->socket->itemcmd == 2)
262 SockList_AddShort (&sl, 0); 245 sl << uint16 (0);
263 } 246 }
264 247
265 for (last = NULL; tmp != last; tmp = tmp->below) 248 for (last = NULL; tmp != last; tmp = tmp->below)
266 { 249 {
267 object *head; 250 object *head;
… …
270 { 253 {
271 last = tmp->below; /* assumes double floor mode */ 254 last = tmp->below; /* assumes double floor mode */
272 if (last && QUERY_FLAG (last, FLAG_IS_FLOOR)) 255 if (last && QUERY_FLAG (last, FLAG_IS_FLOOR))
273 last = last->below; 256 last = last->below;
274 } 257 }
258
275 if (LOOK_OBJ (tmp)) 259 if (LOOK_OBJ (tmp))
276 { 260 {
277 if (++start_look < pl->contr->socket.look_position) 261 if (++start_look < pl->contr->socket->look_position)
278 continue; 262 continue;
263
279 end_look++; 264 end_look++;
265
280 if (end_look > NUM_LOOK_OBJECTS) 266 if (end_look > NUM_LOOK_OBJECTS)
281 { 267 {
282 /* What we basically do is make a 'fake' object - when the user applies it, 268 /* What we basically do is make a 'fake' object - when the user applies it,
283 * we notice the special tag the object has, and act accordingly. 269 * we notice the special tag the object has, and act accordingly.
284 */ 270 */
285 SockList_AddInt (&sl, 0x80000000 | (pl->contr->socket.look_position + NUM_LOOK_OBJECTS)); 271 sl << uint32 (0x80000000 | (pl->contr->socket->look_position + NUM_LOOK_OBJECTS))
286 SockList_AddInt (&sl, 0); 272 << uint32 (0)
287 SockList_AddInt (&sl, (uint32) - 1); 273 << uint32 ((uint32) - 1)
288 SockList_AddInt (&sl, empty_face->number); 274 << uint32 (empty_face->number)
289 sprintf (buf, "Click here to see next group of items"); 275 << data8 ("Apply this to see next group of items")
290 add_stringlen_to_sockbuf (buf, &sl); 276 << uint16 (0)
291 SockList_AddShort (&sl, 0); 277 << uint8 (0)
292 SockList_AddChar (&sl, 0); 278 << uint32 (0);
293 SockList_AddInt (&sl, 0); 279
294 if (pl->contr->socket.itemcmd == 2) 280 if (pl->contr->socket->itemcmd == 2)
295 SockList_AddShort (&sl, 0); 281 sl << uint16 (0);
282
296 break; 283 break;
297 } 284 }
285
298 if (tmp->head) 286 if (tmp->head)
299 head = tmp->head; 287 head = tmp->head;
300 else 288 else
301 head = tmp; 289 head = tmp;
302 290
303 add_object_to_socklist (&pl->contr->socket, &sl, head); 291 add_object_to_socklist (*pl->contr->socket, sl, head);
304 got_one++; 292 got_one++;
305 293
306 if (sl.len >= (MAXSOCKBUF - MAXITEMLEN)) 294 if (sl.length () >= (MAXSOCKBUF - MAXITEMLEN))
307 { 295 {
308 Send_With_Handling (&pl->contr->socket, &sl); 296 pl->contr->socket->send_packet (sl);
297
298 sl.reset ();
309 sprintf ((char *) sl.buf, "item%d ", pl->contr->socket.itemcmd); 299 sl.printf ("item%d ", pl->contr->socket->itemcmd);
310 sl.len = strlen ((char *) sl.buf); 300 sl << uint32 (0);
311 SockList_AddInt (&sl, 0);
312 got_one = 0; 301 got_one = 0;
313 } 302 }
314 } /* If LOOK_OBJ() */ 303 } /* If LOOK_OBJ() */
315 } 304 }
305
316 if (got_one) 306 if (got_one)
317 Send_With_Handling (&pl->contr->socket, &sl); 307 pl->contr->socket->send_packet (sl);
318 308
319 free (sl.buf);
320} 309}
321 310
322/** 311/**
323 * Sends whole inventory. 312 * Sends whole inventory.
324 */ 313 */
325void 314void
326esrv_send_inventory (object *pl, object *op) 315esrv_send_inventory (object *pl, object *op)
327{ 316{
328 object *tmp; 317 object *tmp;
329 int got_one = 0; 318 int got_one = 0;
330 SockList sl;
331 319
332 sl.buf = (unsigned char *) malloc (MAXSOCKBUF); 320 packet sl;
333 321
334 sprintf ((char *) sl.buf, "delinv %d", op->count); 322 sl.printf ("delinv %d", op->count);
335 sl.len = strlen ((char *) sl.buf); 323 pl->contr->socket->send_packet (sl);
336 Send_With_Handling (&pl->contr->socket, &sl);
337 324
325 sl.reset ();
338 sprintf ((char *) sl.buf, "item%d ", pl->contr->socket.itemcmd); 326 sl.printf ("item%d ", pl->contr->socket->itemcmd);
339 sl.len = strlen ((char *) sl.buf);
340 327
341 SockList_AddInt (&sl, op->count); 328 sl << uint32 (op->count);
342 329
343 for (tmp = op->inv; tmp; tmp = tmp->below) 330 for (tmp = op->inv; tmp; tmp = tmp->below)
344 { 331 {
345 object *head; 332 object *head;
346 333
… …
349 else 336 else
350 head = tmp; 337 head = tmp;
351 338
352 if (LOOK_OBJ (head)) 339 if (LOOK_OBJ (head))
353 { 340 {
354 add_object_to_socklist (&pl->contr->socket, &sl, head); 341 add_object_to_socklist (*pl->contr->socket, sl, head);
355 342
356 got_one++; 343 got_one++;
357 344
358 /* IT is possible for players to accumulate a huge amount of 345 /* IT is possible for players to accumulate a huge amount of
359 * items (especially with some of the bags out there) to 346 * items (especially with some of the bags out there) to
360 * overflow the buffer. IF so, send multiple item commands. 347 * overflow the buffer. IF so, send multiple item commands.
361 */ 348 */
362 if (sl.len >= (MAXSOCKBUF - MAXITEMLEN)) 349 if (sl.length () >= (MAXSOCKBUF - MAXITEMLEN))
363 { 350 {
364 Send_With_Handling (&pl->contr->socket, &sl); 351 pl->contr->socket->send_packet (sl);
352
353 sl.reset ();
365 sprintf ((char *) sl.buf, "item%d ", pl->contr->socket.itemcmd); 354 sl.printf ("item%d ", pl->contr->socket->itemcmd);
366 sl.len = strlen ((char *) sl.buf); 355 sl << uint32 (op->count);
367 SockList_AddInt (&sl, op->count);
368 got_one = 0; 356 got_one = 0;
369 } 357 }
370 } /* If LOOK_OBJ() */ 358 } /* If LOOK_OBJ() */
371 } 359 }
360
372 if (got_one) 361 if (got_one)
373 Send_With_Handling (&pl->contr->socket, &sl); 362 pl->contr->socket->send_packet (sl);
374 free (sl.buf); 363
375} 364}
376 365
377/** 366/**
378 * Updates object *op for player *pl. 367 * Updates object *op for player *pl.
379 * 368 *
… …
383 */ 372 */
384 373
385void 374void
386esrv_update_item (int flags, object *pl, object *op) 375esrv_update_item (int flags, object *pl, object *op)
387{ 376{
388 SockList sl;
389
390 /* If we have a request to send the player item, skip a few checks. */ 377 /* If we have a request to send the player item, skip a few checks. */
391 if (op != pl) 378 if (op != pl)
392 { 379 {
393 if (!LOOK_OBJ (op)) 380 if (!LOOK_OBJ (op))
394 return; 381 return;
395 /* we remove the check for op->env, because in theory, the object 382 /* we remove the check for op->env, because in theory, the object
396 * is hopefully in the same place, so the client should preserve 383 * is hopefully in the same place, so the client should preserve
397 * order. 384 * order.
398 */ 385 */
399 } 386 }
387
400 if (!QUERY_FLAG (op, FLAG_CLIENT_SENT)) 388 if (!QUERY_FLAG (op, FLAG_CLIENT_SENT))
401 { 389 {
402 /* FLAG_CLIENT_SENT is debug only. We are using it to see where 390 /* FLAG_CLIENT_SENT is debug only. We are using it to see where
403 * this is happening - we can set a breakpoint here in the debugger 391 * this is happening - we can set a breakpoint here in the debugger
404 * and track back the call. 392 * and track back the call.
405 */ 393 */
406 LOG (llevDebug, "We have not sent item %s (%d)\n", &op->name, op->count); 394 LOG (llevDebug, "We have not sent item %s (%d)\n", &op->name, op->count);
407 } 395 }
408 sl.buf = (unsigned char *) malloc (MAXSOCKBUF);
409 396
410 strcpy ((char *) sl.buf, "upditem "); 397 packet sl;
411 sl.len = strlen ((char *) sl.buf);
412 398
413 SockList_AddChar (&sl, (char) flags); 399 sl << "upditem "
400 << uint8 (flags);
414 401
415 if (op->head) 402 if (op->head)
416 op = op->head; 403 op = op->head;
417 404
418 SockList_AddInt (&sl, op->count); 405 sl << uint32 (op->count);
419 406
420 if (flags & UPD_LOCATION) 407 if (flags & UPD_LOCATION)
421 SockList_AddInt (&sl, op->env ? op->env->count : 0); 408 sl << uint32 (op->env ? op->env->count : 0);
422 409
423 if (flags & UPD_FLAGS) 410 if (flags & UPD_FLAGS)
424 SockList_AddInt (&sl, query_flags (op)); 411 sl << uint32 (query_flags (op));
425 412
426 if (flags & UPD_WEIGHT) 413 if (flags & UPD_WEIGHT)
427 { 414 {
428 sint32 weight = WEIGHT (op); 415 sint32 weight = WEIGHT (op);
429 416
430 SockList_AddInt (&sl, QUERY_FLAG (op, FLAG_NO_PICK) ? -1 : weight); 417 sl << uint32 (QUERY_FLAG (op, FLAG_NO_PICK) ? -1 : weight);
418
431 if (pl == op) 419 if (pl == op)
432 {
433 op->contr->last_weight = weight; 420 op->contr->last_weight = weight;
434 }
435 } 421 }
436 422
437 if (flags & UPD_FACE) 423 if (flags & UPD_FACE)
438 { 424 {
439 if (!(pl->contr->socket.faces_sent[op->face->number] & NS_FACESENT_FACE)) 425 if (!(pl->contr->socket->faces_sent[op->face->number] & NS_FACESENT_FACE))
440 esrv_send_face (&pl->contr->socket, op->face->number, 0); 426 esrv_send_face (pl->contr->socket, op->face->number, 0);
441 SockList_AddInt (&sl, op->face->number); 427
428 sl << uint32 (op->face->number);
442 } 429 }
430
443 if (flags & UPD_NAME) 431 if (flags & UPD_NAME)
444 { 432 {
445 int len; 433 int len;
446 const char *item_p; 434 const char *item_p;
447 char item_n[MAX_BUF]; 435 char item_n[MAX_BUF];
… …
462 } 450 }
463 451
464 strncpy (item_n + len + 1, item_p, 127); 452 strncpy (item_n + len + 1, item_p, 127);
465 item_n[254] = 0; 453 item_n[254] = 0;
466 len += strlen (item_n + 1 + len) + 1; 454 len += strlen (item_n + 1 + len) + 1;
467 SockList_AddChar (&sl, (char) len); 455
468 memcpy (sl.buf + sl.len, item_n, len); 456 sl << data8 (item_n, len);
469 sl.len += len;
470 } 457 }
458
471 if (flags & UPD_ANIM) 459 if (flags & UPD_ANIM)
472 SockList_AddShort (&sl, op->animation_id); 460 sl << uint16 (op->animation_id);
473 461
474 if (flags & UPD_ANIMSPEED) 462 if (flags & UPD_ANIMSPEED)
475 { 463 {
476 int anim_speed = 0; 464 int anim_speed = 0;
477 465
… …
486 else if (FABS (op->speed) >= 1.0) 474 else if (FABS (op->speed) >= 1.0)
487 anim_speed = 1; 475 anim_speed = 1;
488 else 476 else
489 anim_speed = (int) (1.0 / FABS (op->speed)); 477 anim_speed = (int) (1.0 / FABS (op->speed));
490 } 478 }
479
491 if (anim_speed > 255) 480 if (anim_speed > 255)
492 anim_speed = 255; 481 anim_speed = 255;
493 } 482 }
494 SockList_AddChar (&sl, (char) anim_speed); 483
484 sl << uint8 (anim_speed);
495 } 485 }
486
496 if (flags & UPD_NROF) 487 if (flags & UPD_NROF)
497 SockList_AddInt (&sl, op->nrof); 488 sl << uint32 (op->nrof);
498 489
499 Send_With_Handling (&pl->contr->socket, &sl); 490 pl->contr->socket->send_packet (sl);
500 free (sl.buf);
501} 491}
502 492
503/** 493/**
504 * Sends item's info to player. 494 * Sends item's info to player.
505 */ 495 */
506void 496void
507esrv_send_item (object *pl, object *op) 497esrv_send_item (object *pl, object *op)
508{ 498{
509 SockList sl;
510
511 /* If this is not the player object, do some more checks */ 499 /* If this is not the player object, do some more checks */
512 if (op != pl) 500 if (op != pl)
513 { 501 {
514 /* We only send 'visibile' objects to the client */ 502 /* We only send 'visibile' objects to the client */
515 if (!LOOK_OBJ (op)) 503 if (!LOOK_OBJ (op))
… …
517 /* if the item is on the ground, mark that the look needs to 505 /* if the item is on the ground, mark that the look needs to
518 * be updated. 506 * be updated.
519 */ 507 */
520 if (!op->env) 508 if (!op->env)
521 { 509 {
522 pl->contr->socket.update_look = 1; 510 pl->contr->socket->update_look = 1;
523 return; 511 return;
524 } 512 }
525 } 513 }
526 514
527 sl.buf = (unsigned char *) malloc (MAXSOCKBUF); 515 packet sl;
528 516
529 sprintf ((char *) sl.buf, "item%d ", pl->contr->socket.itemcmd); 517 sl.printf ("item%d ", pl->contr->socket->itemcmd);
530 sl.len = strlen ((char *) sl.buf);
531 518
532 if (op->head) 519 if (op->head)
533 op = op->head; 520 op = op->head;
534 521
535 SockList_AddInt (&sl, op->env ? op->env->count : 0); 522 sl << uint32 (op->env ? op->env->count : 0);
536 523
537 add_object_to_socklist (&pl->contr->socket, &sl, op); 524 add_object_to_socklist (*pl->contr->socket, sl, op);
538 525
539 Send_With_Handling (&pl->contr->socket, &sl); 526 pl->contr->socket->send_packet (sl);
540 SET_FLAG (op, FLAG_CLIENT_SENT); 527 SET_FLAG (op, FLAG_CLIENT_SENT);
541 free (sl.buf); 528
542} 529}
543 530
544/** 531/**
545 * Tells the client to delete an item. Uses the item 532 * Tells the client to delete an item. Uses the item
546 * command with a -1 location. 533 * command with a -1 location.
547 */ 534 */
548 535
549void 536void
550esrv_del_item (player *pl, int tag) 537esrv_del_item (player *pl, int tag)
551{ 538{
552 SockList sl; 539 packet sl;
553 540
554 sl.buf = (unsigned char *) malloc (MAXSOCKBUF); 541 sl << "delitem "
542 << uint32 (tag);
555 543
556 strcpy ((char *) sl.buf, "delitem "); 544 pl->socket->send_packet (sl);
557 sl.len = strlen ((char *) sl.buf);
558 SockList_AddInt (&sl, tag);
559
560 Send_With_Handling (&pl->socket, &sl);
561 free (sl.buf);
562} 545}
563 546
564 547
565/******************************************************************************* 548/*******************************************************************************
566 * 549 *
… …
605 588
606/** Client wants to examine some object. So lets do so. */ 589/** Client wants to examine some object. So lets do so. */
607void 590void
608ExamineCmd (char *buf, int len, player *pl) 591ExamineCmd (char *buf, int len, player *pl)
609{ 592{
610 long tag = atoi (buf); 593 tag_t tag = atoi (buf);
594
595 /* If the high bit is set, player examined a pseudo object. */
596 if (tag & 0x80000000)
597 return;
598
611 object *op = esrv_get_ob_from_count (pl->ob, tag); 599 object *op = esrv_get_ob_from_count (pl->ob, tag);
612 600
613 if (!op) 601 if (!op)
614 { 602 {
615 LOG (llevDebug, "Player '%s' tried to examine the unknown object (%ld)\n", &pl->ob->name, tag); 603 LOG (llevDebug, "Player '%s' tried to examine the unknown object (%ld)\n", &pl->ob->name, tag);
616 return; 604 return;
617 } 605 }
606
618 examine (pl->ob, op); 607 examine (pl->ob, op);
619} 608}
620 609
621/** Client wants to apply some object. Lets do so. */ 610/** Client wants to apply some object. Lets do so. */
622void 611void
623ApplyCmd (char *buf, int len, player *pl) 612ApplyCmd (char *buf, int len, player *pl)
624{ 613{
625 uint32 tag = atoi (buf); 614 tag_t tag = atoi (buf);
626 object *op = esrv_get_ob_from_count (pl->ob, tag);
627 615
628 /* sort of a hack, but if the player saves and the player then manually 616 /* sort of a hack, but if the player saves and the player then manually
629 * applies a savebed (or otherwise tries to do stuff), we run into trouble. 617 * applies a savebed (or otherwise tries to do stuff), we run into trouble.
630 */ 618 */
631 if (QUERY_FLAG (pl->ob, FLAG_REMOVED)) 619 if (QUERY_FLAG (pl->ob, FLAG_REMOVED))
632 return; 620 return;
633 621
634 /* If the high bit is set, player applied a pseudo object. */ 622 /* If the high bit is set, player applied a pseudo object. */
635 if (tag & 0x80000000) 623 if (tag & 0x80000000)
636 { 624 {
637 pl->socket.look_position = tag & 0x7fffffff; 625 pl->socket->look_position = tag & 0x7fffffff;
638 pl->socket.update_look = 1; 626 pl->socket->update_look = 1;
639 return; 627 return;
640 } 628 }
629
630 object *op = esrv_get_ob_from_count (pl->ob, tag);
641 631
642 if (!op) 632 if (!op)
643 { 633 {
644 LOG (llevDebug, "Player '%s' tried to apply the unknown object (%d)\n", &pl->ob->name, tag); 634 LOG (llevDebug, "Player '%s' tried to apply the unknown object (%d)\n", &pl->ob->name, tag);
645 return; 635 return;
646 } 636 }
637
647 player_apply (pl->ob, op, 0, 0); 638 player_apply (pl->ob, op, 0, 0);
648} 639}
649 640
650/** Client wants to apply some object. Lets do so. */ 641/** Client wants to apply some object. Lets do so. */
651void 642void
652LockItem (uint8 * data, int len, player *pl) 643LockItem (char *data, int len, player *pl)
653{ 644{
654 int flag, tag;
655 object *op;
656
657 flag = data[0]; 645 int flag = data[0];
658 tag = GetInt_String (data + 1); 646 tag_t tag = net_uint32 ((uint8 *)data + 1);
659 op = esrv_get_ob_from_count (pl->ob, tag); 647 object *op = esrv_get_ob_from_count (pl->ob, tag);
660 648
661 if (!op) 649 if (!op)
662 { 650 {
663 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Could not find object to lock/unlock"); 651 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Could not find object to lock/unlock");
664 return; 652 return;
665 } 653 }
654
666 if (!flag) 655 if (!flag)
667 CLEAR_FLAG (op, FLAG_INV_LOCKED); 656 CLEAR_FLAG (op, FLAG_INV_LOCKED);
668 else 657 else
669 SET_FLAG (op, FLAG_INV_LOCKED); 658 SET_FLAG (op, FLAG_INV_LOCKED);
659
670 esrv_update_item (UPD_FLAGS, pl->ob, op); 660 esrv_update_item (UPD_FLAGS, pl->ob, op);
671} 661}
672 662
673/** Client wants to apply some object. Lets do so. */ 663/** Client wants to apply some object. Lets do so. */
674void 664void
675MarkItem (uint8 * data, int len, player *pl) 665MarkItem (char *data, int len, player *pl)
676{ 666{
677 int tag; 667 tag_t tag = net_uint32 ((uint8 *)data);
678 object *op;
679
680 tag = GetInt_String (data);
681 op = esrv_get_ob_from_count (pl->ob, tag); 668 object *op = esrv_get_ob_from_count (pl->ob, tag);
669
682 if (!op) 670 if (!op)
683 { 671 {
684 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Could not find object to mark"); 672 new_draw_info (NDI_UNIQUE, 0, pl->ob, "Could not find object to mark");
685 return; 673 return;
686 } 674 }
675
687 pl->mark = op; 676 pl->mark = op;
688 pl->mark_count = op->count;
689 new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "Marked item %s", query_name (op)); 677 new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "Marked item %s", query_name (op));
690} 678}
691
692 679
693/** 680/**
694 * look_at prints items on the specified square. 681 * look_at prints items on the specified square.
695 * 682 *
696 * [ removed EARTHWALL check and added check for containers inventory. 683 * [ removed EARTHWALL check and added check for containers inventory.
… …
700look_at (object *op, int dx, int dy) 687look_at (object *op, int dx, int dy)
701{ 688{
702 object *tmp; 689 object *tmp;
703 int flag = 0; 690 int flag = 0;
704 sint16 x, y; 691 sint16 x, y;
705 mapstruct *m; 692 maptile *m;
706 693
707 x = op->x + dx; 694 x = op->x + dx;
708 y = op->y + dy; 695 y = op->y + dy;
709 696
710 if (out_of_map (op->map, x, y)) 697 if (out_of_map (op->map, x, y))
… …
769 { 756 {
770 return; 757 return;
771 } 758 }
772 dy = atoi (cp); 759 dy = atoi (cp);
773 760
774 if (FABS (dx) > pl->socket.mapx / 2 || FABS (dy) > pl->socket.mapy / 2) 761 if (FABS (dx) > pl->socket->mapx / 2 || FABS (dy) > pl->socket->mapy / 2)
775 return; 762 return;
776 763
777 if (pl->blocked_los[dx + pl->socket.mapx / 2][dy + pl->socket.mapy / 2]) 764 if (pl->blocked_los[dx + pl->socket->mapx / 2][dy + pl->socket->mapy / 2])
778 return; 765 return;
779 766
780 look_at (pl->ob, dx, dy); 767 look_at (pl->ob, dx, dy);
781} 768}
782 769
… …
793 return; 780 return;
794 } 781 }
795 782
796 if (!to) 783 if (!to)
797 { /* drop it to the ground */ 784 { /* drop it to the ground */
798
799/* LOG(llevDebug, "Drop it on the ground.\n");*/
800
801 if (op->map && !op->env) 785 if (op->map && !op->env)
802 {
803
804/* LOG(llevDebug,"Dropping object to ground that is already on ground\n");*/
805 return; 786 return;
806 } 787
807 /* If it is an active container, then we should drop all objects 788 /* If it is an active container, then we should drop all objects
808 * in the container and not the container itself. 789 * in the container and not the container itself.
809 */ 790 */
810 if (op->inv && QUERY_FLAG (op, FLAG_APPLIED)) 791 if (op->inv && QUERY_FLAG (op, FLAG_APPLIED))
811 { 792 {
… …
814 for (current = op->inv; current != NULL; current = next) 795 for (current = op->inv; current != NULL; current = next)
815 { 796 {
816 next = current->below; 797 next = current->below;
817 drop_object (pl, current, 0); 798 drop_object (pl, current, 0);
818 } 799 }
800
819 esrv_update_item (UPD_WEIGHT, pl, op); 801 esrv_update_item (UPD_WEIGHT, pl, op);
820 } 802 }
821 else 803 else
822 { 804 {
823 drop_object (pl, op, nrof); 805 drop_object (pl, op, nrof);
… …
832 814
833 pl->contr->count = nrof; 815 pl->contr->count = nrof;
834 pick_up (pl, op); 816 pick_up (pl, op);
835 return; 817 return;
836 } 818 }
819
837 env = esrv_get_ob_from_count (pl, to); 820 env = esrv_get_ob_from_count (pl, to);
838 if (!env) 821 if (!env)
839 { 822 {
840 LOG (llevDebug, "Player '%s' tried to move object to the unknown location (%d)\n", &pl->name, to); 823 LOG (llevDebug, "Player '%s' tried to move object to the unknown location (%d)\n", &pl->name, to);
841 return; 824 return;
842 } 825 }
826
843 /* put_object_in_sack presumes that necessary sanity checking 827 /* put_object_in_sack presumes that necessary sanity checking
844 * has already been done (eg, it can be picked up and fits in 828 * has already been done (eg, it can be picked up and fits in
845 * in a sack, so check for those things. We should also check 829 * in a sack, so check for those things. We should also check
846 * an make sure env is in fact a container for that matter. 830 * an make sure env is in fact a container for that matter.
847 */ 831 */
848 if (env->type == CONTAINER && can_pick (pl, op) && sack_can_hold (pl, env, op, nrof)) 832 if (env->type == CONTAINER && can_pick (pl, op) && sack_can_hold (pl, env, op, nrof))
849 { 833 {
850 put_object_in_sack (pl, env, op, nrof); 834 put_object_in_sack (pl, env, op, nrof);
851 } 835 }
852} 836}
837

Diff Legend

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