src/hcode/btech/mine.c

Go to the documentation of this file.

/*
 * 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
 */

/*
   Different types of mines:

   1 = Standard round (infinite explosions, same damage, to everyone in hex)
   2 = Inferno        (single explosion, adds heat instead) 
   3 = Command-detonated (single explosion, goes off when hears transmission
   on predefined freq - damages neighbor hexes 1/2)
   4 = Vibra          (single explosion, triggered by weight (setting):
   target<=tons<(target+10) = when stepped on
   (target+10*n)<=tons      = when stepped on n hexes away
   tons<target              = no explosion
 */

#include "copyright.h"
#include "config.h"
#include <math.h>
#include "mech.h"
#include "mine.h"
#include "p.artillery.h"
#include "p.map.obj.h"
#include "p.mine.h"
#include "p.mech.utils.h"
#include "p.btechstats.h"
#include "p.template.h"

/* Different types of mines
 *
 * The Trigger mines are used to let the MUX
 * know if a unit has moved to a certain spot
 * 
 * The others are the explosive do damage kind */
char *mine_type_names[] = {
        "Standard",
        "Inferno",
        "Command",
        "Vibra",
        "Trigger",      
        NULL
};

extern int compare_array(char *[], char *);

void add_mine(MAP * map, int x, int y, int dam)
{
        mapobj *o, foo;

        if(is_mine_hex(map, x, y)) {
                for(o = map->mapobj[TYPE_MINE]; o; o = o->next)
                        if(o->x == x && o->y == y)
                                break;
                if(o)
                        return;
        }
        bzero(&foo, sizeof(foo));
        foo.x = x;
        foo.y = y;
        foo.datas = dam;
        foo.datac = MINE_STANDARD;
        add_mapobj(map, &map->mapobj[TYPE_MINE], &foo, 1);
}

static void mine_damage_mechs(MAP * map, int tx, int ty, char *tomsg,
                                                          char *otmsg, char *tomsg1, char *otmsg1,
                                                          int dam, int heat, int nb)
{
        blast_hit_hexes(map, dam, 5, heat, tx, ty, tomsg, otmsg, tomsg1,
                                        otmsg1, MINE_TABLE, 2, 1, 1, 1);
}

static void update_mine(MAP * map, mapobj * mine)
{
        int i;

        i = mine->datas;
        i = i * MINE_NEXT_MODIFIER;
        if(i >= MINE_MIN)
                mine->datas = i;
}

void make_mine_explode(MECH * mech, MAP * map, mapobj * o, int x, int y,
                                           int reason)
{
        int cool = (o->datas >= MINE_MIN);

        if((o->datac == MINE_TRIGGER)
           && reason != MINE_STEP && reason != MINE_LAND)
                return;
        if(o->datac != MINE_TRIGGER) {
                if(o->datac != MINE_COMMAND) {
                        switch (reason) {
                        case MINE_STEP:
                                MechLOSBroadcast(mech,
                                                                 tprintf
                                                                 ("moves to %d,%d, and triggers a mine!", x,
                                                                  y));
                                mech_printf(mech, MECHALL,
                                                        "As you move to %d,%d, you trigger a mine!", x,
                                                        y);
                                break;
                        case MINE_LAND:
                                MechLOSBroadcast(mech, tprintf("triggers a mine!", x, y));
                                mech_notify(mech, MECHALL, "You trigger a mine!");
                                break;
                        case MINE_DROP:
                        case MINE_FALL:
                                MechLOSBroadcast(mech, tprintf("triggers a mine!", x, y));
                                mech_notify(mech, MECHALL, "You trigger a mine!");
                                break;
                        }
                } else
                        HexLOSBroadcast(map, o->x, o->y, "A mine explodes in $H!");
        }

        switch (o->datac) {
        case MINE_STANDARD:
                update_mine(map, o);
                mine_damage_mechs(map, o->x, o->y, "A blast of shrapnel hits you!",
                                                  "is hit by shrapnel!", NULL, NULL, o->datas, 0, 0);
                if(!cool)
                        mapobj_del(map, o->x, o->y, TYPE_MINE);
                break;
        case MINE_INFERNO:
                update_mine(map, o);
                mine_damage_mechs(map, o->x, o->y, "Globs of flaming gel hit you!",
                                                  "is hit by globs of flaming gel!", NULL, NULL,
                                                  o->datas / 3, o->datas, 0);
                if(!cool)
                        mapobj_del(map, o->x, o->y, TYPE_MINE);
                break;
        case MINE_COMMAND:
                unset_hex_mine(map, o->x, o->y);
                mine_damage_mechs(map, o->x, o->y, "A blast of shrapnel hits you!",
                                                  "is hit by shrapnel!",
                                                  "A little blast of shrapnel hits you!",
                                                  "is hit by some of the shrapnel!", o->datas, 0, 1);
                mapobj_del(map, o->x, o->y, TYPE_MINE);
                break;
        case MINE_TRIGGER:
                SendTrigger(tprintf("#%d %s activated trigger at %d,%d.",
                                                        mech->mynum, GetMechID(mech), o->x, o->y));

                // Trigger the unit's AMECHDEST attribute.
                if(mech->mynum > 0)
                    did_it(mech->mynum, mech->mynum, 0, NULL, 0, NULL, A_AMINETRIGGER, (char **) NULL, 0);
                
                return;
        case MINE_VIBRA:
                unset_hex_mine(map, o->x, o->y);
                if(o->x != x || o->y != y)
                        HexLOSBroadcast(map, o->x, o->y, "A mine explodes in $H!");
                mine_damage_mechs(map, o->x, o->y, "A blast of shrapnel hits you!",
                                                  "is hit by shrapnel!",
                                                  "A little blast of shrapnel hits you!",
                                                  "is hit by some of the shrapnel!", o->datas, 0, 1);
                mapobj_del(map, o->x, o->y, TYPE_MINE);
                break;
        }
        recalculate_minefields(map);
}

