src/hcode/btech/p.artillery.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
int	artillery_round_flight_time (float fx, float fy, float tx, float ty)
void	artillery_shoot (MECH *mech, int targx, int targy, int windex, int wmode, int ishit)
void	blast_hit_hexf (MAP *map, int dam, int singlehitsize, int heatdam, float fx, float fy, float tfx, float tfy, char *tomsg, char *otmsg, int table, int safeup, int safedown, int isunderwater)
void	blast_hit_hex (MAP *map, int dam, int singlehitsize, int heatdam, int fx, int fy, int tx, int ty, char *tomsg, char *otmsg, int table, int safeup, int safedown, int isunderwater)
void	blast_hit_hexesf (MAP *map, int dam, int singlehitsize, int heatdam, float fx, float fy, float ftx, float fty, char *tomsg, char *otmsg, char *tomsg1, char *otmsg1, int table, int safeup, int safedown, int isunderwater, int doneighbors)
void	blast_hit_hexes (MAP *map, int dam, int singlehitsize, int heatdam, int tx, int ty, char *tomsg, char *otmsg, char *tomsg1, char *otmsg1, int table, int safeup, int safedown, int isunderwater, int doneighbors)
void	artillery_FriendlyAdjustment (dbref mechnum, MAP *map, int x, int y)

---

Function Documentation

void artillery_FriendlyAdjustment	(	dbref	mechnum,
		MAP *	map,
		int	x,
		int	y
	)

Definition at line 410 of file artillery.c.

References find_mech_in_hex(), getMech(), GetMechToMechID(), artillery_shot_type::map, mech_printf(), MechFireAdjustment, MechSeesHex(), MechSpotter, MECHSTARTED, MechTargX, MechTargY, and Started.

Referenced by artillery_hit().

{
        MECH *mech;
        MECH *spotter;
        MECH *tempMech = NULL;

        if(!(mech = getMech(mechnum)))
                return;
        /* Ok.. we've a valid guy */
        spotter = getMech(MechSpotter(mech));
        if(!((MechTargX(mech) == x && MechTargY(mech) == y)
                 || (spotter && (MechTargX(spotter) == x &&
                                                 MechTargY(spotter) == y))))
                return;
        /* Ok.. we've a valid target to adjust fire on */
        /* Now, see if we've any friendlies in LOS.. NOTE: FRIENDLIES ;-) */
        if(spotter) {
                if(MechSeesHex(spotter, map, x, y))
                        tempMech = spotter;
        } else
                tempMech = find_mech_in_hex(mech, map, x, y, 2);
        if(!tempMech)
                return;
        if(!Started(tempMech) || !Started(mech))
                return;
        if(spotter) {
                mech_printf(mech, MECHSTARTED,
                                        "%s sent you some trajectory-correction data.",
                                        GetMechToMechID(mech, tempMech));
                mech_printf(tempMech, MECHSTARTED,
                                        "You provide %s with information about the miss.",
                                        GetMechToMechID(tempMech, mech));
        }
        MechFireAdjustment(mech)++;
}

int artillery_round_flight_time	(	float	fx,
		float	fy,
		float	tx,
		float	ty
	)

Definition at line 81 of file artillery.c.

References ARTILLERY_MINIMUM_FLIGHT, ARTY_SPEED, FindHexRange(), and MAX.

Referenced by artillery_shoot(), and mech_snipe_func().

{
        int delay = MAX(ARTILLERY_MINIMUM_FLIGHT,
                                        (FindHexRange(fx, fy, tx, ty) / ARTY_SPEED));

        /* XXX Different weapons, diff. speed? */
        return delay;
}

void artillery_shoot	(	MECH *	mech,
		int	targx,
		int	targy,
		int	windex,
		int	wmode,
		int	ishit
	)

Definition at line 98 of file artillery.c.

References artillery_direction(), artillery_hit_event(), artillery_round_flight_time(), artillery_type(), Create, EVENT_DHIT, free_shot_list, artillery_shot_type::from_x, artillery_shot_type::from_y, artillery_shot_type::ishit, artillery_shot_type::map, MapCoordToRealCoord(), MECH::mapindex, MechLOSBroadcast(), MechX, MechY, artillery_shot_type::mode, muxevent_add(), MECH::mynum, artillery_shot_type::next, artillery_shot_type::shooter, artillery_shot_type::to_x, artillery_shot_type::to_y, tprintf(), and artillery_shot_type::type.

