src/hcode/btech/map.dynamic.c

Go to the documentation of this file.

/*
 * $Id: map.dynamic.c,v 1.1.1.1 2005/01/11 21:18:08 kstevens Exp $
 *
 * Author: Markus Stenberg <fingon@iki.fi>
 *
 *  Copyright (c) 1996 Markus Stenberg
 *  Copyright (c) 1998-2002 Thomas Wouters
 *  Copyright (c) 2000-2002 Cord Awtry
 *       All rights reserved
 *
 * Created: Sun Oct 13 19:38:31 1996 fingon
 * Last modified: Sun Jun 14 14:54:11 1998 fingon
 *
 */

#include <stdio.h>

#include "create.h"
#include "mech.h"
#include "autopilot.h"
#include "p.econ_cmds.h"
#include "p.mech.restrict.h"
#include "p.mech.utils.h"
#include "p.map.conditions.h"

#define DYNAMIC_MAGIC 42

/* Code for saving / loading / setting / unsetting the dynamic pieces
   of map structure:
   - mechsOnMap
   - LOSinfo
   - mechflags
   */

#define CHELO(a,b,c,d) if (!(ugly_kludge++)) { \
    if ((tmp=fread(a,b,c,d)) != c) { fprintf (stderr, "Error loading mapdynamic for #%d - couldn't find enough entries! (found: %d, should: %d)\n", map->mynum, tmp, c); return; } } else { if ((tmp=fread(a,b,c,d)) != c) { fprintf (stderr, "Error loading mapdynamic for #%d - couldn't find enough entries! (found: %d, should: %d)\n", map->mynum, tmp, c); fflush(stderr); exit(1); } }
#define CHESA(a,b,c,d) if ((tmp=fwrite(a,b,c,d)) != c) { fprintf (stderr, "Error writing mapdynamic for #%d - couldn't find enough entries! (found: %d, should: %d)\n", map->mynum, tmp, c); fflush(stderr); exit(1); }

static int ugly_kludge = 0;             /* Nonfatal for _first_ */

void load_mapdynamic(FILE * f, MAP * map)
{
        int count = map->first_free;
        int i, tmp;
        unsigned char tmpb;

        if(count > 0) {
                Create(map->mechsOnMap, dbref, count);

                CHELO(map->mechsOnMap, sizeof(map->mechsOnMap[0]), count, f);
                Create(map->mechflags, char, count);

                CHELO(map->mechflags, sizeof(map->mechflags[0]), count, f);
                Create(map->LOSinfo, unsigned short *, count);

                for(i = 0; i < count; i++) {
                        Create(map->LOSinfo[i], unsigned short, count);

                        CHELO(map->LOSinfo[i], sizeof(map->LOSinfo[i][0]), count, f);
                }
        } else {
                map->mechsOnMap = NULL;
                map->mechflags = NULL;
                map->LOSinfo = NULL;
        }
        CHELO(&tmpb, 1, 1, f);
        if(tmpb != DYNAMIC_MAGIC) {
                fprintf(stderr, "Error reading data for obj #%d (%d != %d)!\n",
                                map->mynum, tmpb, DYNAMIC_MAGIC);
                fflush(stderr);
                exit(1);
        }
}

#define outbyte(a) tmpb=(a);CHESA(&tmpb, 1, 1, f);

void save_mapdynamic(FILE * f, MAP * map)
{
        int count = map->first_free;
        int i, tmp;
        unsigned char tmpb;

        if(count > 0) {
                CHESA(map->mechsOnMap, sizeof(map->mechsOnMap[0]), count, f);
                CHESA(map->mechflags, sizeof(map->mechflags[0]), count, f);
                for(i = 0; i < count; i++)
                        CHESA(map->LOSinfo[i], sizeof(map->LOSinfo[i][0]), count, f);
        }
        outbyte(DYNAMIC_MAGIC);
}

void mech_map_consistency_check(MECH * mech)
{
        MAP *map = getMap(mech->mapindex);

        if(!map) {
                if(mech->mapindex > 0) {
                        mech->mapindex = -1;
                        fprintf(stderr, "#%d on nonexistent map - removing..\n",
                                        mech->mynum);
                }
                return;
        }
        if(map->first_free <= mech->mapnumber) {
                /* Invalid: possible corruption of data, therefore un-hosing it */
                mech->mapindex = -1;
                mech_remove_from_all_maps(mech);
                fprintf(stderr, "#%d on invalid map - removing.. (#1)\n",
                                mech->mynum);
                return;
        }
        if(map->mechsOnMap[mech->mapnumber] != mech->mynum) {
                fprintf(stderr, "#%d on invalid map - removing .. (#2) -- mapindex: %d mapnumber: %d mechsOnMap: %d\n",
                                mech->mynum, mech->mapindex, mech->mapnumber, map->mechsOnMap[mech->mapnumber]);
                mech->mapindex = -1;
                mech_remove_from_all_maps(mech);
                return;
        }
        mech_remove_from_all_maps_except(mech, map->mynum);
}

