src/hcode/btech/p.mech.los.h File Reference

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

Go to the source code of this file.

Functions
float	ActualElevation (MAP *map, int x, int y, MECH *mech)
int	CalculateLOSFlag (MECH *mech, MECH *target, MAP *map, int x, int y, int ff, float hexRange)
int	AddTerrainMod (MECH *mech, MECH *target, MAP *map, float hexRange, int wAmmoMode)
int	InLineOfSight_NB (MECH *mech, MECH *target, int x, int y, float hexRange)
int	InLineOfSight (MECH *mech, MECH *target, int x, int y, float hexRange)
void	mech_losemit (dbref player, MECH *mech, char *buffer)

---

Function Documentation

float ActualElevation	(	MAP *	map,
		int	x,
		int	y,
		MECH *	mech
	)

Definition at line 35 of file mech.los.c.

References CLASS_DS, CLASS_MECH, Elevation, Fallen, IsDS, MechDugIn, MechMove, MechType, MechZ, and MOVE_NONE.

Referenced by CalculateLOSFlag().

{

        if(!map)
                return 0.0;
        if(!mech)
                return (float) (Elevation(map, x, y) + 0.1);
        if(MechType(mech) == CLASS_MECH && !Fallen(mech))
                return (float) MechZ(mech) + 1.5;
        else if(MechMove(mech) == MOVE_NONE)
                return (float) MechZ(mech) + 1.5;
        else if(IsDS(mech))
                return (float) MechZ(mech) + 2.5 + (MechType(mech) ==
                                                                                        CLASS_DS ? 0 : 2);
        if(MechDugIn(mech))
                return (float) MechZ(mech) + 0.1;
        return (float) MechZ(mech) + 0.5;
}

int AddTerrainMod	(	MECH *	mech,
		MECH *	target,
		MAP *	map,
		float	hexRange,
		int	wAmmoMode
	)

Definition at line 282 of file mech.los.c.

References MECHLOSFLAG_PARTIAL, MechStatus, MechToMech_LOSFlag, PARTIAL_COVER, and Sensor_ToHitBonus().

Referenced by FindNormalBTH(), and FireSpot().

{
        /* Possibly do a quickie check only */
        if(mech && target) {
                if(MechToMech_LOSFlag(map, mech, target) & MECHLOSFLAG_PARTIAL)
                        MechStatus(target) |= PARTIAL_COVER;
                else
                        MechStatus(target) &= ~PARTIAL_COVER;

                return Sensor_ToHitBonus(mech, target,
                                                                 MechToMech_LOSFlag(map, mech, target),
                                                                 map->maplight, hexRange, wAmmoMode);
        }
        return 0;
}

int CalculateLOSFlag	(	MECH *	mech,
		MECH *	target,
		MAP *	map,
		int	x,
		int	y,
		int	ff,
		float	hexRange
	)

Definition at line 60 of file mech.los.c.

References AA_TECH, ActualElevation(), BOUNDED(), BRIDGE, CLASS_MECH, Elevation, Fallen, FIRE, GetRTerrain, GetTerrain, HEAVY_FOREST, HIGHWATER, ICE, InWater, IsWater, LIGHT_FOREST, MAP::map_height, MAP::map_width, MAP::maxvis, MECHLOSFLAG_BLOCK, MECHLOSFLAG_FIRE, MECHLOSFLAG_MNTN, MECHLOSFLAG_PARTIAL, MECHLOSFLAG_SEEC2, MECHLOSFLAG_SEEN, MECHLOSFLAG_SMOKE, MECHLOSFLAG_WATER, MECHLOSFLAG_WOOD, MECHLOSMAX_WATER, MECHLOSMAX_WOOD, MechMove, MechRTerrain, MechSpecials, MechType, MechX, MechY, MechZ, MOUNTAINS, MOVE_HOVER, SMOKE, TraceLOS(), WATER, WaterBeast, and lostrace_info::y.

Referenced by InLineOfSight(), and update_LOSinfo().