/* we find the mine(s) that cause this (vibras can do it long-distance),
   and eliminate it */

static void possible_mine_explosion(MECH * mech, MAP * map, int x, int y,
                                                                        int reason)
{
        mapobj *o, *o2;
        int mdis = (MechRealTons(mech) - 20) / 10;
        float x1, y1, x2, y2, range;

        MapCoordToRealCoord(x, y, &x1, &y1);
        for(o = map->mapobj[TYPE_MINE]; o; o = o2) {

                int real = 1;

                o2 = o->next;
                if(o->x == x && o->y == y) {

                        switch (o->datac) {

                        case MINE_TRIGGER:
                                if(o->datas > MechRealTons(mech))
                                        continue;
                                break;
                        case MINE_VIBRA:
                                if(o->datai > MechRealTons(mech))
                                        continue;       /* No message, just boom */
                                break;
                        case MINE_COMMAND:
                                mech_notify(mech, MECHALL,
                                                        "You spot small bomblets lying on the ground here..");
                                real = 0;
                                continue;
                        }

                        if(!real)
                                return;

                        make_mine_explode(mech, map, o, x, y, reason);

                } else if(VIBRO(o->datac)) {

                        if(o->datac == MINE_TRIGGER) {

                                /* To small let it go */
                                if(o->datas > (MechRealTons(mech)))
                                        continue;

                                MapCoordToRealCoord(o->x, o->y, &x2, &y2);

                                /* Out side of range */
                                /* Using round here because we get some funky ranges like
                                 * 0.999987 and 1.00000072 */
                                if(nearbyintf(FindHexRange(x1, y1, x2, y2)) >
                                   ((float) o->datai))
                                        continue;

                                make_mine_explode(mech, map, o, x, y, reason);

                        } else if(o->datai < MechRealTons(mech)) {

                                if(abs(o->x - x) <= mdis && abs(o->y - y) <= mdis) {

                                        /* Possible remote explosion */
                                        MapCoordToRealCoord(o->x, o->y, &x2, &y2);
                                        if((range = FindHexRange(x1, y1, x2, y2)) >
                                           (MechRealTons(mech) - o->datai) / 10)
                                                continue;

                                        make_mine_explode(mech, map, o, x, y, reason);
                                }
                        }
                }
        }
}

void possible_mine_poof(MECH * mech, int reason)
{
        MAP *map = getMap(mech->mapindex);
        int x = MechX(mech);
        int y = MechY(mech);

        if(!is_mine_hex(map, x, y))
                return;

        if(MechZ(mech) > (MechRTerrain(mech) == ICE ? 0 : Elevation(map, x, y)))
                return;

        possible_mine_explosion(mech, map, x, y, reason);
}

void possibly_remove_mines(MECH * mech, int x, int y)
{
        MAP *map = FindObjectsData(mech->mapindex);

        if(!map)
                return;
        if(!is_mine_hex(map, x, y))
                return;

        /* Do the cleaning stuff here */

        /* Ok, we're lazy and just decide that roll of <= 4 removes
           all traces of mines in the hex */
        if(Roll() <= 4) {
                if(mapobj_del(map, x, y, TYPE_MINE)) {
                        /* There _was_ something to clear.. no message, we're evil */
                        recalculate_minefields(map);
                }
        }
}

/* for now, just put the hexes themselves ; vibras should have larger radius */
/* Added Exile's MINE_TRIGGER changes.  Can set a distance for the
   mine and it will add mines to the hexes within that range - Dany */
