server/socket/item.C


/*
 * static char *rcsid_item_c =
 *    "$Id: item.C,v 1.1 2006-08-13 17:16:06 elmex Exp $";
 */

/*
    CrossFire, A Multiplayer game for X-windows

    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
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 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
    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 crossfire-devel@real-time.com
*/

/**
 * \file
 * Client/server logic.
 *
 * \date 2003-12-02
 *
 * This containes item logic for client/server.  It doesn't contain
 * the actual commands that send the data, but does contain
 * the logic for what items should be sent.
 */


#include <global.h>
#include <object.h>     /* LOOK_OBJ */
#include <newclient.h>
#include <newserver.h>
#include <sproto.h>

/** This is the maximum number of bytes we expect any one item to take up */
#define MAXITEMLEN  300

/*******************************************************************************
 *
 * Functions related to sending object data to the client.
 *
 ******************************************************************************/

/**
 * Adds string to socklist.
 *
 * This is a simple function that we use a lot here.  It basically
 * adds the specified buffer into the socklist, but prepends a
 * single byte in length.  If the data is longer than that byte, it is
 * truncated approprately.
 */
inline void add_stringlen_to_sockbuf(const char *buf, SockList *sl)
{
    int len;

    len=strlen(buf);
    if (len>255) len=255;
    SockList_AddChar(sl, (char) len);
    strncpy((char*)sl->buf+sl->len, buf,len);
    sl->len += len;
}

/**
 *  This is a similar to query_name, but returns flags
 *  to be sended to client. 
 */
unsigned int query_flags (object *op)
{
    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;
        }
    }
    if (op->type == CONTAINER && ((op->env && op->env->container == op) || 
        (!op->env && QUERY_FLAG(op,FLAG_APPLIED))))
        flags |= F_OPEN;
    
    if (QUERY_FLAG(op,FLAG_KNOWN_CURSED)) {
        if(QUERY_FLAG(op,FLAG_DAMNED))
            flags |= F_DAMNED;
        else if(QUERY_FLAG(op,FLAG_CURSED))
            flags |= F_CURSED;
    }
    if (QUERY_FLAG(op,FLAG_KNOWN_MAGICAL) && !QUERY_FLAG(op,FLAG_IDENTIFIED))
        flags |= F_MAGIC;
    if (QUERY_FLAG(op,FLAG_UNPAID))
        flags |= F_UNPAID;
    if (QUERY_FLAG(op,FLAG_INV_LOCKED))
        flags |= F_LOCKED;

    return flags;
}

/* Used in the send_look to put object head into SockList
 * sl for socket ns.  Need socket to know if we need to send
 * animation of face to the client.
 */
static void add_object_to_socklist(NewSocket *ns, SockList *sl, object *head)
{
    int flags, len, anim_speed;
    char item_n[MAX_BUF];
    const char *item_p;

    flags = query_flags (head);
    if (QUERY_FLAG(head, FLAG_NO_PICK))
        flags |=  F_NOPICK;

    if (!(ns->faces_sent[head->face->number] & NS_FACESENT_FACE))
        esrv_send_face(ns, head->face->number,0);

    if (QUERY_FLAG(head,FLAG_ANIMATE) && !ns->anims_sent[head->animation_id])
        esrv_send_animation(ns, head->animation_id);

    SockList_AddInt(sl, head->count);
    SockList_AddInt(sl, flags);
    SockList_AddInt(sl, QUERY_FLAG(head, FLAG_NO_PICK) ? -1 : WEIGHT(head));
    SockList_AddInt(sl, head->face->number);

    if (!head->custom_name) {
        strncpy(item_n,query_base_name(head, 0),127);
        item_n[127]=0;
        len=strlen(item_n);
        item_p=query_base_name(head, 1);
    } else {
        strncpy(item_n,head->custom_name,127);
        item_n[127]=0;
        len=strlen(item_n);
        item_p=head->custom_name;
    }
    strncpy(item_n+len+1, item_p, 127);
    item_n[254]=0;
    len += strlen(item_n+1+len) + 1;
    SockList_AddChar(sl, (char ) len);
    memcpy(sl->buf+sl->len, item_n, len);
    sl->len += len;

    SockList_AddShort(sl,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;
    }
    SockList_AddChar(sl, (char) anim_speed);
    SockList_AddInt(sl, head->nrof);

    if (ns->itemcmd == 2)
        SockList_AddShort(sl, head->client_type);

    SET_FLAG(head, FLAG_CLIENT_SENT);
}