{
        struct artillery_shot_type *s;
        float fx, fy, tx, ty;

        if(free_shot_list) {
                s = free_shot_list;
                free_shot_list = free_shot_list->next;
        } else
                Create(s, artillery_shot, 1);
        s->from_x = MechX(mech);
        s->from_y = MechY(mech);
        s->to_x = targx;
        s->to_y = targy;
        s->type = windex;
        s->mode = wmode;
        s->ishit = ishit;
        s->shooter = mech->mynum;
        s->map = mech->mapindex;
        MechLOSBroadcast(mech, tprintf("shoots %s towards %s!",
                                                                   artillery_type(s),
                                                                   artillery_direction(s)));
        MapCoordToRealCoord(s->from_x, s->from_y, &fx, &fy);
        MapCoordToRealCoord(s->to_x, s->to_y, &tx, &ty);
        muxevent_add(artillery_round_flight_time(fx, fy, tx, ty), 0, EVENT_DHIT,
                                 artillery_hit_event, (void *) s, NULL);
}

void blast_hit_hex	(	MAP *	map,
		int	dam,
		int	singlehitsize,
		int	heatdam,
		int	fx,
		int	fy,
		int	tx,
		int	ty,
		char *	tomsg,
		char *	otmsg,
		int	table,
		int	safeup,
		int	safedown,
		int	isunderwater
	)

Definition at line 230 of file artillery.c.

References blast_hit_hexf(), artillery_shot_type::map, and MapCoordToRealCoord().

Referenced by artillery_hit_hex().

{
        float ftx, fty;
        float ffx, ffy;

        MapCoordToRealCoord(tx, ty, &ftx, &fty);
        MapCoordToRealCoord(fx, fy, &ffx, &ffy);
        blast_hit_hexf(map, dam, singlehitsize, heatdam, ffx, ffy, ftx, fty,
                                   tomsg, otmsg, table, safeup, safedown, isunderwater);
}

void blast_hit_hexes	(	MAP *	map,
		int	dam,
		int	singlehitsize,
		int	heatdam,
		int	tx,
		int	ty,
		char *	tomsg,
		char *	otmsg,
		char *	tomsg1,
		char *	otmsg1,
		int	table,
		int	safeup,
		int	safedown,
		int	isunderwater,
		int	doneighbors
	)

Definition at line 303 of file artillery.c.

References blast_hit_hexesf(), artillery_shot_type::map, and MapCoordToRealCoord().

Referenced by bomb_hit_hexes(), and mine_damage_mechs().

{
        float fx, fy;

        MapCoordToRealCoord(tx, ty, &fx, &fy);
        blast_hit_hexesf(map, dam, singlehitsize, heatdam, fx, fy, fx, fy,
                                         tomsg, otmsg, tomsg1, otmsg1, table, safeup, safedown,
                                         isunderwater, doneighbors);
}

void blast_hit_hexesf	(	MAP *	map,
		int	dam,
		int	singlehitsize,
		int	heatdam,
		float	fx,
		float	fy,
		float	ftx,
		float	fty,
		char *	tomsg,
		char *	otmsg,
		char *	tomsg1,
		char *	otmsg1,
		int	table,
		int	safeup,
		int	safedown,
		int	isunderwater,
		int	doneighbors
	)

Definition at line 243 of file artillery.c.

References add_decoration(), blast_hit_hexf(), BOUNDED(), find_decorations(), FindXYRange(), FIRE, FIRE_DURATION, GetRTerrain, HEAVY_FOREST, LIGHT_FOREST, artillery_shot_type::map, MapCoordToRealCoord(), MAX, MyHexDist(), RealCoordToMapCoord(), and TYPE_FIRE.

Referenced by blast_hit_hexes(), DS_BlastNearbyMechsAndTrees(), and reactor_explosion().

{
        int x1, y1, x2, y2;
        int dm;
        short tx, ty;
        float hx, hy;
        float t = FindXYRange(fx, fy, ftx, fty);

        dm = MAX(1, (int) t + 1);
        blast_hit_hexf(map, dam / dm, singlehitsize, heatdam / dm, fx, fy, ftx,
                                   fty, tomsg, otmsg, table, safeup, safedown, isunderwater);
        if(!doneighbors)
                return;
        RealCoordToMapCoord(&tx, &ty, fx, fy);
        for(x1 = (tx - doneighbors); x1 <= (tx + doneighbors); x1++)
                for(y1 = (ty - doneighbors); y1 <= (ty + doneighbors); y1++) {
                        int spot;

                        if((dm = MyHexDist(tx, ty, x1, y1, 0)) > doneighbors)
                                continue;
                        if((tx == x1) && (ty == y1))
                                continue;
                        x2 = BOUNDED(0, x1, map->map_width - 1);
                        y2 = BOUNDED(0, y1, map->map_height - 1);
                        if(x1 != x2 || y1 != y2)
                                continue;
                        spot = (x1 == tx && y1 == ty);
                        MapCoordToRealCoord(x1, y1, &hx, &hy);
                        dm++;
                        if(!(dam / dm))
                                continue;
                        blast_hit_hexf(map, dam / dm, singlehitsize, heatdam / dm, hx,
                                                   hy, ftx, fty, spot ? tomsg : tomsg1,
                                                   spot ? otmsg : otmsg1, table, safeup, safedown,
                                                   isunderwater);

                        /*
                         * Added in burning woods when a mech's engine goes nova
                         *
                         * -Kipsta
                         * 8/4/99
                         */

                        switch (GetRTerrain(map, x1, y1)) {
                        case LIGHT_FOREST:
                        case HEAVY_FOREST:
                                if(!find_decorations(map, x1, y1)) {
                                        add_decoration(map, x1, y1, TYPE_FIRE, FIRE,
                                                                   FIRE_DURATION);
                                }

                                break;
                        }
                }
}