static void add_mine_on_map(MAP * map, int x, int y, char type, int data)
{
        int x1, y1;
        int mdis = (100 - data) / 10;
        int t = mdis * 3 / 2;

        if(type == MINE_TRIGGER) {

                float fx, fy, fx1, fy1;

                /* Get the main hex's location in floating values */
                MapCoordToRealCoord(x, y, &fx, &fy);

                /* Loop through all the possible hexes within range
                 * and add mines to those hexes if they are within
                 * range */
                for(x1 = x - data; x1 <= x + data; x1++)
                        for(y1 = y - data; y1 <= y + data; y1++) {

                                /* Check the range, if in range add a mine */
                                /* We round because of weirdness with FindHexRange returning
                                 * values like 1.00215 */
                                MapCoordToRealCoord(x1, y1, &fx1, &fy1);
                                if(nearbyintf(FindHexRange(fx, fy, fx1, fy1)) <=
                                   ((float) data))
                                        set_hex_mine(map, x1, y1);
                        }

        } else if(type >= MINE_LOW && type <= MINE_HIGH) {

                if(VIBRO(type) && mdis) {
                        for(x1 = x - mdis; x1 <= (x + mdis); x1++)
                                for(y1 = y - mdis; y1 <= (y + mdis); y1++)
                                        if((abs(x1 - x) + abs(y1 - y)) <= t)
                                                if(!(x1 < 0 || y1 < 0 || x1 >= map->map_width ||
                                                         y1 >= map->map_height))
                                                        set_hex_mine(map, x1, y1);
                } else {
                        set_hex_mine(map, x, y);
                }
        }
}

/* Re-set all the minefield bits on a map */
void recalculate_minefields(MAP * map)
{
        mapobj *o;

        clear_hex_bits(map, 1);
        for(o = map->mapobj[TYPE_MINE]; o; o = o->next)
                add_mine_on_map(map, o->x, o->y, o->datac, o->datai);
}

/* x y type strength <optvalue> */
void map_add_mine(dbref player, void *data, char *buffer)
{

        char *args[6];
        int argc;
        int x, y, str, type, extra = 0;
        MAP *map = (MAP *) data;
        mapobj foo;

        if(!map)
                return;

#define READINT(from,to) \
    DOCHECK(Readnum(to,from), "Invalid number!")

        argc = mech_parseattributes(buffer, args, 6);
        DOCHECK(argc < 4 || argc > 5, "Invalid arguments!");
        READINT(args[0], x);
        READINT(args[1], y);
        READINT(args[3], str);

        if(argc == 5)
                READINT(args[4], extra);

        DOCHECK((type = compare_array(mine_type_names, args[2])) < 0,
                        "Invalid mine type!");
        DOCHECK(!((x >= 0) && (x < map->map_width) && (y >= 0) &&
                          (y < map->map_height)), "X,Y out of range!");

        bzero(&foo, sizeof(foo));
        foo.x = x;
        foo.y = y;
        foo.datai = extra;
        foo.datas = str;
        foo.datac = type + 1;
        foo.obj = player;
        add_mapobj(map, &map->mapobj[TYPE_MINE], &foo, 1);

        notify_printf(player,
                                  "%s mine added to (%d,%d) (strength: %d / extra: %d)",
                                  mine_type_names[type], x, y, str, extra);
        recalculate_minefields(map);
}

void explode_mines(MECH * mech, int chn)
{
        MAP *map = getMap(mech->mapindex);
        mapobj *o, *o2;
        int count = 0;

        if(!map)
                return;
        for(o = map->mapobj[TYPE_MINE]; o; o = o2) {
                o2 = o->next;
                if(o->datac == MINE_COMMAND)
                        if(o->datai == chn) {
                                make_mine_explode(mech, map, o, 0, 0, 0);
                                count++;
                        }
        }
        if(count)
                recalculate_minefields(map);
}

void show_mines_in_hex(dbref player, MECH * mech, float range, int x, int y)
{
        MAP *map = getMap(mech->mapindex);
        mapobj *o;

        DOCHECK(!is_mine_hex(map, x, y),
                        "You see nothing else of interest in the hex, either.");

        for(o = map->mapobj[TYPE_MINE]; o; o = o->next)
                if(o->x == x && o->y == y)
                        break;

        DOCHECK(!o, "You see nothing else of interest in the hex, either.");
        DOCHECK(Number(2, 9) < ((int) range),
                        "You see nothing else of interest in the hex, either.");
        DOCHECK(!MadePerceptionRoll(mech, 0),
                        "You see nothing else of interest in the hex, either.");
        mech_notify(mech, MECHALL,
                                "Small bomblets litter the hex, interesting... You vaguely "
                                "recall them from some class or other.");
}

---