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

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

Diff Legend

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