void blast_hit_hexf	(	MAP *	map,
		int	dam,
		int	singlehitsize,
		int	heatdam,
		float	fx,
		float	fy,
		float	tfx,
		float	tfy,
		char *	tomsg,
		char *	otmsg,
		int	table,
		int	safeup,
		int	safedown,
		int	isunderwater
	)

Definition at line 146 of file artillery.c.

References BACK, blast_arcf(), CLASS_MECH, DamageMech(), Elevation, FindHitLocation(), FindKickLocation(), FindObjectsData(), FindPunchLocation(), heat_effect(), artillery_shot_type::map, MAX, mech_notify(), MECHALL, MechLOSBroadcast(), MechType, MechX, MechY, MechZ, RealCoordToMapCoord(), TABLE_KICK, and TABLE_PUNCH.

Referenced by blast_hit_hex(), and blast_hit_hexesf().

{
        MECH *tempMech;
        int loop;
        int isrear = 0, iscritical = 0, hitloc;
        int damleft, arc, ndam;
        int ground_zero;
        short tx, ty;

        /* Not on a map so just return */
        if(!map)
                return;

        RealCoordToMapCoord(&tx, &ty, fx, fy);
        if(tx < 0 || ty < 0 || tx >= map->map_width || ty >= map->map_height)
                return;
        if(!tomsg || !otmsg)
                return;
        if(isunderwater)
                ground_zero = Elevation(map, tx, ty);
        else
                ground_zero = MAX(0, Elevation(map, tx, ty));

        for(loop = 0; loop < map->first_free; loop++)
                if(map->mechsOnMap[loop] >= 0) {
                        tempMech = (MECH *)
                                FindObjectsData(map->mechsOnMap[loop]);
                        if(!tempMech)
                                continue;
                        if(MechX(tempMech) != tx || MechY(tempMech) != ty)
                                continue;
                        /* Far too high.. */
                        if(MechZ(tempMech) >= (safeup + ground_zero))
                                continue;
                        /* Far too below (underwater, mostly) */
                        if(                                     /* MechTerrain(tempMech) == WATER &&  */
                                  MechZ(tempMech) <= (ground_zero - safedown))
                                continue;
                        MechLOSBroadcast(tempMech, otmsg);
                        mech_notify(tempMech, MECHALL, tomsg);
                        arc = blast_arcf(tfx, tfy, tempMech);

                        if(arc == BACK)
                                isrear = 1;
                        damleft = dam;

                        while (damleft > 0) {
                                if(singlehitsize <= damleft)
                                        ndam = singlehitsize;
                                else
                                        ndam = damleft;

                                damleft -= ndam;

                                switch (table) {
                                case TABLE_PUNCH:
                    if (MechType(tempMech) != CLASS_MECH) {
                        hitloc = FindHitLocation(tempMech, arc, &iscritical, &isrear);
                    } else {
                        hitloc = FindPunchLocation(tempMech, arc);
                    }
                                        break;
                                case TABLE_KICK:
                    if (MechType(tempMech) != CLASS_MECH) {
                        hitloc = FindHitLocation(tempMech, arc, &iscritical, &isrear);
                    } else {
                        hitloc = FindKickLocation(tempMech, arc);
                    }
                                        break;
                                default:
                                        hitloc =
                                                FindHitLocation(tempMech, arc, &iscritical, &isrear);
                                }

                                DamageMech(tempMech, tempMech, 0, -1, hitloc, isrear,
                                                   iscritical, ndam, 0, -1, 0, -1, 0, 0);
                        }
                        heat_effect(NULL, tempMech, heatdam, 0);
                }
}

---