{
        int new_flag = (ff & (MECHLOSFLAG_SEEN)) + MECHLOSFLAG_SEEC2;
        int woods_count = 0;
        int water_count = 0;
        int height, i;
        int pos_x, pos_y;
        float pos_z, z_inc, end_z;
        int terrain;
        int dopartials = 0;
        int underwater, bothworlds, t_underwater, t_bothworlds;
        int uwatercount = 0, coordcount;
        lostrace_info *coords;

#ifndef BT_PARTIAL
        float partial_z, p_z_inc;
#endif

        /* A Hex target off the map? Don't bother */
        if(!target && ((x < 0 || y < 0 || x >= map->map_width ||
                                        y >= map->map_height)))
                return new_flag + MECHLOSFLAG_BLOCK;

        /* Outside max sensor range in the worst case? Don't bother. */
        if(hexRange > (((MechSpecials(mech) & AA_TECH) || (target &&
                                                                                                           (MechSpecials(target) &
                                                                                                                AA_TECH))) ? 180 :
                                   map->maxvis))
                return new_flag + MECHLOSFLAG_BLOCK;

        /* We start at (MechX(mech), MechY(mech)) and wind up at (x,y) */
        pos_x = MechX(mech);
        pos_y = MechY(mech);
        pos_z = ActualElevation(map, pos_x, pos_y, mech);
        end_z = ActualElevation(map, x, y, target);

/* Definition of 'both worlds': According to FASA, if a mech is half
   submerged, or a sub is surfaced, or any naval or hover is on top
   of the water, it can see in both the underwater and overwater 'worlds'.
   In other words, it'll never get a block from the water/air interface.
   Neither will anything get such a block against it. That's what the
   'both worlds' variables test for. */

        if(end_z > 10 && pos_z > 10)
                return new_flag;
        bothworlds = IsWater(MechRTerrain(mech)) &&     /* Can we be in both worlds? */
                (((MechType(mech) == CLASS_MECH) && (MechZ(mech) == -1)) ||
                 ((WaterBeast(mech)) && (MechZ(mech) == 0)) ||
                 ((MechMove(mech) == MOVE_HOVER) && (MechZ(mech) == 0)));
        underwater = InWater(mech) && (pos_z < 0.0);

        /* Ice hex targeting special case */
        if(!target && !underwater && GetRTerrain(map, x, y) == ICE)
                end_z = 0.0;

        if(target) {
                /* What about him? Both worlds? Or flat out underwater? */
                t_bothworlds = IsWater(MechRTerrain(target)) &&
                        (((MechType(target) == CLASS_MECH) && (MechZ(target) == -1)) ||
                         ((WaterBeast(target)) && (MechZ(target) == 0)) ||
                         ((MechMove(target) == MOVE_HOVER) && (MechZ(target) == 0)));

                t_underwater = InWater(target) && (end_z < 0.0);
        } else {
                if(GetRTerrain(map, x, y) == ICE)
                        t_bothworlds = 1;
                else
                        t_bothworlds = 0;
                t_underwater = (end_z < 0.0);   /* Is the hex underwater? */
        }

        /* And now we look once more to make sure we aren't wasting our time */
        if(((underwater) && !(t_underwater)) ||
           ((t_underwater) && !(underwater))) {
                return new_flag + MECHLOSFLAG_BLOCK;
        }

        /* Worth our time to mess with figuring partial cover? */
        if(target && mech)
                dopartials = (MechType(target) == CLASS_MECH) && (!Fallen(target));

        /*Same hex is always LoS */
        if((x == pos_x) && (y == pos_y))
                return new_flag;

        /* Special cases are out of the way, looks like we have to do actual work. */
        coordcount = TraceLOS(map, pos_x, pos_y, x, y, &coords);
        if(coordcount > 0) {
                z_inc = (float) (end_z - pos_z) / coordcount;
        } else {
                z_inc = 0;                              /* In theory, this should never happen. */
        }

#ifndef BT_PARTIAL
        partial_z = 0;
        p_z_inc = (float) 1 / coordcount;
#endif

        if(coordcount > 0) {            /* not in same hex ; in same hex, you see always */
                for(i = 0; i < coordcount; i++) {
                        pos_z += z_inc;
#ifndef BT_PARTIAL
                        partial_z += p_z_inc;
#endif
                        if(coords[i].x < 0 || coords[i].x >= map->map_width ||
                           coords[i].y < 0 || coords[i].y >= map->map_height)
                                continue;
                        /* Should be possible to see into water.. perhaps. But not
                           on vislight */
                        terrain = GetRTerrain(map, coords[i].x, coords[i].y);
                        /* get the current height */
                        height = Elevation(map, coords[i].x, coords[i].y);

/* If you, persoanlly, are underwater, the only way you can see someone
   if if they are underwater or in both worlds AND your LoS passes thru
   nothing but water hexes AND your LoS doesn't go thru the sea floor */
                        if(underwater) {

/* LoS hits sea floor */
                                if(!(IsWater(terrain)) || (terrain != BRIDGE &&
                                                                                   height >= pos_z)) {
                                        new_flag |= MECHLOSFLAG_BLOCK;
                                        return new_flag;
                                }

/* LoS pops out of water, AND we're not tracing to half-submerged mech's head */
                                if(!t_bothworlds && pos_z > 0.0) {
                                        new_flag |= MECHLOSFLAG_BLOCK;
                                        return new_flag;
                                }

/* uwatercount = # hexes LoS travel UNDERWATER */
                                if(pos_z <= 0.0)
                                        uwatercount++;
                                water_count++;
                        } else {                        /* Viewer is not underwater */
                                /* keep track of how many wooded hexes we cross */
                                if(pos_z < (height + 2)) {
                                        switch (GetTerrain(map, coords[i].x, coords[i].y)) {
                                        case SMOKE:
                                                if(i < coordcount - 1)
                                                        new_flag |= MECHLOSFLAG_SMOKE;
                                                break;
                                        case FIRE:
                                                if(i < coordcount - 1)
                                                        new_flag |= MECHLOSFLAG_FIRE;
                                                break;
                                        }
                                        switch (terrain) {
                                        case LIGHT_FOREST:
                                        case HEAVY_FOREST:
                                                if(i < coordcount - 1)
                                                        woods_count += (terrain == LIGHT_FOREST) ? 1 : 2;
                                                break;
                                        case HIGHWATER:
                                                water_count++;
                                                break;
                                        case ICE:
                                                if(pos_z < -0.0) {
                                                        new_flag |= MECHLOSFLAG_BLOCK;
                                                        return new_flag;
                                                }
                                                water_count++;
                                                break;
                                        case WATER:

/* LoS goes INTO water and we're not tracing to a target in both worlds */
                                                if(!bothworlds && (pos_z < 0.0)) {
                                                        new_flag |= MECHLOSFLAG_BLOCK;
                                                        return new_flag;
                                                }

/* Hexes in LoS that are phsyically underwater */
                                                if(pos_z < 0.0)
                                                        uwatercount++;
                                                water_count++;
                                                break;
                                        case MOUNTAINS:
                                                if(i < coordcount - 1)
                                                        new_flag |= MECHLOSFLAG_MNTN;
                                                break;
                                        }
                                }
                                /* make this the new 'current hex' */
                                if(height >= pos_z && terrain != BRIDGE) {
                                        new_flag |= MECHLOSFLAG_BLOCK;
                                        return new_flag;
                                }
#ifndef BT_PARTIAL
                                else if(dopartials && height >= (pos_z - partial_z))
                                        new_flag |= MECHLOSFLAG_PARTIAL;
#endif
                        }
                }
        }
        /* Then, we check the hex before target hex */
#ifdef BT_PARTIAL
        if(coordcount >= 2)
                if(dopartials) {
                        if(MechZ(target) >= MechZ(mech) &&
                           (Elevation(map, coords[coordcount - 2].x,
                                                  coords[coordcount - 2].y) == (MechZ(target) + 1)))
                                new_flag |= MECHLOSFLAG_PARTIAL;
                        if(MechZ(target) == -1 && MechRTerrain(target) == WATER)
                                new_flag |= MECHLOSFLAG_PARTIAL;
                }
#endif

        water_count = BOUNDED(0, water_count, MECHLOSMAX_WATER - 1);
        woods_count = BOUNDED(0, woods_count, MECHLOSMAX_WOOD - 1);
        new_flag += MECHLOSFLAG_WOOD * woods_count;
        new_flag += MECHLOSFLAG_WATER * water_count;

/* Block EM after 2, Vis/IR after 6 */
        if(uwatercount > 2)
                new_flag |= MECHLOSFLAG_MNTN;
        if(uwatercount > 6)
                new_flag |= MECHLOSFLAG_FIRE;
        return new_flag;
}

