src/hcode/btech/mine.c File Reference

#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"

Include dependency graph for mine.c:

Go to the source code of this file.

Defines
#define	READINT(from, to)   DOCHECK(Readnum(to,from), "Invalid number!")
Functions
int	compare_array (char *[], char *)
void	add_mine (MAP *map, int x, int y, int dam)
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)
static void	update_mine (MAP *map, mapobj *mine)
void	make_mine_explode (MECH *mech, MAP *map, mapobj *o, int x, int y, int reason)
static void	possible_mine_explosion (MECH *mech, MAP *map, int x, int y, int reason)
void	possible_mine_poof (MECH *mech, int reason)
void	possibly_remove_mines (MECH *mech, int x, int y)
static void	add_mine_on_map (MAP *map, int x, int y, char type, int data)
void	recalculate_minefields (MAP *map)
void	map_add_mine (dbref player, void *data, char *buffer)
void	explode_mines (MECH *mech, int chn)
void	show_mines_in_hex (dbref player, MECH *mech, float range, int x, int y)
Variables
char *	mine_type_names []

---

Define Documentation

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

---

Function Documentation

void add_mine	(	MAP *	map,
		int	x,
		int	y,
		int	dam
	)

Definition at line 52 of file mine.c.

References add_mapobj(), is_mine_hex(), MAP::mapobj, MINE_STANDARD, mapobj_struct::next, TYPE_MINE, mapobj_struct::x, and mapobj_struct::y.

Referenced by artillery_hit_hex().

{
        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 add_mine_on_map	(	MAP *	map,
		int	x,
		int	y,
		char	type,
		int	data
	)			[static]

Definition at line 285 of file mine.c.

References FindHexRange(), MAP::map_height, MAP::map_width, MapCoordToRealCoord(), MINE_HIGH, MINE_LOW, MINE_TRIGGER, set_hex_mine(), and VIBRO.

Referenced by recalculate_minefields().

{
        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);
                }
        }
}

int compare_array	(	char *	[],
		char *
	)

Definition at line 1194 of file template.c.

Referenced by BuildBitVector(), BuildBitVectorNoErr(), BuildBitVectorWithDelim(), CheckSpecialsList(), debug_makemechs(), find_section(), fun_btmakemechs(), load_template(), map_add_mine(), mechMovefunc(), and mechTypefunc().

{
        int x;

        if(!list)
                return -1;
        for(x = 0; list[x]; x++)
                if(!strcasecmp(list[x], command))
                        return x;

        return -1;
}

void explode_mines	(	MECH *	mech,
		int	chn
	)

Definition at line 383 of file mine.c.

References mapobj_struct::datac, mapobj_struct::datai, getMap(), make_mine_explode(), MECH::mapindex, MAP::mapobj, MINE_COMMAND, mapobj_struct::next, recalculate_minefields(), and TYPE_MINE.

{
        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 make_mine_explode	(	MECH *	mech,
		MAP *	map,
		mapobj *	o,
		int	x,
		int	y,
		int	reason
	)

Definition at line 89 of file mine.c.

References A_AMINETRIGGER, mapobj_struct::datac, mapobj_struct::datas, did_it(), GetMechID(), HexLOSBroadcast(), mapobj_del(), mech_notify(), mech_printf(), MECHALL, MechLOSBroadcast(), MINE_COMMAND, mine_damage_mechs(), MINE_DROP, MINE_FALL, MINE_INFERNO, MINE_LAND, MINE_MIN, MINE_STANDARD, MINE_STEP, MINE_TRIGGER, MINE_VIBRA, MECH::mynum, recalculate_minefields(), SendTrigger, tprintf(), TYPE_MINE, unset_hex_mine(), update_mine(), mapobj_struct::x, and mapobj_struct::y.

Referenced by explode_mines(), and possible_mine_explosion().

{
        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);
}

void map_add_mine	(	dbref	player,
		void *	data,
		char *	buffer
	)

Definition at line 339 of file mine.c.

References add_mapobj(), args, compare_array(), DOCHECK, MAP::mapobj, mech_parseattributes(), mine_type_names, notify_printf(), READINT, recalculate_minefields(), TYPE_MINE, x, and y.

{

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

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
	)			[static]

Definition at line 71 of file mine.c.

References blast_hit_hexes(), and MINE_TABLE.

Referenced by make_mine_explode().

{
        blast_hit_hexes(map, dam, 5, heat, tx, ty, tomsg, otmsg, tomsg1,
                                        otmsg1, MINE_TABLE, 2, 1, 1, 1);
}

static void possible_mine_explosion	(	MECH *	mech,
		MAP *	map,
		int	x,
		int	y,
		int	reason
	)			[static]

Definition at line 173 of file mine.c.

References mapobj_struct::datac, mapobj_struct::datai, mapobj_struct::datas, FindHexRange(), make_mine_explode(), MapCoordToRealCoord(), MAP::mapobj, mech_notify(), MECHALL, MechRealTons, MINE_COMMAND, MINE_TRIGGER, MINE_VIBRA, mapobj_struct::next, TYPE_MINE, VIBRO, mapobj_struct::x, and mapobj_struct::y.

Referenced by possible_mine_poof().

{
        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
	)

Definition at line 246 of file mine.c.

References Elevation, getMap(), ICE, is_mine_hex(), MECH::mapindex, MechRTerrain, MechX, MechY, MechZ, possible_mine_explosion(), x, and y.

Referenced by aero_land(), LandMech(), mech_drop(), MechFalls(), and NewHexEntered().

{
        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
	)

Definition at line 261 of file mine.c.

References FindObjectsData(), is_mine_hex(), MECH::mapindex, mapobj_del(), recalculate_minefields(), Roll(), and TYPE_MINE.

Referenced by possibly_clear().

{
        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);
                }
        }
}

void recalculate_minefields

(

MAP *

map

)

Definition at line 329 of file mine.c.

References add_mine_on_map(), clear_hex_bits(), mapobj_struct::datac, mapobj_struct::datai, MAP::mapobj, mapobj_struct::next, TYPE_MINE, mapobj_struct::x, and mapobj_struct::y.

Referenced by explode_mines(), load_update3(), make_mine_explode(), map_add_mine(), and possibly_remove_mines().

{
        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);
}

void show_mines_in_hex	(	dbref	player,
		MECH *	mech,
		float	range,
		int	x,
		int	y
	)

Definition at line 403 of file mine.c.

References DOCHECK, getMap(), is_mine_hex(), MadePerceptionRoll(), MECH::mapindex, MAP::mapobj, mech_notify(), MECHALL, mapobj_struct::next, Number, TYPE_MINE, mapobj_struct::x, and mapobj_struct::y.

Referenced by mech_scan().

{
        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.");
}

static void update_mine	(	MAP *	map,
		mapobj *	mine
	)			[static]

Definition at line 79 of file mine.c.

References mapobj_struct::datas, MINE_MIN, and MINE_NEXT_MODIFIER.

Referenced by make_mine_explode().

{
        int i;

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

---

Variable Documentation

char* mine_type_names[]

Initial value:

 {
        "Standard",
        "Inferno",
        "Command",
        "Vibra",
        "Trigger",      
        NULL
}

Definition at line 41 of file mine.c.

Referenced by map_add_mine().

---