/**
 * 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)
{
    object *tmp, *last;
    int got_one=0,start_look=0, end_look=0;
    SockList sl;
    char buf[MAX_BUF];

    if (!pl->contr->socket.update_look) {
        LOG(llevDebug,"esrv_draw_look called when update_look was not set\n");
        return;
    } else {
        pl->contr->socket.update_look=0;
    }

    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))
            return;

    for (tmp=get_map_ob(pl->map,pl->x,pl->y); tmp && tmp->above;tmp=tmp->above) ;

    sl.buf= (unsigned char *) malloc(MAXSOCKBUF);

    Write_String_To_Socket(&pl->contr->socket, "delinv 0", strlen("delinv 0"));
    sprintf((char*)sl.buf,"item%d ", pl->contr->socket.itemcmd);
    sl.len=strlen((char*)sl.buf);

    SockList_AddInt(&sl, 0);

    if (!(pl->contr->socket.faces_sent[empty_face->number]&NS_FACESENT_FACE))
        esrv_send_face(&pl->contr->socket, empty_face->number,0);

    if (pl->contr->socket.look_position) {
        SockList_AddInt(&sl, 0x80000000 | (pl->contr->socket.look_position- NUM_LOOK_OBJECTS));
        SockList_AddInt(&sl, 0);
        SockList_AddInt(&sl, (uint32) -1);
        SockList_AddInt(&sl, empty_face->number);
        sprintf(buf,"Click here to see %d previous items", NUM_LOOK_OBJECTS);
        add_stringlen_to_sockbuf(buf, &sl);
        SockList_AddShort(&sl,0);
        SockList_AddChar(&sl, 0);
        SockList_AddInt(&sl, 0);
        if (pl->contr->socket.itemcmd == 2)
            SockList_AddShort(&sl, 0);
    }

    for (last=NULL; tmp!=last; tmp=tmp->below) {
        object *head;

        if (QUERY_FLAG(tmp, FLAG_IS_FLOOR) && !last) {
            last = tmp->below;  /* assumes double floor mode */
            if (last && QUERY_FLAG(last, FLAG_IS_FLOOR))
                last = last->below;
        }
        if (LOOK_OBJ(tmp)) {
            if (++start_look < pl->contr->socket.look_position) continue;
            end_look++;
            if (end_look > NUM_LOOK_OBJECTS) {
                /* 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.
                 */
                SockList_AddInt(&sl, 0x80000000 | (pl->contr->socket.look_position+ NUM_LOOK_OBJECTS));
                SockList_AddInt(&sl, 0);
                SockList_AddInt(&sl, (uint32) -1);
                SockList_AddInt(&sl, empty_face->number);
                sprintf(buf,"Click here to see next group of items");
                add_stringlen_to_sockbuf(buf, &sl);
                SockList_AddShort(&sl,0);
                SockList_AddChar(&sl, 0);
                SockList_AddInt(&sl, 0);
                if (pl->contr->socket.itemcmd == 2)
                    SockList_AddShort(&sl, 0);
                break;
            }
            if (tmp->head) head = tmp->head;
            else head = tmp;

            add_object_to_socklist(&pl->contr->socket, &sl, head);
            got_one++;

            if (sl.len >= (MAXSOCKBUF-MAXITEMLEN)) {
                Send_With_Handling(&pl->contr->socket, &sl);
                sprintf((char*)sl.buf,"item%d ", pl->contr->socket.itemcmd);
                sl.len=strlen((char*)sl.buf);
                SockList_AddInt(&sl, 0);
                got_one=0;
            }
        } /* If LOOK_OBJ() */
    }
    if (got_one)
        Send_With_Handling(&pl->contr->socket, &sl);

    free(sl.buf);
}