int InLineOfSight	(	MECH *	mech,
		MECH *	target,
		int	x,
		int	y,
		float	hexRange
	)

Definition at line 312 of file mech.los.c.

References CalculateLOSFlag(), CLAIRVOYANT, MAP::cloudbase, getMap(), InWeaponArc(), MAP::LOSinfo, MAP::map_height, MAP::map_width, MapCoordToRealCoord(), MECH::mapindex, MAP::maplight, MECH::mapnumber, MAP::mapvis, mech_notify(), MechCritStatus, MechFX, MechFY, MECHLOSFLAG_BLOCK, MECHLOSFLAG_SEEN, MECHLOSFLAG_SEESP, MECHLOSFLAG_SEESS, MECHPILOT, MechToMech_LOSFlag, MECH::mynum, SendError, Sensor_CanSee(), and tprintf().

Referenced by auto_radio_command_report(), DisplayTarget(), find_mech_in_hex(), findC3RangeWithNetwork(), FireSpot(), fun_btlosm2m(), InLineOfSight_NB(), mech_attachcables(), mech_bearing(), mech_c3_join_leave(), mech_c3i_join_leave(), mech_contacts(), mech_detachcables(), mech_embark(), mech_hide_event(), mech_jump(), mech_lock_event(), mech_pickup(), mech_radio(), mech_range(), mech_report(), mech_scan(), mech_settarget(), mech_spot(), mech_vector(), mech_view(), MechFireBroadcast(), MechLOSBroadcast(), MechLOSBroadcasti(), mechSeenByNetwork(), MechSeesHexF(), navigate_sketch_mechs(), parse_tacargs(), ScrambleInfraAndLiteAmp(), show_lrs_map(), showNetworkTargets(), and sketch_tac_mechs().