void eliminate_empties(MAP * map)
{
        int i;
        int j;
        int count, oldcount;
        char tempbuf[SBUF_SIZE];

        if(!map)
                return;
        for(i = map->first_free - 1; i >= 0; i--)
                if(map->mechsOnMap[i] > 0)
                        break;
        count = i + 1;
        if(count == (oldcount = map->first_free))
                return;
        fprintf(stderr,
                        "Map #%d contains empty entries ; removing %d (%d->%d)\n",
                        map->mynum, oldcount - count, oldcount, count);
        if(i < 0)
                return;
        for(j = count; j < oldcount; j++)
                free((void *) map->LOSinfo[j]);
        ReCreate(map->LOSinfo, unsigned short *, count);

        ReCreate(map->mechsOnMap, dbref, count);
        ReCreate(map->mechflags, char, count);

        map->first_free = count;
        sprintf(tempbuf, "%d", map->mynum);
        mech_Rfixstuff(GOD, NULL, tempbuf);
}

void remove_mech_from_map(MAP * map, MECH * mech)
{
        int loop = map->first_free;

        clear_mech_from_LOS(mech);
        mech->mapindex = -1;
        if(map->first_free <= mech->mapnumber ||
           map->mechsOnMap[mech->mapnumber] != mech->mynum) {
                SendError(tprintf
                                  ("Map indexing error for mech #%d: Map index %d contains data for #%d instead.",
                                   mech->mynum, mech->mapnumber,
                                   map->mechsOnMap ? map->mechsOnMap[mech->mapnumber] : -1));
                if(map->mechsOnMap)
                        for(loop = 0;
                                (loop < map->first_free) &&
                                (map->mechsOnMap[loop] != mech->mynum); loop++);
        } else
                loop = mech->mapnumber;
        mech->mapnumber = 0;
        if(loop != (map->first_free)) {
                map->mechsOnMap[loop] = -1;     /* clear it */
                map->mechflags[loop] = 0;
#if 0
                for(i = 0; i < map->first_free; i++)
                        if(map->mechsOnMap[i] > 0 && i != loop)
                                if((t = getMech(map->mechsOnMap[i])))
                                        if(MechTeam(t) != MechTeam(mech) &&
                                           (map->LOSinfo[i][loop] & MECHLOSFLAG_SEEN)) {
                                                MechNumSeen(t) = MAX(0, MechNumSeen(t) - 1);
                                        }
#endif
                if(loop == (map->first_free - 1))
                        map->first_free--;      /* Who cares about some lost memory? In realloc
                                                                   we'll gain it back anyway */
        }
        if(Towed(mech)) {
                /* Check that the towing guy isn't left on the map */
                int i;
                MECH *t;

                for(i = 0; i < map->first_free; i++)
                        /* Release from towing if tow-guy ain't on same map already */
                        if((t = FindObjectsData(map->mechsOnMap[i])))
                                if(MechCarrying(t) == mech->mynum) {
                                        SetCarrying(t, -1);
                                        MechStatus(mech) &= ~TOWED;     /* Reset the Towed flag */
                                        break;
                                }
        }
        MechNumSeen(mech) = 0;
        if(IsDS(mech))
                SendDSInfo(tprintf("DS #%d has left map #%d", mech->mynum,
                                                   map->mynum));

}

void add_mech_to_map(MAP * newmap, MECH * mech)
{
        int loop, count, i;

        for(loop = 0; loop < newmap->first_free; loop++)
                if(newmap->mechsOnMap[loop] == mech->mynum)
                        break;
        if(loop != newmap->first_free)
                return;
        for(loop = 0; loop < newmap->first_free; loop++)
                if(newmap->mechsOnMap[loop] < 0)
                        break;
        if(loop == newmap->first_free) {
                newmap->first_free++;
                count = newmap->first_free;
                ReCreate(newmap->mechsOnMap, dbref, count);
                ReCreate(newmap->mechflags, char, count);
                ReCreate(newmap->LOSinfo, unsigned short *, count);

                newmap->LOSinfo[count - 1] = NULL;
                for(i = 0; i < count; i++) {
                        ReCreate(newmap->LOSinfo[i], unsigned short, count);

                        newmap->LOSinfo[i][loop] = 0;
                }
                for(i = 0; i < count; i++)
                        newmap->LOSinfo[loop][i] = 0;
        }
        mech->mapindex = newmap->mynum;
        mech->mapnumber = loop;
        newmap->mechsOnMap[loop] = mech->mynum;
        newmap->mechflags[loop] = 0;

        /* Is there an autopilot */
        if(MechAuto(mech) > 0) {

                AUTO *a = FindObjectsData(MechAuto(mech));

                /* Reset the AI's comtitle */
                if(a)
                        auto_set_comtitle(a, mech);
        }

        if(Towed(mech)) {
                int i;
                MECH *t;

                for(i = 0; i < newmap->first_free; i++)
                        /* Release from towing if tow-guy ain't on same map already */
                        if((t = FindObjectsData(newmap->mechsOnMap[i])))
                                if(MechCarrying(t) == mech->mynum)
                                        break;
                if(i == newmap->first_free)
                        MechStatus(mech) &= ~TOWED;     /* Reset the Towed flag */
        }
        MarkForLOSUpdate(mech);
        UnZombifyMech(mech);
        UpdateConditions(mech, newmap);
        if(IsDS(mech))
                SendDSInfo(tprintf("DS #%d has entered map #%d", mech->mynum,
                                                   newmap->mynum));
}

int mech_size(MAP * map)
{
        return map->first_free * (sizeof(dbref) + sizeof(char) +
                                                          sizeof(unsigned short *) +
                                                          map->first_free * sizeof(unsigned short));
}

---