/**
 * Sends whole inventory.
 */
void esrv_send_inventory(object *pl, object *op)
{
    object *tmp;
    int got_one=0;
    SockList sl;
    
    sl.buf= (unsigned char *) malloc(MAXSOCKBUF);

    sprintf((char*)sl.buf,"delinv %d", op->count);
    sl.len=strlen((char*)sl.buf);
    Send_With_Handling(&pl->contr->socket, &sl);

    sprintf((char*)sl.buf,"item%d ", pl->contr->socket.itemcmd);
    sl.len=strlen((char*)sl.buf);

    SockList_AddInt(&sl, op->count);
    
    for (tmp=op->inv; tmp; tmp=tmp->below) {
        object *head;

        if (tmp->head) head = tmp->head;
        else head = tmp;

        if (LOOK_OBJ(head)) {
            add_object_to_socklist(&pl->contr->socket, &sl, head);
        
            got_one++;

            /* IT is possible for players to accumulate a huge amount of
             * items (especially with some of the bags out there) to
             * overflow the buffer.  IF so, send multiple item commands.
             */
            if (sl.len >= (MAXSOCKBUF-MAXITEMLEN)) {
                Send_With_Handling(&pl->contr->socket, &sl);
                sprintf((char*)sl.buf,"item%d ", pl->contr->socket.itemcmd);
                sl.len=strlen((char*)sl.buf);
                SockList_AddInt(&sl, op->count);
                got_one=0;
            }
        } /* If LOOK_OBJ() */
    }
    if (got_one)
        Send_With_Handling(&pl->contr->socket, &sl);
    free(sl.buf);
}

/**
 * Updates object *op for player *pl.
 *
 * flags is a list of values to update
 * to the client (as defined in newclient.h - might as well use the
 * same value both places.
 */

void esrv_update_item(int flags, object *pl, object *op)
{
    SockList sl;

    /* If we have a request to send the player item, skip a few checks. */
    if (op!=pl) {
        if (! LOOK_OBJ(op)) 
            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 (!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);
    }
    sl.buf= (unsigned char *) malloc(MAXSOCKBUF);

    strcpy((char*)sl.buf,"upditem ");
    sl.len=strlen((char*)sl.buf);

    SockList_AddChar(&sl, (char) flags);

    if (op->head) op=op->head;

    SockList_AddInt(&sl, op->count);

    if (flags & UPD_LOCATION)
        SockList_AddInt(&sl, op->env? op->env->count:0);

    if (flags & UPD_FLAGS)
        SockList_AddInt(&sl, query_flags(op));

    if (flags & UPD_WEIGHT) {
        sint32 weight = WEIGHT(op);

        SockList_AddInt(&sl,  QUERY_FLAG(op, FLAG_NO_PICK) ? -1 : weight);
        if (pl == op) {
            op->contr->last_weight = weight;
        }
    }

    if (flags & UPD_FACE) {
        if (!(pl->contr->socket.faces_sent[op->face->number] & NS_FACESENT_FACE))
            esrv_send_face(&pl->contr->socket, op->face->number,0);
        SockList_AddInt(&sl, op->face->number);
    }
    if (flags & UPD_NAME) {
        int len;
        const char *item_p;
    char item_n[MAX_BUF];

        if (!op->custom_name) {
            strncpy(item_n,query_base_name(op, 0),127);
            item_n[127]=0;
            len=strlen(item_n);
            item_p=query_base_name(op, 1);
        }
        else {
            strncpy(item_n,op->custom_name,127);
            item_n[127]=0;
            len=strlen(item_n);
            item_p=op->custom_name;
        }

        strncpy(item_n+len+1, item_p, 127);
        item_n[254]=0;
        len += strlen(item_n+1+len) + 1;
        SockList_AddChar(&sl, (char)len);
        memcpy(sl.buf+sl.len, item_n, len);
        sl.len += len;
    }
    if (flags & UPD_ANIM) 
            SockList_AddShort(&sl,op->animation_id);

    if (flags & UPD_ANIMSPEED) {
        int anim_speed=0;
        if (QUERY_FLAG(op,FLAG_ANIMATE)) {
            if (op->anim_speed) anim_speed=op->anim_speed;
            else {
                if (FABS(op->speed)<0.001) anim_speed=255;
                else if (FABS(op->speed)>=1.0) anim_speed=1;
                else anim_speed = (int) (1.0/FABS(op->speed));
            }
            if (anim_speed>255) anim_speed=255;
        }
        SockList_AddChar(&sl, (char)anim_speed);
    }
    if (flags & UPD_NROF)
            SockList_AddInt(&sl, op->nrof);

    Send_With_Handling(&pl->contr->socket, &sl);
    free(sl.buf);
}