{
        MAP *map;
        float x1, y1;
        int arc;
        int losflag;

        map = getMap(mech->mapindex);
        if(!map) {
                mech_notify(mech, MECHPILOT,
                                        "You are on an invalid map! Map index reset!");
                SendError(tprintf("InLineOfSight:invalid map:Mech %d  Index %d",
                                                  mech->mynum, mech->mapindex));
                mech->mapindex = -1;
                return 0;
        }
        if(x < 0 || y < 0 || y >= map->map_height || x >= map->map_width) {
                SendError(tprintf("x:%d y:%d out of bounds for #%d (LOS check)", x,
                                                  y, mech ? mech->mynum : -1));
        }

        /* Possibly do a quickie check only */
        if(MechCritStatus(mech) & CLAIRVOYANT)
                return 1;

        if(target) {
                x1 = MechFX(target);
                y1 = MechFY(target);
        } else
                MapCoordToRealCoord(x, y, &x1, &y1);
        arc = InWeaponArc(mech, x1, y1);

        if(mech && target) {
#ifndef ADVANCED_LOS
                losflag = MechToMech_LOSFlag(map, mech, target);
                if(Sensor_CanSee(mech, target, &losflag, arc, hexRange, map->mapvis,
                                                 map->maplight, map->cloudbase)) {
                        map->LOSinfo[mech->mapnumber][target->mapnumber] |=
                                (MECHLOSFLAG_SEEN | MECHLOSFLAG_SEESP | MECHLOSFLAG_SEESS);
                        return 1;
                } else {
                        map->LOSinfo[mech->mapnumber][target->mapnumber] &=
                                ~(MECHLOSFLAG_SEEN | MECHLOSFLAG_SEESP | MECHLOSFLAG_SEESS);
                        return 0;
                }
#else
                if(MechToMech_LOSFlag(map, mech, target) & (MECHLOSFLAG_SEESP |
                                                                                                        MECHLOSFLAG_SEESS))
                        return MechToMech_LOSFlag(map, mech, target) &
                                (MECHLOSFLAG_SEESP | MECHLOSFLAG_SEESS | MECHLOSFLAG_BLOCK);
#endif
                return 0;
        }
        losflag = CalculateLOSFlag(mech, NULL, map, x, y, 0, hexRange);
        return Sensor_CanSee(mech, NULL, &losflag, arc, hexRange, map->mapvis,
                                                 map->maplight, map->cloudbase);
}

int InLineOfSight_NB	(	MECH *	mech,
		MECH *	target,
		int	x,
		int	y,
		float	hexRange
	)

Definition at line 299 of file mech.los.c.

References InLineOfSight(), and MECHLOSFLAG_BLOCK.

Referenced by checkTAG(), FindBSuitTarget(), fun_bthexlos(), fun_btid2db(), fun_btlosm2m(), GetMechToMechID(), mech_charge(), mech_contacts(), mech_report(), mech_scan(), mech_tag(), mech_view(), mechSeenByNetwork(), PhysicalAttack(), showNetworkTargets(), and SwarmHitTarget().

{
        int i;

        if(mech == target)
                return 1;

        i = InLineOfSight(mech, target, x, y, hexRange);
        if(i & MECHLOSFLAG_BLOCK)
                return 0;
        return i;
}

void mech_losemit	(	dbref	player,
		MECH *	mech,
		char *	buffer
	)

Definition at line 370 of file mech.los.c.

References cch, MECH_USUALSP, MechLOSBroadcast(), and notify.

{
        cch(MECH_USUALSP);
        MechLOSBroadcast(mech, buffer);
        notify(player, "Broadcast done.");
}

---