--- deliantra/server/socket/item.C 2007/04/23 19:10:17 1.44 +++ deliantra/server/socket/item.C 2008/09/08 11:27:25 1.71 @@ -1,25 +1,24 @@ /* - * CrossFire, A Multiplayer game for X-windows - * - * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team - * Copyright (C) 2002 Mark Wedel & Crossfire Development Team - * Copyright (C) 1992 Frank Tore Johansen - * - * This program is free software; you can redistribute it and/or modify + * This file is part of Deliantra, the Roguelike Realtime MMORPG. + * + * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team + * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team + * Copyright (©) 1992,2007 Frank Tore Johansen + * + * Deliantra is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or + * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. - * + * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. - * + * * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - * - * The author can be reached via e-mail to + * along with this program. If not, see . + * + * The authors can be reached via e-mail to */ /** @@ -40,146 +39,6 @@ /** This is the maximum number of bytes we expect any one item to take up */ #define MAXITEMLEN 300 -#if 0 -tag_t -client_container::tag () const -{ - switch (type) - { - case CC_INVENTORY: - return ns->pl->count; - case CC_MAPSPACE: - return 0; - case CC_CONTAINER: - return env->count; - } - - abort (); -} - -void -client_container::clear () -{ - switch (type) - { - case CC_INVENTORY: - abort (); - - case CC_MAPSPACE: - case CC_CONTAINER: - ns->send_packet_printf ("delinv %d", tag ()); - break; - } - - for (iterator i = begin (); i != end (); ++i) - i->op->seen_by = 0; - - vector< refitem, slice_allocator >::clear (); -} - -inline iterator -client_container::merge_item (iterator i, object *op) -{ - if (i != end () && i->op == op) - return ++i; - - if (op->seen_by) - return; // seen by another entity already - - op->seen_by = this; - - refitem ref; - ref.op = op; - - return insert (i, ref); -} - -void -client_container::update (int offset) -{ - iterator i = begin (); - - switch (type) - { - case CC_INVENTORY: - case CC_CONTAINER: - { - object *env = type == CC_INVENTORY - ? ns->pl->ob - : this->env; - - // pass 1, erase all objects no longer in container - for (iterator j = begin (); j != end (); ++j) - if (j->op->env != env) - { - j->op->seen_by = 0; - erase (j); - } - - // pass 2 merge items - for (object *op = env->inv; op; op = op->below) - { - if (--offset < 0) - i = merge_item (i, op); - else if (offset < -FLOORBOX_PAGESIZE) - break; - } - } - break; - - case CC_MAPSPACE: - { - // pass 1, erase all objects no longer on space - for (iterator j = begin (); j != end (); ++j) - if (j->op->x != x || j->op->y != y || j->op->map != map) - { - j->op->seen_by = 0; - erase (j); - } - - // pass 2 merge items - for (object *op = GET_MAP_OB (map, x, y); op; op = op->above) - { - if (--offset < 0) - i = merge_item (i, op); - else if (offset < -FLOORBOX_PAGESIZE) - break; - } - } - break; - } - - // pass 3, erase all extra items - for (iterator j = i; j != end (); ++j) - j->op->seen_by = 0; - - if (i != end ()) - erase (i, end ()); -} - -void -client_container::set_mapspace (maptile *map, int x, int y) -{ - if (type == CC_MAPSPACE - && this->map == map - && this->x == x - && this->y == y) - return; - - clear (); - - type = CC_MAPSPACE; - this->map = map; - this->x = x; - this->y = y; -} - -void -client_container::set_container (object *env) -{ -} -#endif - /******************************************************************************* * * Functions related to sending object data to the client. @@ -196,39 +55,37 @@ unsigned int flags = 0; if (QUERY_FLAG (op, FLAG_APPLIED)) - { - switch (op->type) - { - case BOW: - case WAND: - case ROD: - case HORN: - flags = a_readied; - break; - case WEAPON: - flags = a_wielded; - break; - case SKILL: - case ARMOUR: - case HELMET: - case SHIELD: - case RING: - case BOOTS: - case GLOVES: - case AMULET: - case GIRDLE: - case BRACERS: - case CLOAK: - flags = a_worn; - break; - case CONTAINER: - flags = a_active; - break; - default: - flags = a_applied; - break; - } - } + switch (op->type) + { + case BOW: + case WAND: + case ROD: + case HORN: + flags = a_readied; + break; + case WEAPON: + flags = a_wielded; + break; + case SKILL: + case ARMOUR: + case HELMET: + case SHIELD: + case RING: + case BOOTS: + case GLOVES: + case AMULET: + case GIRDLE: + case BRACERS: + case CLOAK: + flags = a_worn; + break; + case CONTAINER: + flags = a_active; + break; + default: + flags = a_applied; + break; + } if (op->type == CONTAINER && ((op->env && op->env->container == op) || (!op->env && QUERY_FLAG (op, FLAG_APPLIED)))) flags |= F_OPEN; @@ -258,15 +115,14 @@ static void add_object_to_socklist (client &ns, packet &sl, object *head) { - int flags, len, anim_speed; char item_n[MAX_BUF]; const char *item_p; - flags = query_flags (head); + int flags = query_flags (head); if (QUERY_FLAG (head, FLAG_NO_PICK)) flags |= F_NOPICK; - ns.send_face (head->face); + ns.send_face (head->face, -50); ns.flush_fx (); if (QUERY_FLAG (head, FLAG_ANIMATE) && !ns.anims_sent[head->animation_id]) @@ -274,9 +130,11 @@ sl << uint32 (head->count) << uint32 (flags) - << uint32 (QUERY_FLAG (head, FLAG_NO_PICK) ? -1 : WEIGHT (head)) + << uint32 (QUERY_FLAG (head, FLAG_NO_PICK) ? -1 : head->client_weight ()) << uint32 (head->face); + int len; + if (!head->custom_name) { strncpy (item_n, query_base_name (head, 0), 127); @@ -299,148 +157,161 @@ sl << data8 (item_n, len) << uint16 (head->animation_id); - anim_speed = 0; - if (QUERY_FLAG (head, FLAG_ANIMATE)) - { - if (head->anim_speed) - anim_speed = head->anim_speed; - else - { - if (fabs (head->speed) < 0.001) - anim_speed = 255; - else if (fabs (head->speed) >= 1.0) - anim_speed = 1; - else - anim_speed = (int) (1.0 / fabs (head->speed)); - } - - if (anim_speed > 255) - anim_speed = 255; - } + int anim_speed = !head->flag [FLAG_ANIMATE] ? 0 + : head->anim_speed ? clamp (head->anim_speed, 1, 255) + : 1. / clamp (fabs (head->speed), 1./255., 1./1.); sl << uint8 (anim_speed) << uint32 (head->nrof); if (ns.itemcmd == 2) sl << uint16 (head->client_type); +} + +static faceidx +need_face_now (player *pl, const char *name) +{ + faceidx face = face_find (name, empty_face); - SET_FLAG (head, FLAG_CLIENT_SENT); + pl->ns->send_face (face, -50); + pl->ns->flush_fx (); + + return face; } +#define FINGER_UP "finger_up.x11" +#define FINGER_DOWN "finger_down.x11" + /** * Send the look window. Don't need to do animations here * This sends all the faces to the client, not just updates. This is * because object ordering would otherwise be inconsistent. */ void -esrv_draw_look (object *pl) +esrv_draw_look (player *pl) { - int got_one = 0, start_look = 0, end_look = 0; + object *ob = pl->ob; - if (!pl->contr->ns->update_look) + if (!pl->ns->update_look) { - LOG (llevDebug, "esrv_draw_look called when update_look was not set (player %s)\n", &pl->name); + LOG (llevDebug, "esrv_draw_look called when update_look was not set (player %s)\n", &ob->name); return; } - else - pl->contr->ns->update_look = 0; - if (QUERY_FLAG (pl, FLAG_REMOVED) - || !pl->map - || pl->map->in_memory != MAP_IN_MEMORY - || out_of_map (pl->map, pl->x, pl->y)) + pl->ns->update_look = 0; + + if (QUERY_FLAG (ob, FLAG_REMOVED) + || !ob->map + || ob->map->in_memory != MAP_ACTIVE + || out_of_map (ob->map, ob->x, ob->y)) return; - pl->contr->ns->send_packet ("delinv 0"); + pl->ns->send_packet ("delinv 0"); packet sl; - sl.printf ("item%d ", pl->contr->ns->itemcmd); + sl.printf ("item%d ", pl->ns->itemcmd); sl << uint32 (0); - pl->contr->ns->send_face (empty_face); - pl->contr->ns->flush_fx (); + int start_pos = pl->ns->look_position; + bool dirty = false; - if (pl->contr->ns->look_position) - { - char buf[80]; - snprintf (buf, 80, "Apply this to see %d previous items", FLOORBOX_PAGESIZE); + mapspace &ms = ob->ms (); - sl << uint32 (0x80000000 | (pl->contr->ns->look_position - FLOORBOX_PAGESIZE)) - << uint32 (0) - << sint32 (-1) - << uint32 (empty_face) - << data8 (buf) - << uint16 (0) - << uint8 (0) - << uint32 (0); + // manage a ring buffer of the "last FLOORBOX_PAGESIZE" items and + // start from the top + object *items [FLOORBOX_PAGESIZE]; + int item_idx = 0, item_cnt = 0; + int pos = 0; - if (pl->contr->ns->itemcmd == 2) - sl << uint16 (0); - } + // find our items by walking down + object *item = ms.top; - object *tmp = pl->ms ().top; - for (object *last = 0; tmp != last; tmp = tmp->below) + for (; item && item_cnt < FLOORBOX_PAGESIZE; item = item->below) { - object *head; + if (!item->client_visible ()) + continue; + + if (++pos < start_pos) + continue; - if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) && !last) + // record item + items [item_idx] = item; item_idx = item_idx < FLOORBOX_PAGESIZE ? item_idx + 1 : 0; + item_cnt++; + + // stop at first floor + if (item->flag [FLAG_IS_FLOOR]) { - last = tmp->below; /* assumes double floor mode */ - if (last && QUERY_FLAG (last, FLAG_IS_FLOOR)) - last = last->below; + // we are finished, don't append "next group of items" + // by setting item to ms.bot it becomes zero which is checked after the while loop + item = ms.bot; } + } - if (tmp->client_visible ()) - { - if (++start_look < pl->contr->ns->look_position) - continue; + // see if there are more if we cared - we ignore invisible objects + if (item) + { + /* What we basically do is make a 'fake' object - when the user applies it, + * we notice the special tag the object has, and act accordingly. + */ + sl << uint32 (0x80000000 | (start_pos + FLOORBOX_PAGESIZE)) + << uint32 (0) + << uint32 ((uint32) - 1) + << uint32 (need_face_now (pl, FINGER_DOWN)) + << data8 ("Apply this to see the items below") + << uint16 (0) + << uint8 (0) + << uint32 (0); - end_look++; + if (pl->ns->itemcmd == 2) + sl << uint16 (0); - if (end_look > FLOORBOX_PAGESIZE) - { - /* What we basically do is make a 'fake' object - when the user applies it, - * we notice the special tag the object has, and act accordingly. - */ - sl << uint32 (0x80000000 | (pl->contr->ns->look_position + FLOORBOX_PAGESIZE)) - << uint32 (0) - << uint32 ((uint32) - 1) - << uint32 (empty_face) - << data8 ("Apply this to see next group of items") - << uint16 (0) - << uint8 (0) - << uint32 (0); + dirty = true; + } - if (pl->contr->ns->itemcmd == 2) - sl << uint16 (0); + // now send out all items in the ring buffer in reverse order + while (item_cnt) + { + --item_cnt; + item_idx = (item_idx ? item_idx : FLOORBOX_PAGESIZE) - 1; + object *item = items [item_idx]; - break; - } + add_object_to_socklist (*pl->ns, sl, item->head_ ()); - if (tmp->head) - head = tmp->head; - else - head = tmp; + dirty = true; - add_object_to_socklist (*pl->contr->ns, sl, head); - got_one++; + // if packet got too large, send it and begin a new one + if (sl.length () > MAXSOCKBUF - MAXITEMLEN) + { + pl->ns->send_packet (sl); - if (sl.length () >= (MAXSOCKBUF - MAXITEMLEN)) - { - pl->contr->ns->send_packet (sl); + sl.reset (); + sl.printf ("item%d ", pl->ns->itemcmd); + sl << uint32 (0); - sl.reset (); - sl.printf ("item%d ", pl->contr->ns->itemcmd); - sl << uint32 (0); - got_one = 0; - } + dirty = false; } } - if (got_one) - pl->contr->ns->send_packet (sl); + if (start_pos) + { + sl << uint32 (0x80000000 | (start_pos - FLOORBOX_PAGESIZE)) + << uint32 (0) + << sint32 (-1) + << uint32 (need_face_now (pl, FINGER_UP)) + << data8 ("Apply this to see the items higher up") + << uint16 (0) + << uint8 (0) + << uint32 (0); + if (pl->ns->itemcmd == 2) + sl << uint16 (0); + + dirty = true; + } + + if (dirty) + pl->ns->send_packet (sl); } /** @@ -480,7 +351,7 @@ * items (especially with some of the bags out there) to * overflow the buffer. IF so, send multiple item commands. */ - if (sl.length () >= (MAXSOCKBUF - MAXITEMLEN)) + if (sl.length () > MAXSOCKBUF - MAXITEMLEN) { pl->contr->ns->send_packet (sl); @@ -507,35 +378,18 @@ esrv_update_item (int flags, object *pl, object *op) { /* If we have a request to send the player item, skip a few checks. */ - if (op != pl) - { - if (!op->client_visible ()) - return; - /* we remove the check for op->env, because in theory, the object - * is hopefully in the same place, so the client should preserve - * order. - */ - } + if (op != pl && !op->client_visible ()) + return; client *ns = pl->contr->ns; if (!ns) return; - if (!QUERY_FLAG (op, FLAG_CLIENT_SENT)) - { - /* FLAG_CLIENT_SENT is debug only. We are using it to see where - * this is happening - we can set a breakpoint here in the debugger - * and track back the call. - */ - LOG (llevDebug, "We have not sent item %s (%d)\n", &op->name, op->count); - } - packet sl ("upditem"); sl << uint8 (flags); - if (op->head) - op = op->head; + op = op->head_ (); sl << uint32 (op->count); @@ -547,17 +401,17 @@ if (flags & UPD_WEIGHT) { - sint32 weight = WEIGHT (op); - - sl << uint32 (QUERY_FLAG (op, FLAG_NO_PICK) ? -1 : weight); + sint32 weight = op->flag [FLAG_NO_PICK] ? -1 : op->client_weight (); - if (pl == op) + if (op) ns->last_weight = weight; + + sl << uint32 (weight); } if (flags & UPD_FACE) { - ns->send_face (op->face); + ns->send_face (op->face, -50); ns->flush_fx (); sl << uint32 (op->face); } @@ -633,41 +487,25 @@ if (!pl->contr->ns) return; - /* If this is not the player object, do some more checks */ - if (op != pl) - { - /* We only send 'visibile' objects to the client */ - if (!op->client_visible ()) - return; - - /* if the item is on the ground, mark that the look needs to - * be updated. - */ - if (!op->env) - { - pl->contr->ns->floorbox_update (); - return; - } - } + /* We only send 'visible' objects to the client, and sometimes the player */ + if (!op->client_visible () && op->type != PLAYER) + return; packet sl; sl.printf ("item%d ", pl->contr->ns->itemcmd); - if (op->head) - op = op->head; + op = op->head_ (); sl << uint32 (op->env ? op->env->count : 0); add_object_to_socklist (*pl->contr->ns, sl, op); pl->contr->ns->send_packet (sl); - SET_FLAG (op, FLAG_CLIENT_SENT); } /** - * Tells the client to delete an item. Uses the item - * command with a -1 location. + * Tells the client to delete an item. */ void esrv_del_item (player *pl, int tag) @@ -732,6 +570,14 @@ { tag_t tag = atoi (buf); + /* If the high bit is set, player applied a pseudo object. */ + if (tag & 0x80000000) + { + pl->ns->look_position = tag & 0x7fffffff; + pl->ns->floorbox_update (); + return; + } + object *op = esrv_get_ob_from_count (pl->ob, tag); if (!op) @@ -754,7 +600,8 @@ std::string s = op->describe (pl->ob); packet sl ("ex"); - sl << ber32 (tag) << s.c_str (); + sl << ber32 (tag) + << data (*pl->expand_cfpod (s.c_str ())); pl->ns->send_packet (sl); } @@ -766,12 +613,6 @@ { tag_t tag = atoi (buf); - /* sort of a hack, but if the player saves and the player then manually - * applies a savebed (or otherwise tries to do stuff), we run into trouble. - */ - if (QUERY_FLAG (pl->ob, FLAG_REMOVED)) - return; - /* If the high bit is set, player applied a pseudo object. */ if (tag & 0x80000000) { @@ -801,7 +642,7 @@ if (!op) { - new_draw_info (NDI_UNIQUE, 0, pl->ob, "Could not find object to lock/unlock"); + pl->failmsg ("Could not find object to lock/unlock"); return; } @@ -822,12 +663,12 @@ if (!op) { - new_draw_info (NDI_UNIQUE, 0, pl->ob, "Could not find object to mark"); + pl->failmsg ("Could not find object to mark"); return; } pl->mark = op; - new_draw_info_format (NDI_UNIQUE, 0, pl->ob, "Marked item %s", query_name (op)); + pl->ob->statusmsg (format ("Marked item %s", query_name (op))); } /** @@ -836,94 +677,76 @@ * [ removed EARTHWALL check and added check for containers inventory. * Tero.Haatanen@lut.fi ] */ -void -look_at (object *op, int dx, int dy) +static void +look_at (player *pl, int dx, int dy) { - object *tmp; - int flag = 0; - sint16 x, y; - maptile *m; + dynbuf_text buf; + object *ob = pl->ob; - x = op->x + dx; - y = op->y + dy; - - if (out_of_map (op->map, x, y)) - return; - - m = get_map_from_coord (op->map, &x, &y); - if (!m) + if (!pl->observe->map) return; - for (tmp = GET_MAP_OB (m, x, y); tmp && tmp->above; tmp = tmp->above) - ; + mapxy pos (pl->observe); + pos.move (dx, dy); - for (; tmp; tmp = tmp->below) - { - if (tmp->invisible && !QUERY_FLAG (op, FLAG_WIZ)) - continue; + if (pos.normalise ()) + for (object *tmp = pos->top; tmp; tmp = tmp->below) + { + if (tmp->invisible && !QUERY_FLAG (ob, FLAG_WIZ)) + continue; - if (!flag) - { - if (dx || dy) - new_draw_info (NDI_UNIQUE, 0, op, "There you see:"); - else - { - clear_win_info (op); - new_draw_info (NDI_UNIQUE, 0, op, "You see:"); - } - flag = 1; - } + if (QUERY_FLAG (ob, FLAG_WIZ)) + buf.printf (" - %s (%d).\n", query_name (tmp), tmp->count); + else + buf.printf (" - %s.\n", query_name (tmp)); - if (QUERY_FLAG (op, FLAG_WIZ)) - new_draw_info_format (NDI_UNIQUE, 0, op, "- %s (%d).", query_name (tmp), tmp->count); - else - new_draw_info_format (NDI_UNIQUE, 0, op, "- %s.", query_name (tmp)); + object *head = tmp->head_ (); - if (((tmp->inv != NULL || (tmp->head && tmp->head->inv)) && - (tmp->type != CONTAINER && tmp->type != FLESH)) || QUERY_FLAG (op, FLAG_WIZ)) - inventory (op, tmp->head == NULL ? tmp : tmp->head); + if (head->inv) + if ((head->type != CONTAINER && head->type != FLESH) + || QUERY_FLAG (ob, FLAG_WIZ)) + buf << head->query_inventory (ob, " "); - if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) && !QUERY_FLAG (op, FLAG_WIZ)) /* don't continue under the floor */ - break; - } + if (QUERY_FLAG (tmp, FLAG_IS_FLOOR) && !QUERY_FLAG (ob, FLAG_WIZ)) /* don't continue under the floor */ + break; + } - if (!flag) - { - if (dx || dy) - new_draw_info (NDI_UNIQUE, 0, op, "You see nothing there."); - else - new_draw_info (NDI_UNIQUE, 0, op, "You see nothing."); - } + if (buf.empty ()) + pl->failmsg ("You see nothing there."); + else + pl->infobox (MSG_CHANNEL ("lookat"), buf); } /** Client wants to look at some object. Lets do so. */ void LookAt (char *buf, int len, player *pl) { - int dx, dy; char *cp; - dx = atoi (buf); + int dx = atoi (buf); if (!(cp = strchr (buf, ' '))) return; - dy = atoi (cp); - if (fabs (dx) > pl->ns->mapx / 2 || fabs (dy) > pl->ns->mapy / 2) - return; + int dy = atoi (cp); - if (pl->blocked_los[dx + pl->ns->mapx / 2][dy + pl->ns->mapy / 2]) - return; + if (player *opl = pl->observe->contr) + if (client *ns = opl->ns) + { + if (fabs (dx) > ns->mapx / 2 || fabs (dy) > ns->mapy / 2) + return; - look_at (pl->ob, dx, dy); + if (opl->blocked_los[dx + ns->mapx / 2][dy + ns->mapy / 2]) + return; + } + + look_at (pl, dx, dy); } /** Move an object to a new location */ void esrv_move_object (object *pl, tag_t to, tag_t tag, long nrof) { - object *op, *env; - - op = esrv_get_ob_from_count (pl, tag); + object *op = esrv_get_ob_from_count (pl, tag); if (!op) { LOG (llevDebug, "Player '%s' tried to move an unknown object (%ld)\n", &pl->name, tag); @@ -940,15 +763,17 @@ */ if (op->inv && QUERY_FLAG (op, FLAG_APPLIED)) { - object *current, *next; + int cnt = MAX_ITEM_PER_DROP; - for (current = op->inv; current != NULL; current = next) + for (object *current = op->inv; current && cnt--; ) { - next = current->below; + object *next = current->below; drop_object (pl, current, 0); + current = next; } - esrv_update_item (UPD_WEIGHT, pl, op); + if (cnt <= 0) + op->failmsg ("Only dropped some items, can't drop that many items at once."); } else drop_object (pl, op, nrof); @@ -966,7 +791,7 @@ return; } - env = esrv_get_ob_from_count (pl, to); + object *env = esrv_get_ob_from_count (pl, to); if (!env) { LOG (llevDebug, "Player '%s' tried to move object to the unknown location (%d)\n", &pl->name, to); @@ -978,7 +803,9 @@ * in a sack, so check for those things. We should also check * an make sure env is in fact a container for that matter. */ - if (env->type == CONTAINER && can_pick (pl, op) && sack_can_hold (pl, env, op, nrof)) + if (env->type == CONTAINER + && can_pick (pl, op) + && sack_can_hold (pl, env, op, nrof)) put_object_in_sack (pl, env, op, nrof); }