/**
 * Sends item's info to player.
 */
void esrv_send_item(object *pl, object*op)
{
    SockList sl;
    
    /* If this is not the player object, do some more checks */
    if (op!=pl) {
        /* We only send 'visibile' objects to the client */
        if (! LOOK_OBJ(op)) 
            return;
        /* if the item is on the ground, mark that the look needs to
         * be updated.
         */
        if (!op->env) {
            pl->contr->socket.update_look=1;
            return;
        }
    }

    sl.buf= (unsigned char *) malloc(MAXSOCKBUF);

    sprintf((char*)sl.buf,"item%d ", pl->contr->socket.itemcmd);
    sl.len=strlen((char*)sl.buf);

    if (op->head) op=op->head;

    SockList_AddInt(&sl, op->env? op->env->count:0);

    add_object_to_socklist(&pl->contr->socket, &sl, op);

    Send_With_Handling(&pl->contr->socket, &sl);
    SET_FLAG(op, FLAG_CLIENT_SENT);
    free(sl.buf);
}

/**
 * Tells the client to delete an item.  Uses the item
 * command with a -1 location.
 */

void esrv_del_item(player *pl, int tag)
{
    SockList sl;

    sl.buf= (unsigned char *) malloc(MAXSOCKBUF);

    strcpy((char*)sl.buf,"delitem ");
    sl.len=strlen((char*)sl.buf);
    SockList_AddInt(&sl, tag);

    Send_With_Handling(&pl->socket, &sl);
    free(sl.buf);
}


/*******************************************************************************
 *
 * Client has requested us to do something with an object.
 *
 ******************************************************************************/

/**
 * Takes a player and object count (tag) and returns the actual object
 * pointer, or null if it can't be found.
 */

object *esrv_get_ob_from_count(object *pl, tag_t count)
{
    object *op, *tmp;

    if (pl->count == count)
        return pl;

    for(op = pl->inv; op; op = op->below)
        if (op->count == count)
            return op;
        else if (op->type == CONTAINER && pl->container == op)
            for(tmp = op->inv; tmp; tmp = tmp->below)
                if (tmp->count == count)
                    return tmp;

    for(op = get_map_ob (pl->map, pl->x, pl->y); op; op = op->above)
        if (op->head != NULL && op->head->count == count)
            return op;
        else if (op->count == count)
            return op;
        else if (op->type == CONTAINER && pl->container == op)
            for(tmp = op->inv; tmp; tmp = tmp->below)
                if (tmp->count == count)
                    return tmp;

    return NULL;
}


/** Client wants to examine some object.  So lets do so. */
void ExamineCmd(char *buf, int len,player *pl)
{
    long tag = atoi(buf);
    object *op = esrv_get_ob_from_count(pl->ob, tag);

    if (!op) {
        LOG(llevDebug, "Player '%s' tried to examine the unknown object (%ld)\n",
            pl->ob->name, tag);
        return;
    }
    examine (pl->ob, op);
}

/** Client wants to apply some object.  Lets do so. */
void ApplyCmd(char *buf, int len,player *pl)
{
    uint32 tag = atoi(buf);
    object *op = esrv_get_ob_from_count(pl->ob, tag);

    /* 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) {
        pl->socket.look_position = tag & 0x7fffffff;
        pl->socket.update_look = 1;
        return;
    }

    if (!op) {
        LOG(llevDebug, "Player '%s' tried to apply the unknown object (%d)\n",
          pl->ob->name, tag);
        return;
    }
    player_apply (pl->ob, op, 0, 0);
}

/** Client wants to apply some object.  Lets do so. */
void LockItem(uint8 *data, int len,player *pl)
{
    int flag, tag;
    object *op;

    flag = data[0];
    tag = GetInt_String(data+1);
    op = esrv_get_ob_from_count(pl->ob, tag);

    if (!op) {
        new_draw_info(NDI_UNIQUE, 0, pl->ob,"Could not find object to lock/unlock");
        return;
    }
    if (!flag)
        CLEAR_FLAG(op,FLAG_INV_LOCKED);
    else
        SET_FLAG(op,FLAG_INV_LOCKED);
    esrv_update_item(UPD_FLAGS, pl->ob, op);
}

/** Client wants to apply some object.  Lets do so. */
void MarkItem(uint8 *data, int len,player *pl)
{
    int tag;
    object *op;

    tag = GetInt_String(data);
    op = esrv_get_ob_from_count(pl->ob, tag);
    if (!op) {
        new_draw_info(NDI_UNIQUE, 0, pl->ob,"Could not find object to mark");
        return;
    }
    pl->mark = op;
    pl->mark_count = op->count;
    new_draw_info_format(NDI_UNIQUE, 0, pl->ob, "Marked item %s", query_name(op));
}


/**
 * look_at prints items on the specified square.
 *
 * [ removed EARTHWALL check and added check for containers inventory.
 *   Tero.Haatanen@lut.fi ]
 */
void look_at(object *op,int dx,int dy) {
    object *tmp;
    int flag=0;
    sint16 x,y;
    mapstruct *m;

    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) return;

    for(tmp=get_map_ob(m, x ,y);tmp!=NULL&&tmp->above!=NULL;
            tmp=tmp->above);

    for ( ; tmp != NULL; tmp=tmp->below ) {
         if (tmp->invisible && !QUERY_FLAG(op, 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(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));

         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(QUERY_FLAG(tmp, FLAG_IS_FLOOR)&&!QUERY_FLAG(op, 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.");
    }
}


/** 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);
    if (!(cp=strchr(buf,' '))) {
        return;
    }
    dy=atoi(cp);

    if (FABS(dx) > pl->socket.mapx / 2 || FABS(dy) > pl->socket.mapy / 2)
          return;

    if(pl->blocked_los[dx + pl->socket.mapx / 2][dy + pl->socket.mapy / 2])
          return;

    look_at(pl->ob, 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);
    if (!op) {
        LOG(llevDebug, "Player '%s' tried to move an unknown object (%ld)\n",
            pl->name, tag);
        return;
    }

    if (!to) {  /* drop it to the ground */
/*      LOG(llevDebug, "Drop it on the ground.\n");*/

        if (op->map && !op->env) {
/*          LOG(llevDebug,"Dropping object to ground that is already on ground\n");*/
            return;
        }
        /* If it is an active container, then we should drop all objects
         * in the container and not the container itself.
         */
        if (op->inv && QUERY_FLAG(op, FLAG_APPLIED)) {
            object *current, *next;
            for (current=op->inv; current!=NULL; current=next) {
                next=current->below;
                drop_object(pl, current, 0);
            }
            esrv_update_item(UPD_WEIGHT, pl, op);
        }
        else {
            drop_object (pl, op, nrof);
        }
        return;
    } else if (to == pl->count) {     /* pick it up to the inventory */
        /* return if player has already picked it up */
        if (op->env == pl) return;

        pl->contr->count = nrof;
        pick_up(pl, op);
        return ;
    }
    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);
        return;
    }
    /* put_object_in_sack presumes that necessary sanity checking
     * has already been done (eg, it can be picked up and fits in
     * 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)) {
        put_object_in_sack (pl, env, op, nrof);
    }
}


Revision:	1.2
Committed:	Tue Aug 29 07:34:01 2006 UTC (17 years, 9 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.1:	+18 -46 lines
Log Message:	nuke transports