#include <stdio.h>#include <stdlib.h>#include <math.h>#include <sys/file.h>#include "mech.h"#include "failures.h"#include "mech.events.h"#include "mech.ice.h"#include "p.mech.ecm.h"#include "p.mech.tag.h"#include "p.mech.combat.h"#include "p.mech.combat.misc.h"#include "p.mech.damage.h"#include "p.mech.fire.h"#include "p.mech.startup.h"#include "p.mech.utils.h"#include "p.mech.update.h"#include "p.btechstats.h"#include "p.mech.physical.h"#include "p.bsuit.h"#include "p.mine.h"#include "p.mech.lite.h"#include "p.mech.pickup.h"Include dependency graph for mech.update.c:
Go to the source code of this file.
Defines | |
| #define | FASA_TURN_MOD 3/2 |
| #define | DECREASE_HEAT(spd) tempspeed *= (ceil((rint((maxspeed / 1.5) / MP1) - (spd/MP1) ) * 1.5) * MP1) / maxspeed |
| #define | DECREASE_OLD(spd) tempspeed *= (maxspeed - (spd)) / maxspeed |
| #define | INCREASE_OLD(spd) DECREASE_OLD(-(spd)) |
| #define | DECREASE_NEW(spd) tempspeed *= MP1 / (MP1 + spd) |
| #define | INCREASE_NEW(spd) tempspeed *= (MP1 + spd/2) / MP1 |
| #define | DECREASE(s) DECREASE_NEW(s) |
| #define | INCREASE(s) INCREASE_NEW(s) |
| #define | MOVE_BACK |
Enumerations | |
| enum | { JUMP, WALK_WALL, WALK_DROP, HIT_UNDER_BRIDGE, WALK_BACK } |
Functions | |
| int | fiery_death (MECH *mech) |
| int | bridge_w_elevation (MECH *mech) |
| void | bridge_set_elevation (MECH *mech) |
| int | DSOkToNotify (MECH *mech) |
| int | collision_check (MECH *mech, int mode, int le, int lt) |
| void | CheckNavalHeight (MECH *mech, int oz) |
| void | move_mech (MECH *mech) |
| void | CheckVTOLHeight (MECH *mech) |
| void | UpdateHeading (MECH *mech) |
| float | terrain_speed (MECH *mech, float tempspeed, float maxspeed, int terrain, int elev) |
| void | UpdateSpeed (MECH *mech) |
| int | OverheatMods (MECH *mech) |
| void | ammo_explosion (MECH *attacker, MECH *mech, int ammoloc, int ammocritnum, int damage) |
| void | HandleOverheat (MECH *mech) |
| static int | EnableSomeHS (MECH *mech, int numsinks) |
| static int | DisableSomeHS (MECH *mech, int numsinks) |
| void | UpdateHeat (MECH *mech) |
| int | recycle_weaponry (MECH *mech) |
| int | SkidMod (float Speed) |
| void | move_unit_back (MECH *mech, float deltax, float deltay, int lastelevation, int ot, int le) |
| void | NewHexEntered (MECH *mech, MAP *mech_map, float deltax, float deltay, int last_z) |
| void | CheckDamage (MECH *wounded) |
| void | UpdatePilotSkillRolls (MECH *mech) |
| void | updateAutoturnTurret (MECH *mech) |
| void | mech_update (dbref key, void *data) |
Variables | |
| int | arc_override |
| #define DECREASE | ( | s | ) | DECREASE_NEW(s) |
| #define DECREASE_HEAT | ( | spd | ) | tempspeed *= (ceil((rint((maxspeed / 1.5) / MP1) - (spd/MP1) ) * 1.5) * MP1) / maxspeed |
| #define DECREASE_NEW | ( | spd | ) | tempspeed *= MP1 / (MP1 + spd) |
Definition at line 926 of file mech.update.c.
| #define DECREASE_OLD | ( | spd | ) | tempspeed *= (maxspeed - (spd)) / maxspeed |
| #define FASA_TURN_MOD 3/2 |
Referenced by UpdateHeading().
| #define INCREASE | ( | s | ) | INCREASE_NEW(s) |
Definition at line 932 of file mech.update.c.
| #define INCREASE_NEW | ( | spd | ) | tempspeed *= (MP1 + spd/2) / MP1 |
Definition at line 928 of file mech.update.c.
| #define INCREASE_OLD | ( | spd | ) | DECREASE_OLD(-(spd)) |
| #define MOVE_BACK |
| anonymous enum |
Definition at line 93 of file mech.update.c.
00093 { 00094 JUMP, WALK_WALL, WALK_DROP, HIT_UNDER_BRIDGE, WALK_BACK 00095 };
Definition at line 1136 of file mech.update.c.
References confdata::btech_inferno_penalty, CLASS_BSUIT, CLASS_MW, DamageMech(), DestroyPart, GetPartAmmoMode, HasBoolAdvantage(), headhitmwdamage(), Inferno_Hit(), INFERNO_MODE, mech_notify(), MECHALL, MechLOSBroadcast(), MECHPILOT, MechPilot, MechType, MechWeapHeat, and mudconf.
Referenced by HandleMechCrit(), HandleOverheat(), and mech_explode_event().
01138 { 01139 if(MechType(mech) == CLASS_MW) { 01140 mech_notify(mech, MECHALL, "Your weapon's ammo explodes!"); 01141 MechLOSBroadcast(mech, "'s weapon's ammo explodes!"); 01142 } else { 01143 mech_notify(mech, MECHALL, "Ammunition explosion!"); 01144 if(GetPartAmmoMode(mech, ammoloc, ammocritnum) & INFERNO_MODE) 01145 MechLOSBroadcast(mech, 01146 "is suddenly enveloped by a brilliant fireball!"); 01147 else 01148 MechLOSBroadcast(mech, "has an internal ammo explosion!"); 01149 } 01150 DestroyPart(mech, ammoloc, ammocritnum); 01151 if(!attacker) 01152 return; 01153 if(GetPartAmmoMode(mech, ammoloc, ammocritnum) & INFERNO_MODE) { 01154 Inferno_Hit(mech, mech, damage / 4, 0); 01155 if(mudconf.btech_inferno_penalty) 01156 MechWeapHeat(mech) += 30.0; 01157 damage = damage / 2; 01158 } 01159 if(MechType(mech) == CLASS_BSUIT) 01160 DamageMech(mech, attacker, 0, -1, ammoloc, 0, 0, damage, 0, -1, 0, 01161 -1, 0, 0); 01162 else 01163 DamageMech(mech, attacker, 0, -1, ammoloc, 0, 0, -1, damage, -1, 0, 01164 -1, 0, 0); 01165 01166 if(MechType(mech) != CLASS_BSUIT) { 01167 mech_notify(mech, MECHPILOT, 01168 "You take personal injury from the ammunition explosion!"); 01169 if(HasBoolAdvantage(MechPilot(mech), "pain_resistance")) 01170 headhitmwdamage(mech, mech, 1); 01171 else 01172 headhitmwdamage(mech, mech, 2); 01173 } 01174 }
| void bridge_set_elevation | ( | MECH * | mech | ) |
Definition at line 71 of file mech.update.c.
References bridge_w_elevation(), MechUpperElevation, MechZ, MoveMod, and Overwater.
Referenced by DropSetElevation().
00072 { 00073 if(MechZ(mech) < (MechUpperElevation(mech) - MoveMod(mech))) { 00074 if(Overwater(mech)) 00075 MechZ(mech) = 0; 00076 else 00077 MechZ(mech) = bridge_w_elevation(mech); 00078 return; 00079 } 00080 MechZ(mech) = MechUpperElevation(mech); 00081 }
| int bridge_w_elevation | ( | MECH * | mech | ) |
Definition at line 66 of file mech.update.c.
Referenced by bridge_set_elevation(), collision_check(), DropGetElevation(), and NewHexEntered().
| void CheckDamage | ( | MECH * | wounded | ) |
Definition at line 2701 of file mech.update.c.
References AcceptableDegree(), confdata::btech_newstagger, CheckingStaggerDamage, CLASS_MECH, Fallen, IsDS, Jumping, LastStaggerNotify, MadePilotSkillRoll(), mech_notify(), MECHALL, MechFacing, MechFalls(), MechLOSBroadcast(), MechStaggeredLastTurn, MechStaggerStamp, MechTurnDamage, MechType, mudconf, muxevent_tick, MECH::mynum, OODing, Roll(), SendDebug, SetFacing, SetMechStaggerStamp, StaggerDamage, StaggerLevel, StartStaggerCheck, StopStaggerCheck, tprintf(), and TURN.
Referenced by UpdatePilotSkillRolls().
02702 { 02703 /* should be called from UpdatePilotSkillRolls */ 02704 /* this is so that a roll will be made only when the mech takes damage */ 02705 int now = muxevent_tick % TURN; 02706 int staggerLevel = 0; 02707 int headingChange = 0; 02708 02709 if(mudconf.btech_newstagger) { 02710 02711 /* phase out post-stagger assistance - see check_stagger_event() */ 02712 if(StaggerDamage(wounded) < 0) { 02713 StaggerDamage(wounded) += 1; 02714 return; 02715 } 02716 if(StaggerDamage(wounded) == 0) { 02717 return; 02718 } 02719 02720 staggerLevel = StaggerLevel(wounded); 02721 02722 if(Fallen(wounded) || (MechType(wounded) != CLASS_MECH)) { 02723 if(CheckingStaggerDamage(wounded) || (StaggerDamage(wounded) > 0)) 02724 StopStaggerCheck(wounded); 02725 02726 return; 02727 } 02728 02729 if(!CheckingStaggerDamage(wounded)) { 02730 if((Jumping(wounded) && (staggerLevel < 1)) || !Jumping(wounded)) 02731 StartStaggerCheck(wounded); 02732 } 02733 02734 if(staggerLevel < 1) { 02735 return; 02736 } 02737 02738 SendDebug(tprintf("For %d. StaggerDamage: %d. StaggerLevel: %d.", 02739 wounded->mynum, StaggerDamage(wounded), 02740 StaggerLevel(wounded))); 02741 02742 if(LastStaggerNotify(wounded) < staggerLevel) { 02743 LastStaggerNotify(wounded) = staggerLevel; 02744 02745 if(Jumping(wounded) || OODing(wounded)) { 02746 switch (staggerLevel) { 02747 case 1: 02748 mech_notify(wounded, MECHALL, 02749 "%cy%chThe damage causes you to spin a little in your flight path.%cn"); 02750 headingChange = 15; 02751 break; 02752 02753 case 2: 02754 mech_notify(wounded, MECHALL, 02755 "%crThe damage spins you but you maintain your flight!%cn"); 02756 MechLOSBroadcast(wounded, 02757 "turns slightly from the damage!"); 02758 headingChange = 45; 02759 break; 02760 02761 default: 02762 mech_notify(wounded, MECHALL, 02763 "%cr%chThe damage causes you to spin completely around!%cn"); 02764 MechLOSBroadcast(wounded, 02765 "spins around from the damage!"); 02766 headingChange = 180; 02767 break; 02768 } 02769 02770 SetFacing(wounded, 02771 AcceptableDegree((MechFacing(wounded) + 02772 headingChange) * (Roll() >= 02773 6 ? 1 : -1))); 02774 } else { 02775 switch (staggerLevel) { 02776 case 1: 02777 mech_notify(wounded, MECHALL, 02778 "%cy%chThe damage causes you to stagger a little.%cn"); 02779 break; 02780 02781 case 2: 02782 mech_notify(wounded, MECHALL, 02783 "%crThe damage causes you to stagger even more!%cn"); 02784 MechLOSBroadcast(wounded, 02785 "starts to stagger from the damage!"); 02786 break; 02787 02788 default: 02789 mech_notify(wounded, MECHALL, 02790 "%cr%chThe damage causes you to stagger violently while attempting to keep your footing!%cn"); 02791 MechLOSBroadcast(wounded, 02792 "staggers back and forth attempting to keep its footing!"); 02793 break; 02794 } 02795 } 02796 } 02797 } else { 02798 if(!IsDS(wounded) && MechTurnDamage(wounded) >= 20 && 02799 (!MechStaggeredLastTurn(wounded) || 02800 MechStaggerStamp(wounded) == now)) { 02801 02802 if(!Jumping(wounded) && !Fallen(wounded) && !OODing(wounded)) { 02803 mech_notify(wounded, MECHALL, "You stagger from the damage!"); 02804 if(!MadePilotSkillRoll(wounded, 1)) { 02805 mech_notify(wounded, MECHALL, 02806 "You fall over from all the damage!"); 02807 MechLOSBroadcast(wounded, 02808 "falls down, staggered by the damage!"); 02809 MechFalls(wounded, 1, 0); 02810 } 02811 } 02812 MechTurnDamage(wounded) = 0; 02813 SetMechStaggerStamp(wounded, now); 02814 return; 02815 } 02816 if((MechStaggeredLastTurn(wounded) && 02817 MechStaggerStamp(wounded) == now) || 02818 (!MechStaggeredLastTurn(wounded) && !now)) { 02819 MechTurnDamage(wounded) = 0; 02820 SetMechStaggerStamp(wounded, -1); 02821 } 02822 } 02823 }
| void CheckNavalHeight | ( | MECH * | mech, | |
| int | oz | |||
| ) |
Definition at line 732 of file mech.update.c.
References BRIDGE, ICE, MarkForLOSUpdate(), mech_notify(), MECHALL, MechDesiredFacing, MechDesiredSpeed, MechElev, MechElevation, MechFZ, MechLOSBroadcast(), MechLowerElevation, MechMove, MechRTerrain, MechSpeed, MechTerrain, MechVerticalSpeed, MechX, MechY, MechZ, MIN, MOVE_SUB, SendError, SetFacing, tprintf(), WATER, and ZSCALE.
Referenced by move_mech().
00733 { 00734 if(MechRTerrain(mech) != WATER && MechRTerrain(mech) != ICE && 00735 MechRTerrain(mech) != BRIDGE) { 00736 MechSpeed(mech) = 0.0; 00737 MechVerticalSpeed(mech) = 0; 00738 MechDesiredSpeed(mech) = 0.0; 00739 SetFacing(mech, 0); 00740 MechDesiredFacing(mech) = 0; 00741 return; 00742 } 00743 if(!oz && MechZ(mech) && MechElev(mech) > 1) { 00744 MarkForLOSUpdate(mech); 00745 MechZ(mech) = 0; 00746 MechLOSBroadcast(mech, "dives!"); 00747 MechZ(mech) = -1; 00748 } 00749 if(MechFZ(mech) > 0.0) { 00750 if(MechVerticalSpeed(mech) > 0 && !MechZ(mech) && oz < 0) { 00751 mech_notify(mech, MECHALL, 00752 "Your sub has reached surface and stops rising."); 00753 MechLOSBroadcast(mech, tprintf("surfaces at %d,%d!", 00754 MechX(mech), MechY(mech))); 00755 /* Possible show-up message? */ 00756 } 00757 MechZ(mech) = 0; 00758 MechFZ(mech) = 0.0; 00759 if(MechVerticalSpeed(mech) > 0) 00760 MechVerticalSpeed(mech) = 0; 00761 return; 00762 } 00763 if(MechZ(mech) <= (MechLowerElevation(mech))) { 00764 MechZ(mech) = MIN(0, MechLowerElevation(mech) + 1); 00765 if(MechElevation(mech) > 0) 00766 SendError(tprintf 00767 ("Oddity: #%d managed to wind up on '%c' (%d elev.)", 00768 mech->mynum, MechTerrain(mech), MechElev(mech))); 00769 MechFZ(mech) = ((5.0 * MechZ(mech) - 4) * ZSCALE) / 5.0; 00770 if(MechMove(mech) == MOVE_SUB) { 00771 if(MechVerticalSpeed(mech) < 0) { 00772 MechVerticalSpeed(mech) = 0; 00773 mech_notify(mech, MECHALL, 00774 "The sub has reached bottom and stops diving."); 00775 } 00776 #if 0 00777 else 00778 mech_notify(mech, MECHALL, "The sub has reached bottom."); 00779 #endif 00780 } 00781 } 00782 }
| void CheckVTOLHeight | ( | MECH * | mech | ) |
Definition at line 784 of file mech.update.c.
References aero_land(), BRIDGE, DestroyMech(), InWater, is_aero, Landed, LANDED, mech_notify(), MECHALL, MechElevation, MechFalls(), MechFZ, MechLOSBroadcast(), MechPilot, MechRTerrain, MechSpeed, MechStatus, MechVerticalSpeed, MechZ, MP1, ORBIT_Z, and ZSCALE.
Referenced by move_mech().
00785 { 00786 if(InWater(mech) && MechZ(mech) <= 0) { 00787 mech_notify(mech, MECHALL, "You crash your vehicle into the water!"); 00788 mech_notify(mech, MECHALL, "Water pours into the cockpit....glub glub!"); 00789 MechLOSBroadcast(mech, "splashes into the water!"); 00790 DestroyMech(mech, mech, 0); 00791 return; 00792 } 00793 00794 if((MechZ(mech) >= ORBIT_Z) && !is_aero(mech)) { 00795 mech_notify(mech, MECHALL, "You cannot achieve orbit! Vertical movement halted!"); 00796 MechZ(mech) = ORBIT_Z - 1; 00797 MechFZ(mech) = ZSCALE * MechZ(mech); 00798 MechVerticalSpeed(mech) = 0.0; 00799 return; 00800 } 00801 00802 if(MechZ(mech) >= MechElevation(mech)) 00803 return; 00804 if(MechRTerrain(mech) == BRIDGE) 00805 if(MechZ(mech) != (MechElevation(mech) - 1)) 00806 return; 00807 aero_land(MechPilot(mech), mech, ""); 00808 if(Landed(mech)) 00809 return; 00810 mech_notify(mech, MECHALL, 00811 "CRASH! You smash your toy into the ground!"); 00812 MechLOSBroadcast(mech, "crashes into the ground!"); 00813 MechFalls(mech, 1 + fabs(MechVerticalSpeed(mech) / MP1), 0); 00814 00815 /* mech_notify (mech, MECHALL, "Your vehicle is inoperable."); */ 00816 MechZ(mech) = MechElevation(mech); 00817 MechFZ(mech) = ZSCALE * MechZ(mech); 00818 MechSpeed(mech) = 0.0; 00819 MechVerticalSpeed(mech) = 0.0; 00820 MechStatus(mech) |= LANDED; 00821 00822 /* DestroyMech (mech, mech); */ 00823 }
| int collision_check | ( | MECH * | mech, | |
| int | mode, | |||
| int | le, | |||
| int | lt | |||
| ) |
Definition at line 97 of file mech.update.c.
References BRIDGE, bridge_w_elevation(), CLASS_VTOL, Elevation, getMap(), HIT_UNDER_BRIDGE, ICE, JUMP, MECH::mapindex, MechElevation, MechLastX, MechLastY, MechMove, MechRTerrain, MechSpeed, MechType, MechUpperElevation, MechX, MechY, MechZ, MOVE_HOVER, MOVE_TRACK, MoveMod, Overwater, WALK_BACK, WALK_DROP, WALK_WALL, and WATER.
Referenced by move_mech(), and NewHexEntered().
00098 { 00099 int e; 00100 MAP *mech_map = getMap(mech->mapindex); 00101 00102 if(Overwater(mech) && le < 0) 00103 le = 0; 00104 e = MechElevation(mech); 00105 if(MechRTerrain(mech) == ICE) 00106 if(le >= 0) 00107 e = 0; 00108 if(le < (MechUpperElevation(mech) - MoveMod(mech)) && lt == BRIDGE) { 00109 if(Overwater(mech)) 00110 le = 0; 00111 else 00112 le = bridge_w_elevation(mech); 00113 } 00114 if(e < 0 && Overwater(mech)) 00115 e = 0; 00116 switch (mode) { 00117 case JUMP: 00118 if(MechRTerrain(mech) == BRIDGE) { 00119 if(MechZ(mech) < 0) 00120 return 1; 00121 if(MechZ(mech) == (e - 1)) 00122 return 1; 00123 return 0; 00124 } else 00125 return (MechZ(mech) < e); 00126 case WALK_DROP: 00127 return (le - e) > MoveMod(mech); 00128 case WALK_WALL: 00129 if((MechMove(mech) == MOVE_HOVER) && 00130 (MechRTerrain(mech) == BRIDGE) && (((lt == ICE) || 00131 (lt == WATER)) || ((le == 0) 00132 && (lt == 00133 BRIDGE)))) 00134 { 00135 return 0; 00136 } else { 00137 return (e - le) > MoveMod(mech); 00138 } 00139 case WALK_BACK: 00140 if(MechMove(mech) != MOVE_TRACK && MechType(mech) != CLASS_VTOL) 00141 return (MechSpeed(mech) < 0 ? abs((le - e)) : 0); 00142 case HIT_UNDER_BRIDGE: /* Hovers only... tho it should be fixed for foils and hulls too */ 00143 if((lt == BRIDGE) && (MechRTerrain(mech) == BRIDGE) && (le == 0) 00144 && (Elevation(mech_map, MechLastX(mech), MechLastY(mech)) != 0) 00145 && (Elevation(mech_map, MechX(mech), MechY(mech)) == 1)) 00146 return 1; 00147 else 00148 return 0; 00149 } 00150 return 0; 00151 }
| static int DisableSomeHS | ( | MECH * | mech, | |
| int | numsinks | |||
| ) | [static] |
Definition at line 1336 of file mech.update.c.
References CLAN_TECH, DOUBLE_HEAT_TECH, mech_printf(), MechActiveNumsinks, MECHALL, MechDisabledHS, MechMinusHeat, MechSpecials, and MIN.
Referenced by UpdateHeat().
01337 { 01338 01339 numsinks = MIN(numsinks, 01340 (MechSpecials(mech) & (DOUBLE_HEAT_TECH | CLAN_TECH)) ? 4 : 01341 2); 01342 numsinks = MIN(numsinks, MechActiveNumsinks(mech)); 01343 01344 if(!numsinks) 01345 return 0; 01346 01347 MechDisabledHS(mech) += numsinks; 01348 MechMinusHeat(mech) -= numsinks; /* Submerged heatsinks silently 01349 still dissipate some heat */ 01350 #ifdef HEATCUTOFF_DEBUG 01351 mech_printf(mech, MECHALL, 01352 "%%cy%d heatsink%s hum%s into silence.%%c", numsinks, 01353 numsinks == 1 ? "" : "s", numsinks == 1 ? "s" : ""); 01354 #endif 01355 01356 return numsinks; 01357 }
| int DSOkToNotify | ( | MECH * | mech | ) |
Definition at line 83 of file mech.update.c.
References DS_SPAM_TIME, DSLastMsg, and muxevent_tick.
Referenced by move_mech().
00084 { 00085 if(DSLastMsg(mech) > muxevent_tick || 00086 (muxevent_tick - DSLastMsg(mech)) >= DS_SPAM_TIME) { 00087 DSLastMsg(mech) = muxevent_tick; 00088 return 1; 00089 } 00090 return 0; 00091 }
| static int EnableSomeHS | ( | MECH * | mech, | |
| int | numsinks | |||
| ) | [static] |
Definition at line 1313 of file mech.update.c.
References CLAN_TECH, DOUBLE_HEAT_TECH, mech_printf(), MECHALL, MechDisabledHS, MechMinusHeat, MechSpecials, and MIN.
Referenced by UpdateHeat().
01314 { 01315 01316 numsinks = MIN(numsinks, 01317 (MechSpecials(mech) & (DOUBLE_HEAT_TECH | CLAN_TECH)) ? 4 : 01318 2); 01319 numsinks = MIN(numsinks, MechDisabledHS(mech)); 01320 01321 if(!numsinks) 01322 return 0; 01323 01324 MechDisabledHS(mech) -= numsinks; 01325 MechMinusHeat(mech) += numsinks; /* We dont check for water and 01326 such after enabling them, only the next tic. */ 01327 #ifdef HEATCUTOFF_DEBUG 01328 mech_printf(mech, MECHALL, 01329 "%%cg%d heatsink%s kick%s into action.%%c", numsinks, 01330 numsinks == 1 ? "" : "s", numsinks == 1 ? "s" : ""); 01331 #endif 01332 01333 return numsinks; 01334 }
| int fiery_death | ( | MECH * | mech | ) |
Definition at line 38 of file mech.update.c.
References CLASS_MW, Destroyed, DestroyMech(), FIRE, heat_effect(), is_aero, mech_notify(), MECHALL, MechMove, MechTerrain, MechType, and MOVE_VTOL.
Referenced by move_mech().
00039 { 00040 if(MechTerrain(mech) == FIRE) { 00041 if(is_aero(mech)) 00042 return 0; 00043 if(MechMove(mech) == MOVE_VTOL) 00044 return 0; 00045 if(Destroyed(mech)) 00046 return 0; 00047 00048 /* Cause various things */ 00049 /* MWs _die_ */ 00050 if(MechType(mech) == CLASS_MW) { 00051 mech_notify(mech, MECHALL, "You feel a tad bit too warm.."); 00052 mech_notify(mech, MECHALL, "You faint."); 00053 DestroyMech(mech, mech, 0); 00054 return 1; 00055 } 00056 00057 /* Tanks may die */ 00058 return 0; /* Dumb idea */ 00059 heat_effect(NULL, mech, 0, 0); 00060 if(Destroyed(mech)) 00061 return 1; 00062 } 00063 return 0; 00064 }
| void HandleOverheat | ( | MECH * | mech | ) |
Definition at line 1176 of file mech.update.c.
References AccumulateComputerXP(), ammo_explosion(), confdata::btech_inferno_penalty, char_getskillsuccess(), domino_space(), Fallen, FindDestructiveAmmo(), FindInfernoAmmo(), getMap(), is_aero, isPlayer, Jumping, JumpSpeedMP, Landed, MadePilotSkillRoll(), mech_notify(), MECHALL, MechCritStatus, MechFalls(), MechHeat, MechHeatLast, MechLOSBroadcast(), MechPilot, MechSpeed, MechStatus, MechStatus2, MP1, mudconf, muxevent_tick, OODing, Roll(), Shutdown, SLITE_LIT, SLITE_ON, Started, STARTED, StopMoving, StopStand, and TURN.
Referenced by UpdateHeat().
01177 { 01178 int avoided = 0, hasinferno = 0; 01179 MAP *mech_map; 01180 int ammoloc, ammocritnum, damage = 0; 01181 01182 if(MechHeat(mech) < 10.) 01183 return; 01184 /* Has it been a TURN already ? */ 01185 if((MechHeatLast(mech) + TURN) > muxevent_tick) 01186 return; 01187 MechHeatLast(mech) = muxevent_tick; 01188 01189 /* Ammo - done first so infernobooms shut you down */ 01190 if(MechHeat(mech) >= 10.) { 01191 if(mudconf.btech_inferno_penalty) 01192 hasinferno = FindInfernoAmmo(mech, &ammoloc, &ammocritnum); 01193 if(MechHeat(mech) >= 28.) { 01194 /* Ammo explosion (Avoid 8+, infernos 12+) */ 01195 if(hasinferno) { 01196 if(Roll() >= 12) 01197 avoided = 1; 01198 } else { 01199 if(Roll() >= 8) 01200 avoided = 1; 01201 } 01202 } else if(MechHeat(mech) >= 23.) { 01203 /* Ammo explosion (Avoid 6+, infernos 10+) */ 01204 if(hasinferno) { 01205 if(Roll() >= 10) 01206 avoided = 1; 01207 } else { 01208 if(Roll() >= 6) 01209 avoided = 1; 01210 } 01211 } else if(MechHeat(mech) >= 19.) { 01212 /* Ammo explosion (Avoid 4+, infernos 8+) */ 01213 if(hasinferno) { 01214 if(Roll() >= 8) 01215 avoided = 1; 01216 } else { 01217 if(Roll() >= 4) 01218 avoided = 1; 01219 } 01220 01221 } else if((MechHeat(mech) >= 14.) && (hasinferno)) { 01222 if(Roll() >= 6) 01223 avoided = 1; 01224 } else if((MechHeat(mech) >= 10.) && (hasinferno)) { 01225 if(Roll() >= 4) 01226 avoided = 1; 01227 } else if((MechHeat(mech) < 19.) && (!hasinferno)) { 01228 avoided = 1; 01229 } 01230 01231 if(!(avoided)) { 01232 if(!hasinferno) 01233 damage = FindDestructiveAmmo(mech, &ammoloc, &ammocritnum); 01234 else 01235 damage = hasinferno; 01236 if(damage) { 01237 /* BOOM! */ 01238 /* That's going to hurt... */ 01239 ammo_explosion(mech, mech, ammoloc, ammocritnum, damage); 01240 } else 01241 mech_notify(mech, MECHALL, 01242 "You have no ammunition, lucky you!"); 01243 } 01244 } 01245 01246 avoided = 0; 01247 #ifdef BT_EXILE_MW3STATS 01248 if(!isPlayer(MechPilot(mech))) { 01249 #endif 01250 if(MechHeat(mech) >= 30.) { 01251 /* Shutdown */ 01252 } else if(MechHeat(mech) >= 26.) { 01253 /* Shutdown avoid on 10+ */ 01254 if(Roll() >= 10) 01255 avoided = 1; 01256 } else if(MechHeat(mech) >= 22.) { 01257 /* Shutdown avoid on 8+ */ 01258 if(Roll() >= 8) 01259 avoided = 1; 01260 } else if(MechHeat(mech) >= 18.) { 01261 /* Shutdown avoid on 6+ */ 01262 if(Roll() >= 6) 01263 avoided = 1; 01264 } else if(MechHeat(mech) >= 14.) { 01265 /* Shutdown avoid on 4+ */ 01266 if(Roll() >= 4) 01267 avoided = 1; 01268 } 01269 #ifdef BT_EXILE_MW3STATS 01270 } else { 01271 avoided = 1; 01272 if(MechHeat(mech) >= 14.) { 01273 mech_notify(mech, MECHALL, 01274 "You frantically attempt to override the shutdown process!"); 01275 avoided = 01276 char_getskillsuccess(MechPilot(mech), "computer", 01277 (MechHeat(mech) >= 01278 30. ? 8 : MechHeat(mech) >= 01279 26. ? 6 : MechHeat(mech) >= 01280 22. ? 4 : MechHeat(mech) >= 01281 18. ? 2 : 0), 1); 01282 if(avoided) 01283 AccumulateComputerXP(MechPilot(mech), mech, 1); 01284 } 01285 } 01286 #endif 01287 if(!(avoided) && Started(mech)) { 01288 if(MechStatus(mech) & STARTED) 01289 mech_notify(mech, MECHALL, "%ci%crReactor shutting down...%c"); 01290 if(MechStatus2(mech) & SLITE_ON) { 01291 mech_notify(mech, MECHALL, "Your searchlight shuts off."); 01292 MechStatus2(mech) &= ~SLITE_ON; 01293 MechCritStatus(mech) &= ~SLITE_LIT; 01294 } 01295 if(Jumping(mech) || OODing(mech) || (is_aero(mech) && !Landed(mech))) { 01296 mech_notify(mech, MECHALL, "%chYou fall from the sky!%c"); 01297 MechLOSBroadcast(mech, "falls from the sky!"); 01298 mech_map = getMap(mech->mapindex); 01299 MechFalls(mech, JumpSpeedMP(mech, mech_map), 0); 01300 domino_space(mech, 2); 01301 } else { 01302 MechLOSBroadcast(mech, "stops in mid-motion!"); 01303 if((fabs(MechSpeed(mech) > MP1)) && !Fallen(mech) && 01304 (!MadePilotSkillRoll(mech, 3))) 01305 MechFalls(mech, 0, 1); 01306 } 01307 Shutdown(mech); 01308 StopMoving(mech); 01309 StopStand(mech); 01310 } 01311 }
| void mech_update | ( | dbref | key, | |
| void * | data | |||
| ) |
Definition at line 2935 of file mech.update.c.
References aero_update(), AUTOTURN_TURRET, BOUNDED(), checkECM(), checkTAG(), end_lite_check(), FIRED, is_aero, MechPlusHeat, MechStatus, MechStatus2, MechVisMod, Number, Started, Uncon, updateAutoturnTurret(), UpdateHeat(), and UpdatePilotSkillRolls().
02936 { 02937 MECH *mech = (MECH *) data; 02938 02939 if(!mech) 02940 return; 02941 MechStatus(mech) &= ~FIRED; 02942 if(is_aero(mech)) { 02943 aero_update(mech); 02944 return; 02945 } 02946 if(Started(mech) || Uncon(mech)) 02947 UpdatePilotSkillRolls(mech); 02948 if(Started(mech) || MechPlusHeat(mech) > 0.1) 02949 UpdateHeat(mech); 02950 if(Started(mech)) 02951 MechVisMod(mech) = 02952 BOUNDED(0, MechVisMod(mech) + Number(-40, 40), 100); 02953 checkECM(mech); 02954 checkTAG(mech); 02955 end_lite_check(mech); 02956 02957 if(MechStatus2(mech) & AUTOTURN_TURRET) 02958 updateAutoturnTurret(mech); 02959 }
| void move_mech | ( | MECH * | mech | ) |
Definition at line 155 of file mech.update.c.
References AccumulatePilXP(), break_thru_ice(), BRIDGE, BSuitMirrorSwarmedTarget(), confdata::btech_newcharge, CHARGE_DIST_TRIGGER, CHARGE_TIMER_LIMIT, ChargeMech(), CheckEdgeOfMap(), CheckNavalHeight(), CheckVTOLHeight(), CLASS_MECH, CLASS_VEH_NAVAL, collision_check(), domino_space(), drop_thru_ice(), DropSetElevation(), DS_LandWarning(), DSOkToNotify(), FaMechRange, fiery_death(), FindComponents(), GetElev, getMap(), getMech(), GetTerrain, HEXLEVEL, HIDDEN, ICE, In_Character, is_aero, IsDS, JUMP, Jumping, JumpSpeed, JumpSpeedMP, Landed, LandMech(), length_hypotenuse(), MAP::map_height, MAP::map_width, MapCoordToRealCoord(), MECH::mapindex, MAPMOVEMOD, MarkForLOSUpdate(), MBUF_SIZE, mech_land(), mech_notify(), mech_shutdown(), MECHALL, MechCarrying, MechChargeDistance, MechChargeTarget, MechChargeTimer, MechCocoon, MechCritStatus, MechDesiredAngle, MechElev, MechEndFZ, MechFacing, MechFalls(), MechFloods(), MechFX, MechFY, MechFZ, MechGoingX, MechGoingY, MechHexes, MechJumpHeading, MechJumpLength, MechJumpTop, MechLastX, MechLastY, MechLateral, MechLOSBroadcast(), MechMove, MechPilot, MECHPILOT, MechRFacing, MechRTerrain, MechSpeed, MechStartFX, MechStartFY, MechStartFZ, MechTerrain, MechType, MechVerticalSpeed, MechX, MechY, MechZ, MirrorPosition, MOVE_BIPED, MOVE_FLY, MOVE_FOIL, MOVE_HOVER, MOVE_HULL, MOVE_MOD, MOVE_QUAD, MOVE_SUB, MOVE_TRACK, MOVE_VTOL, MOVE_WHEEL, mudconf, NewHexEntered(), PIL_XP_EVERY_N_STEPS, possibly_drop_thru_ice(), RealCoordToMapCoord(), RGotPilot, SCALEMAP, SendDebug, SendError, SetRFacing, steppable_base_check(), StopHiding, ValidMap(), water_extinguish_inferno(), x, y, YSCALE2, and ZSCALE.
Referenced by aero_move_event(), mech_jump_event(), and mech_move_event().
00156 { 00157 float newx = 0.0, newy = 0.0, dax, day; 00158 float xy_charge_dist, xscale; 00159 float jump_pos; 00160 00161 #ifdef ODDJUMP 00162 float rjump_pos, midmod; 00163 #endif 00164 int x, y, upd_z = 0; 00165 int last_z = 0; 00166 MECH *target; 00167 MAP *mech_map; 00168 int oi, oz; 00169 int iced = 0; 00170 00171 /* Buffer for printing messages so we don't use the tprintf 00172 * function anymore */ 00173 char message_buffer[MBUF_SIZE]; 00174 00175 oz = MechZ(mech); 00176 mech_map = getMap(mech->mapindex); 00177 00178 if(!mech_map && MechPilot(mech) >= 0) 00179 mech_map = ValidMap(MechPilot(mech), mech->mapindex); 00180 00181 /* Unit is not on a map so don't need to move it - instead 00182 * reset its values and shut it down */ 00183 if(!mech_map) { 00184 00185 mech_notify(mech, MECHALL, 00186 "You are on an invalid map! Map index reset!"); 00187 MechCocoon(mech) = 0; 00188 00189 if(Jumping(mech)) 00190 mech_land(MechPilot(mech), (void *) mech, ""); 00191 00192 mech_shutdown(MechPilot(mech), (void *) mech, ""); 00193 00194 snprintf(message_buffer, MBUF_SIZE, 00195 "move_mech:invalid map:Mech: %d Index: %d", mech->mynum, 00196 mech->mapindex); 00197 SendError(message_buffer); 00198 mech->mapindex = -1; 00199 return; 00200 } 00201 00202 /* Is the unit on a valid spot on the map */ 00203 if(MechX(mech) < 0 || MechX(mech) >= mech_map->map_width || 00204 MechLastX(mech) < 0 || MechLastX(mech) >= mech_map->map_width || 00205 MechY(mech) < 0 || MechY(mech) >= mech_map->map_height || 00206 MechLastY(mech) < 0 || MechLastY(mech) >= mech_map->map_height) { 00207 00208 mech_notify(mech, MECHALL, 00209 "You are at an invalid map location! Map index reset!"); 00210 MechCocoon(mech) = 0; 00211 00212 if(Jumping(mech)) 00213 mech_land(MechPilot(mech), (void *) mech, ""); 00214 00215 mech_shutdown(MechPilot(mech), (void *) mech, ""); 00216 00217 snprintf(message_buffer, MBUF_SIZE, 00218 "move_mech:invalid map:Mech: %d Index: %d", mech->mynum, 00219 mech->mapindex); 00220 SendError(message_buffer); 00221 00222 mech->mapindex = -1; 00223 return; 00224 } 00225 00226 /* Is the unit charging - and if so have they been charging to long */ 00227 if(mudconf.btech_newcharge && MechChargeTarget(mech) > 0) { 00228 if(MechChargeTimer(mech)++ > CHARGE_TIMER_LIMIT) { 00229 mech_notify(mech, MECHALL, "Charge timed out, charge reset."); 00230 MechChargeTarget(mech) = -1; 00231 MechChargeTimer(mech) = 0; 00232 MechChargeDistance(mech) = 0; 00233 } 00234 } 00235 00239 /* Check the move type of the unit */ 00240 switch (MechMove(mech)) { 00241 case MOVE_BIPED: 00242 case MOVE_QUAD: 00243 00244 /* Biped/Quad Jumping */ 00245 if(Jumping(mech)) { 00246 MarkForLOSUpdate(mech); 00247 FindComponents(JumpSpeed(mech, mech_map) * MOVE_MOD * 00248 MAPMOVEMOD(mech_map), MechJumpHeading(mech), &newx, 00249 &newy); 00250 MechFX(mech) += newx; 00251 MechFY(mech) += newy; 00252 jump_pos = length_hypotenuse((MechFX(mech) - MechStartFX(mech)), 00253 (MechFY(mech) - MechStartFY(mech))); 00254 00257 #ifndef ODDJUMP 00258 MechFZ(mech) = ((4 * JumpSpeedMP(mech, mech_map) * ZSCALE) 00259 / (MechJumpLength(mech) * MechJumpLength(mech))) * 00260 jump_pos * (MechJumpLength(mech) - jump_pos) + 00261 MechStartFZ(mech) + jump_pos * (MechEndFZ(mech) 00262 - 00263 MechStartFZ(mech)) / 00264 (MechJumpLength(mech) * HEXLEVEL); 00265 #else 00266 rjump_pos = MechJumpLength(mech) - jump_pos; 00267 if(rjump_pos < 0.0) 00268 rjump_pos = 0.0; 00269 00270 /* New flight path: Make a direct line from the origin to 00271 destination, and imagine a 1-x^4 in relation to the 0 as 00272 the line. y=1 = JumpTop offset, x=0 = middle of path, 00273 x=-1 = beginning, x=1 = end */ 00274 midmod = jump_pos / MechJumpLength(mech); 00275 midmod = (midmod - 0.5) * 2; 00276 if(MechJumpTop(mech) >= (1 + JumpSpeedMP(mech, mech_map))) { 00277 midmod = (1.0 - (midmod * midmod)) * MechJumpTop(mech); 00278 } else { 00279 midmod = (1.0 - (midmod * midmod * midmod * midmod)) * 00280 MechJumpTop(mech); 00281 } 00282 00283 MechFZ(mech) = (rjump_pos * MechStartFZ(mech) + 00284 jump_pos * MechEndFZ(mech)) / 00285 MechJumpLength(mech) + midmod * ZSCALE; 00286 #endif 00287 00288 MechZ(mech) = (int) (MechFZ(mech) / ZSCALE + 0.5); 00289 00290 #ifdef JUMPDEBUG 00291 snprintf(message_buffer, MBUF_SIZE, 00292 "#%d: %d, %d, %d (%d, %d, %d)", 00293 mech->mynum, MechX(mech), MechY(mech), MechZ(mech), 00294 (int) MechFX(mech), (int) MechFY(mech), 00295 (int) MechFZ(mech)); 00296 SendDebug(message_buffer); 00297 #endif 00298 00299 /* The famous jumping on bridge collision code */ 00302 if(MechRTerrain(mech) == BRIDGE && 00303 collision_check(mech, JUMP, 0, 0) && MechZ(mech) > 0) { 00304 00305 mech_notify(mech, MECHALL, 00306 "CRASH! You crash into the bridge!"); 00307 MechLOSBroadcast(mech, "crashes into the bridge!"); 00308 MechFalls(mech, 1, 0); 00309 return; 00310 } 00311 00312 /* Is the jumping unit in its target hex */ 00313 if((MechX(mech) == MechGoingX(mech)) && 00314 (MechY(mech) == MechGoingY(mech))) { 00315 00316 /*Ok.. in the hex. but no instant landings anymore, laddie */ 00317 /*Range to point of origin is larger than whole jump's length */ 00318 MapCoordToRealCoord(MechX(mech), MechY(mech), &dax, &day); 00319 00321 /* Basicly checking to see if the unit is in the hex, 00322 * the ODDJUMP code looks for the exact center */ 00323 #ifdef ODDJUMP 00324 if(length_hypotenuse(dax - MechStartFX(mech), 00325 day - MechStartFY(mech)) <= 00326 length_hypotenuse(MechFX(mech) - MechStartFX(mech), 00327 MechFY(mech) - MechStartFY(mech))) { 00328 00329 LandMech(mech); 00330 MechFX(mech) = (float) dax; 00331 MechFY(mech) = (float) day; 00332 } 00333 #else 00334 LandMech(mech); 00335 MechFX(mech) = (float) dax; 00336 MechFY(mech) = (float) day; 00337 #endif 00338 } 00339 00340 /* Are we landing on ice */ 00341 if(MechRTerrain(mech) == ICE) { 00342 if(oz < -1 && MechZ(mech) >= -1) 00343 break_thru_ice(mech); 00344 else if(oz >= -1 && MechZ(mech) < -1) 00345 drop_thru_ice(mech); 00346 } 00347 00348 } else if(fabs(MechSpeed(mech)) > 0.0) { 00349 00350 /* Ok not jumping but we're moving */ 00351 FindComponents(MechSpeed(mech) * MOVE_MOD * 00352 MAPMOVEMOD(mech_map), 00353 MechLateral(mech) + MechFacing(mech), &newx, 00354 &newy); 00355 MechFX(mech) += newx; 00356 MechFY(mech) += newy; 00357 00358 upd_z = 1; 00359 00360 /* If we're charging record distance traveled */ 00361 if(MechChargeTarget(mech) > 0 && mudconf.btech_newcharge) { 00362 xscale = 1.0 / SCALEMAP; 00363 xscale = xscale * xscale; 00364 xy_charge_dist = 00365 sqrt(xscale * newx * newx + YSCALE2 * newy * newy); 00366 MechChargeDistance(mech) += xy_charge_dist; 00367 } 00368 00369 } else { 00370 00371 /* Ok not moving or jumping so don't need to calc a new x,y,z */ 00372 return; 00373 } 00374 break; 00375 00376 case MOVE_TRACK: 00377 case MOVE_WHEEL: 00378 00381 /* Is the tank moving? */ 00382 if(fabs(MechSpeed(mech)) > 0.0) { 00383 00386 #ifndef BT_MOVEMENT_MODES 00387 FindComponents(MechSpeed(mech) * MOVE_MOD * 00388 MAPMOVEMOD(mech_map), MechFacing(mech), &newx, 00389 &newy); 00390 #else 00391 FindComponents(MechSpeed(mech) * MOVE_MOD * 00392 MAPMOVEMOD(mech_map), 00393 MechLateral(mech) + MechFacing(mech), &newx, 00394 &newy); 00395 #endif 00396 MechFX(mech) += newx; 00397 MechFY(mech) += newy; 00398 upd_z = 1; 00399 00400 /* If we're charging record the distance traveled */ 00401 if(MechChargeTarget(mech) > 0 && mudconf.btech_newcharge) { 00402 xscale = 1.0 / SCALEMAP; 00403 xscale = xscale * xscale; 00404 xy_charge_dist = 00405 sqrt(xscale * newx * newx + YSCALE2 * newy * newy); 00406 MechChargeDistance(mech) += xy_charge_dist; 00407 } 00408 00409 } else { 00410 00411 /* Ok not moving or jumping so don't need to calc a new x,y,z */ 00412 return; 00413 } 00414 break; 00415 00416 case MOVE_HOVER: 00417 00418 /* If we're moving update position */ 00419 if(fabs(MechSpeed(mech)) > 0.0) { 00420 00422 #ifndef BT_MOVEMENT_MODES 00423 FindComponents(MechSpeed(mech) * MOVE_MOD * 00424 MAPMOVEMOD(mech_map), MechFacing(mech), &newx, 00425 &newy); 00426 #else 00427 FindComponents(MechSpeed(mech) * MOVE_MOD * 00428 MAPMOVEMOD(mech_map), 00429 MechLateral(mech) + MechFacing(mech), &newx, 00430 &newy); 00431 #endif 00432 MechFX(mech) += newx; 00433 MechFY(mech) += newy; 00434 upd_z = 1; 00435 00436 /* Record the charge distance */ 00437 if(MechChargeTarget(mech) > 0 && mudconf.btech_newcharge) { 00438 xscale = 1.0 / SCALEMAP; 00439 xscale = xscale * xscale; 00440 xy_charge_dist = 00441 sqrt(xscale * newx * newx + YSCALE2 * newy * newy); 00442 MechChargeDistance(mech) += xy_charge_dist; 00443 } 00444 00445 } else { 00446 00447 /* Ok not moving or jumping so don't need to calc a new x,y,z */ 00448 return; 00449 } 00450 break; 00451 00452 case MOVE_VTOL: 00453 00454 /* If we're landed we're not moving */ 00455 if(Landed(mech)) 00456 return; 00457 00458 /* Use the same code as subs below */ 00461 case MOVE_SUB: 00462 00463 MarkForLOSUpdate(mech); 00464 FindComponents(MechSpeed(mech) * MOVE_MOD * MAPMOVEMOD(mech_map), 00465 MechFacing(mech), &newx, &newy); 00466 MechFX(mech) += newx; 00467 MechFY(mech) += newy; 00468 MechFZ(mech) += MechVerticalSpeed(mech) * MOVE_MOD; 00469 MechZ(mech) = MechFZ(mech) / ZSCALE; 00470 break; 00471 00472 case MOVE_FLY: 00473 00474 /* Ok we're in the air */ 00475 if(!Landed(mech)) { 00476 00477 MarkForLOSUpdate(mech); 00478 MechFZ(mech) += MechStartFZ(mech) * MOVE_MOD; 00479 MechZ(mech) = MechFZ(mech) / ZSCALE; 00480 MechFX(mech) += MechStartFX(mech) * MOVE_MOD; 00481 MechFY(mech) += MechStartFY(mech) * MOVE_MOD; 00482 00486 if(IsDS(mech)) { 00487 00488 /* Fun messages to emit to the pilot */ 00489 if(MechZ(mech) < 10 && oz >= 10) 00490 DS_LandWarning(mech, 1); 00491 else if(MechZ(mech) < 50 && oz >= 50) 00492 DS_LandWarning(mech, 0); 00493 else if(MechZ(mech) < 100 && oz >= 100) { 00494 00495 if(abs(MechDesiredAngle(mech)) != 90) { 00496 if(DSOkToNotify(mech)) { 00497 mech_notify(mech, MECHALL, "As the craft enters " 00498 "the lower atmosphere, its nose rises up " 00499 "for a clean landing.."); 00500 snprintf(message_buffer, MBUF_SIZE, 00501 "starts descending towards %d, %d..", 00502 MechX(mech), MechY(mech)); 00503 MechLOSBroadcast(mech, message_buffer); 00504 } else { 00505 mech_notify(mech, MECHALL, "Due to low altitude, " 00506 "climbing angle set to 90 degrees."); 00507 } 00508 MechDesiredAngle(mech) = 90; 00509 } 00510 MechStartFX(mech) = 0.0; 00511 MechStartFY(mech) = 0.0; 00512 DS_LandWarning(mech, -1); 00513 } 00514 } 00515 00516 } else { 00517 00518 /* Ok we're rolling around on the ground */ 00519 if(!(fabs(MechSpeed(mech)) > 0.0)) 00520 return; 00521 00522 FindComponents(MechSpeed(mech) * MOVE_MOD * 00523 MAPMOVEMOD(mech_map), MechFacing(mech), &newx, 00524 &newy); 00525 MechFX(mech) += newx; 00526 MechFY(mech) += newy; 00527 upd_z = 1; 00528 } 00529 break; 00530 00531 case MOVE_HULL: 00532 case MOVE_FOIL: 00533 00534 if(fabs(MechSpeed(mech)) > 0.0) { 00535 00536 FindComponents(MechSpeed(mech) * MOVE_MOD * 00537 MAPMOVEMOD(mech_map), MechFacing(mech), &newx, 00538 &newy); 00539 MechFX(mech) += newx; 00540 MechFY(mech) += newy; 00541 MechZ(mech) = 0; 00542 MechFZ(mech) = 0.0; 00543 00544 } else { 00545 00546 /* Not moving so no need to update x,y,z and other stuff */ 00547 return; 00548 } 00549 break; 00550 } 00551 00552 /* We've already updated the floating x,y values, now to update the hex 00553 * x,y values + both the Z values */ 00554 MechLastX(mech) = MechX(mech); 00555 MechLastY(mech) = MechY(mech); 00556 last_z = MechZ(mech); 00557 00558 RealCoordToMapCoord(&MechX(mech), &MechY(mech), MechFX(mech), 00559 MechFY(mech)); 00560 00562 /* Checking to make sure we didn't jump PAST our target hex */ 00563 #ifdef ODDJUMP 00564 if(Jumping(mech) && MechLastX(mech) == MechGoingX(mech) && 00565 MechLastY(mech) == MechGoingY(mech) && 00566 (MechX(mech) != MechLastX(mech) || MechY(mech) != MechLastY(mech))) { 00567 00568 LandMech(mech); 00569 MechFX(mech) -= newx; 00570 MechFY(mech) -= newy; 00571 MechFZ(mech) = MechEndFZ(mech); 00572 MechX(mech) = MechGoingX(mech); 00573 MechY(mech) = MechGoingY(mech); 00574 MapCoordToRealCoord(MechX(mech), MechY(mech), &MechFX(mech), 00575 &MechFY(mech)); 00576 MechZ(mech) = MechFZ(mech) / ZSCALE; 00577 } 00578 #endif 00579 00580 /* Store the current map index */ 00581 oi = mech->mapindex; 00582 00583 /* Did we hit mapedge? */ 00584 CheckEdgeOfMap(mech); 00585 00586 /* Did our mapindex change? - like did we run out a hangar? */ 00587 if(mech->mapindex != oi) 00588 mech_map = getMap(mech->mapindex); 00589 00590 /* We left a hangar and/or moved to a new hex */ 00591 if(oi != mech->mapindex || MechLastX(mech) != MechX(mech) || 00592 MechLastY(mech) != MechY(mech)) { 00593 00594 /* Either the mech or the map is bad */ 00595 if(!mech || !mech_map) { 00596 00597 snprintf(message_buffer, MBUF_SIZE, 00598 "Invalide pointer (%s) in move_mech()", 00599 (!mech ? "mech" : !mech_map ? "mech_map" : "weird....")); 00600 SendError(message_buffer); 00601 00602 if(mech) { 00603 00604 /* Bad Map */ 00605 mech_notify(mech, MECHALL, 00606 "You are on an invalid map! Map index reset!"); 00607 MechCocoon(mech) = 0; 00608 00609 if(Jumping(mech)) 00610 mech_land(MechPilot(mech), (void *) mech, ""); 00611 00612 mech_shutdown(MechPilot(mech), (void *) mech, ""); 00613 snprintf(message_buffer, MBUF_SIZE, 00614 "move_mech:invalid map:Mech: %d Index: %d", 00615 mech->mynum, mech->mapindex); 00616 SendError(message_buffer); 00617 mech->mapindex = -1; 00618 } 00619 return; 00620 } 00621 00622 /* We've moved from our hex so break our cover */ 00623 if(MechCritStatus(mech) & HIDDEN) { 00624 mech_notify(mech, MECHALL, 00625 "You move too much and break your cover!"); 00626 MechLOSBroadcast(mech, "breaks from its cover."); 00627 MechCritStatus(mech) &= ~(HIDDEN); 00628 } 00629 00630 StopHiding(mech); 00631 00632 x = MechX(mech); 00633 y = MechY(mech); 00634 MechTerrain(mech) = GetTerrain(mech_map, x, y); 00635 MechElev(mech) = GetElev(mech_map, x, y); 00636 00637 /* Update our Z values */ 00638 if(upd_z) { 00639 00640 /* Chance of breaking through ICE */ 00641 if(MechRTerrain(mech) == ICE) { 00642 if(oz < -1 && MechZ(mech) >= -1) 00643 break_thru_ice(mech); 00644 else if(MechZ(mech) == 0) 00645 if(possibly_drop_thru_ice(mech)) 00646 iced = 1; 00647 } 00648 00649 /* Check for bridges and basic elevation changes */ 00650 DropSetElevation(mech, 0); 00651 00652 /* To fix certain slide-under-ice-effect for _mechs_ */ 00653 if(MechType(mech) == CLASS_MECH && MechRTerrain(mech) == ICE 00654 && oz == -1 && MechZ(mech) == -1) { 00655 00656 MechZ(mech) = 0; 00657 MechFZ(mech) = MechZ(mech) * ZSCALE; 00658 } 00659 } 00660 00661 if(!iced) 00662 NewHexEntered(mech, mech_map, newx, newy, last_z); 00663 00664 if(MechX(mech) == x && MechY(mech) == y) { 00665 00666 MarkForLOSUpdate(mech); 00667 MechFloods(mech); 00668 water_extinguish_inferno(mech); 00669 steppable_base_check(mech, x, y); 00670 00671 /* Pilot XP */ 00672 if(In_Character(mech->mynum)) { 00673 MechHexes(mech)++; 00674 if(!(MechHexes(mech) % PIL_XP_EVERY_N_STEPS)) 00675 if(RGotPilot(mech)) 00676 AccumulatePilXP(MechPilot(mech), mech, 1, 0); 00677 } 00678 00679 /* Check for stacking */ 00680 domino_space(mech, 0); 00681 } 00682 } 00683 00684 /* If aero/vtol make sure we're not rubbing against the ground or trees */ 00685 if((MechMove(mech) == MOVE_VTOL || is_aero(mech)) && !Landed(mech)) 00686 CheckVTOLHeight(mech); 00687 00688 /* If we're a boat make sure we've not run a ground */ 00689 if(MechType(mech) == CLASS_VEH_NAVAL) 00690 CheckNavalHeight(mech, oz); 00691 00692 /* We're charging lets do some damage */ 00693 if(MechChargeTarget(mech) != -1) { 00694 00695 /* Valid target? */ 00696 target = getMech(MechChargeTarget(mech)); 00697 if(target) { 00698 00699 if(FaMechRange(mech, target) < CHARGE_DIST_TRIGGER) { 00700 ChargeMech(mech, target); 00701 MechChargeTarget(mech) = -1; 00702 MechChargeTimer(mech) = 0; 00703 MechChargeDistance(mech) = 0; 00704 } 00705 00706 } else { 00707 mech_notify(mech, MECHPILOT, "Invalid CHARGE target!"); 00708 MechChargeTarget(mech) = -1; 00709 MechChargeDistance(mech) = 0; 00710 MechChargeTimer(mech) = 0; 00711 } 00712 } 00713 00714 /* If we're towing something update its position with us */ 00715 if(MechCarrying(mech) > 0) { 00716 target = getMech(MechCarrying(mech)); 00717 if(target && target->mapindex == mech->mapindex) { 00718 MirrorPosition(mech, target, 0); 00719 SetRFacing(target, MechRFacing(mech)); 00720 } 00721 } 00722 00723 /* If a bsuit has swarmed a target update its 00724 * position in relation to its target */ 00725 BSuitMirrorSwarmedTarget(mech_map, mech); 00726 00727 /* This is really for killing MechWarriors 00728 * actual heat code is checked with UpdateHeat */ 00729 fiery_death(mech); 00730 }
| void move_unit_back | ( | MECH * | mech, | |
| float | deltax, | |||
| float | deltay, | |||
| int | lastelevation, | |||
| int | ot, | |||
| int | le | |||
| ) |
Definition at line 1638 of file mech.update.c.
References MechElev, MechFX, MechFY, MechFZ, MechLastX, MechLastY, MechTerrain, MechX, MechY, MechZ, and ZSCALE.
Referenced by NewHexEntered().
01640 { 01641 01642 MechFX(mech) -= deltax; 01643 MechFY(mech) -= deltay; 01644 MechX(mech) = MechLastX(mech); 01645 MechY(mech) = MechLastY(mech); 01646 MechZ(mech) = lastelevation; 01647 MechFZ(mech) = MechZ(mech) * ZSCALE; 01648 MechTerrain(mech) = ot; 01649 MechElev(mech) = le; 01650 01651 }
Definition at line 1656 of file mech.update.c.
References BRIDGE, bridge_w_elevation(), confdata::btech_fasaadvvhlfire, confdata::btech_newterrain, confdata::btech_roll_on_backwalk, confdata::btech_skidcliff, BUILDING, ChannelEmitKill(), checkVehicleInFire(), CLASS_BSUIT, CLASS_MW, CLASS_VEH_GROUND, collision_check(), Destroy, domino_space(), ed, Elevation, EVENT_MOVEMODE, FIRE, GetTerrain, GRASSLAND, HEAVY_FOREST, HIGHWATER, HIT_UNDER_BRIDGE, ICE, IsForest, IsRunning, JUMP, Jumping, Landed, LANDED, LandMech(), LIGHT_FOREST, MadePilotSkillRoll(), MadePilotSkillRoll_NoXP(), MAX, mech_notify(), mech_printf(), MECHALL, MechAutoFall, MechDesiredSpeed, MechElev, MechElevation, MECHEVENT, MechFalls(), MechFloods(), MechFX, MechFY, MechFZ, MechLastX, MechLastY, MechLOSBroadcast(), MechMove, MechPilot, MECHPILOT, MechRTerrain, MechsElevation, MechSpecials2, MechSpeed, MechStatus, MechStatus2, MechTerrain, MechType, MechVerticalSpeed, MechX, MechY, MechZ, MIN, MINE_STEP, MMaxSpeed, MODE_OFF, MODE_SPRINT, MOVE_BIPED, MOVE_FLY, MOVE_FOIL, MOVE_HOVER, MOVE_HULL, MOVE_QUAD, MOVE_SUB, MOVE_TRACK, move_unit_back(), MOVE_VTOL, MOVE_WHEEL, MoveModeChange, MP1, MP2, MP3, MP_PER_KPH, mudconf, possible_mine_poof(), RGotPilot, ROAD, ROUGH, SkidMod(), SPRINTING, tprintf(), TURN, WALK_BACK, WALK_DROP, WALK_WALL, WalkingSpeed, WATER, WATERPROOF_TECH, and ZSCALE.
Referenced by move_mech().
01658 { 01659 int elevation, lastelevation; 01660 int oldterrain; 01661 int ot, le, ed, done = 0, tt, avoidbth; 01662 int isunder = 0; 01663 float f; 01664 01665 /* Recording the old elevation and terrain */ 01667 ot = oldterrain = GetTerrain(mech_map, MechLastX(mech), MechLastY(mech)); 01668 01669 if((MechMove(mech) == MOVE_HOVER) && 01670 (oldterrain == WATER || oldterrain == ICE || 01671 ((oldterrain == BRIDGE) && (last_z == 0)))) { 01672 01673 le = lastelevation = elevation = 0; 01674 01675 } else { 01676 01677 le = lastelevation = 01678 Elevation(mech_map, MechLastX(mech), MechLastY(mech)); 01679 elevation = MechElevation(mech); 01680 01681 if(MechMove(mech) == MOVE_HOVER && elevation < 0) 01682 elevation = 0; 01683 01684 if(ot == ICE && MechZ(mech) >= 0) { 01685 le = lastelevation = 0; 01686 } 01687 01688 /* if(MechZ(mech) < le) 01689 le = MechZ(mech); 01690 */ 01691 } 01692 01693 switch (MechMove(mech)) { 01694 case MOVE_BIPED: 01695 case MOVE_QUAD: 01696 01697 if(Jumping(mech)) { 01698 01699 if(MechRTerrain(mech) == WATER) 01700 return; 01701 01702 #define MOVE_BACK \ 01703 MechFX(mech) -= deltax;\ 01704 MechFY(mech) -= deltay;\ 01705 MechX(mech) = MechLastX(mech);\ 01706 MechY(mech) = MechLastY(mech);\ 01707 MechZ(mech) = lastelevation;\ 01708 MechFZ(mech) = MechZ(mech) * ZSCALE;\ 01709 MechTerrain(mech) = ot;\ 01710 MechElev(mech) = le; 01711 01712 /* Did we hit something while jumping */ 01713 if(collision_check(mech, JUMP, 0, 0)) { 01714 01715 ed = MAX(1, 1 + MechZ(mech) - Elevation(mech_map, 01716 MechX(mech), 01717 MechY(mech))); 01718 move_unit_back(mech, deltax, deltay, lastelevation, ot, le); 01719 mech_notify(mech, MECHALL, 01720 "%chYou attempt to jump over elevation that is too high!%c"); 01721 if(RGotPilot(mech) && 01722 MadePilotSkillRoll(mech, 01723 (int) (MechFZ(mech)) / ZSCALE / 3)) { 01724 01725 mech_notify(mech, MECHALL, "%chYou land safely.%c"); 01726 LandMech(mech); 01727 01728 } else { 01729 01730 mech_notify(mech, MECHALL, 01731 "%chYou crash into the obstacle and fall from the sky!%c"); 01732 MechLOSBroadcast(mech, 01733 "crashes into an obstacle and falls from the sky!"); 01734 MechFalls(mech, ed, 0); 01735 domino_space(mech, 2); 01736 } 01737 } 01738 return; 01739 } 01740 01741 /* Walked into a wall silly */ 01742 if(collision_check(mech, WALK_WALL, lastelevation, oldterrain)) { 01743 01744 move_unit_back(mech, deltax, deltay, lastelevation, ot, le); 01745 mech_notify(mech, MECHALL, 01746 "You attempt to climb a hill too steep for you."); 01747 01748 if(MechPilot(mech) == -1 || (!mudconf.btech_skidcliff && 01749 MadePilotSkillRoll_NoXP(mech, 01750 (int) (fabs((MechSpeed (mech)) + MP1) / MP1) / 3, 1)) 01751 || (mudconf.btech_skidcliff && 01752 MadePilotSkillRoll_NoXP(mech, 01753 SkidMod(fabs(MechSpeed(mech)) / MP1), 1))) { 01754 01755 mech_notify(mech, MECHALL, 01756 "You manage to stop before crashing."); 01757 MechLOSBroadcast(mech, "stops suddenly to avoid a cliff!"); 01758 01759 } else { 01760 01761 mech_notify(mech, MECHALL, 01762 "You run headlong into the cliff and fall down!"); 01763 MechLOSBroadcast(mech, 01764 "runs headlong into a cliff and falls down!"); 01765 if(!mudconf.btech_skidcliff) 01766 MechFalls(mech, 01767 (int) (1 + (MechSpeed(mech)) * MP_PER_KPH) / 4, 01768 0); 01769 else 01770 MechFalls(mech, 1, 0); 01771 } 01772 MechDesiredSpeed(mech) = 0; 01773 MechSpeed(mech) = 0; 01774 MechZ(mech) = lastelevation; 01775 return; 01776 01777 } else if(collision_check(mech, WALK_DROP, lastelevation, oldterrain)) { 01778 01779 /* Walked off a cliff ... */ 01780 mech_notify(mech, MECHALL, 01781 "You notice a large drop in front of you"); 01782 avoidbth = mudconf.btech_skidcliff ? 01783 SkidMod(fabs(MechSpeed(mech)) / MP1) : 01784 ((fabs((MechSpeed(mech)) + MP1) / MP1) / 3); 01785 01786 if(MechPilot(mech) == -1 || (!MechAutoFall(mech) && 01787 MadePilotSkillRoll_NoXP(mech, 01788 avoidbth,1))) { 01789 01790 mech_notify(mech, MECHALL, 01791 "You manage to stop before falling off."); 01792 MechLOSBroadcast(mech, 01793 "stops suddenly to avoid falling off a cliff!"); 01794 move_unit_back(mech, deltax, deltay, lastelevation, ot, le); 01795 01796 } else { 01797 01798 mech_notify(mech, MECHALL, 01799 "You run off the cliff and fall to the ground below."); 01800 MechLOSBroadcast(mech, 01801 "runs off a cliff and falls to the ground below!"); 01802 MechFalls(mech, lastelevation - elevation, 0); 01803 MechDesiredSpeed(mech) = 0; 01804 MechSpeed(mech) = 0; 01805 } 01806 MechDesiredSpeed(mech) = 0; 01807 MechSpeed(mech) = 0; 01808 return; 01809 01810 } else if(mudconf.btech_roll_on_backwalk && 01811 (MechSpeed(mech) < 0) && 01812 (collision_check 01813 (mech, WALK_BACK, lastelevation, oldterrain))) { 01814 01815 mech_printf(mech, MECHALL, "You notice a %s behind you!", 01816 (elevation > 01817 lastelevation ? "small incline" : "small drop")); 01818 01819 if(MechPilot(mech) == -1 01820 || (MadePilotSkillRoll(mech, 01821 collision_check(mech, WALK_BACK, 01822 lastelevation, 01823 oldterrain) 01824 - 1))) { 01825 01826 mech_notify(mech, MECHALL, 01827 "You manage to overcome the obstacle."); 01828 01829 } else { 01830 01831 mech_printf(mech, MECHALL, "%s", 01832 (elevation > lastelevation ? 01833 "You stumble on your rear and fall down." : 01834 "You fall on your rear off the small incline.")); 01835 01837 MechLOSBroadcast(mech, 01838 tprintf("%s", 01839 (elevation > 01840 lastelevation ? 01841 "falls on its back walking up an incline." 01842 : 01843 "falls off the back of a small incline."))); 01844 MechFalls(mech, abs(lastelevation - elevation), 1); 01845 MechDesiredSpeed(mech) = 0; 01846 MechSpeed(mech) = 0; 01847 if(elevation > lastelevation) { 01848 move_unit_back(mech, deltax, deltay, lastelevation, ot, 01849 le); 01850 } 01851 } 01852 return; 01853 } 01854 01855 /* Slow the unit if its made an elevation change */ 01856 le = elevation - lastelevation; 01857 le = (le < 0) ? -le : le; 01858 if(MechZ(mech) != elevation) 01859 le = 0; 01860 if(le > 0) { 01861 deltax = (le == 1) ? MP1 : MP2; 01862 if(MechSpeed(mech) > 0) { 01863 MechSpeed(mech) -= deltax; 01864 if(MechSpeed(mech) < 0) 01865 MechSpeed(mech) = 0; 01866 } else if(MechSpeed(mech) < 0) { 01867 MechSpeed(mech) += deltax; 01868 if(MechSpeed(mech) > 0) 01869 MechSpeed(mech) = 0; 01870 } 01871 } 01872 01873 if(MechType(mech) == CLASS_BSUIT) { 01874 01875 /* Are they in water, also make sure it affects them */ 01876 if(!(MechSpecials2(mech) & WATERPROOF_TECH) && 01877 (MechRTerrain(mech) == WATER || 01878 (MechRTerrain(mech) == BRIDGE && 01879 (lastelevation < (elevation - 1)))) && elevation < 0) { 01880 01881 mech_notify(mech, MECHALL, 01882 "You notice a body of water in front of you"); 01883 01884 if(MechPilot(mech) == -1 || 01885 MadePilotSkillRoll(mech, 01886 (int) (fabs((MechSpeed(mech)) + MP1) / 01887 MP1) / 3)) { 01888 01889 mech_notify(mech, MECHALL, 01890 "You manage to stop before falling in."); 01891 MechLOSBroadcast(mech, 01892 "stops suddenly to avoid going for a swim!"); 01893 } else { 01894 01895 mech_notify(mech, MECHALL, 01896 "You trip at the edge of the water and plunge in..."); 01897 MechFloods(mech); 01898 return; 01899 } 01900 move_unit_back(mech, deltax, deltay, lastelevation, ot, le); 01901 MechDesiredSpeed(mech) = 0; 01902 MechSpeed(mech) = 0; 01903 return; 01904 } 01905 01906 } else if(!(MechSpecials2(mech) & WATERPROOF_TECH) && 01907 ((MechRTerrain(mech) == WATER && MechZ(mech) < 0) || 01908 (MechRTerrain(mech) == BRIDGE && MechZ(mech) < 0) || 01909 (MechRTerrain(mech) == ICE && MechZ(mech) < 0) || 01910 MechRTerrain(mech) == HIGHWATER) && 01911 MechType(mech) != CLASS_MW) { 01912 01913 int skillmod, dammod; 01914 MechDesiredSpeed(mech) = MIN(MechDesiredSpeed(mech), 01915 WalkingSpeed(MMaxSpeed(mech))); 01916 #ifdef BT_MOVEMENT_MODES 01917 if(MechStatus2(mech) & SPRINTING) { 01918 MechLOSBroadcast(mech, 01919 "breaks out of its sprint as it enters water!"); 01920 mech_notify(mech, MECHALL, 01921 "You lose your sprinting momentum as you " 01922 "enter water!"); 01923 if(!MoveModeChange(mech)) 01924 MECHEVENT(mech, EVENT_MOVEMODE, mech_movemode_event, TURN, 01925 MODE_OFF | MODE_SPRINT); 01926 } 01927 #endif 01928 if(IsRunning(MechSpeed(mech), MMaxSpeed(mech))) { 01929 mech_notify(mech, MECHPILOT, 01930 "You struggle to keep control as you run into the water!"); 01931 skillmod = 2; 01932 dammod = 2; 01933 } else { 01934 mech_notify(mech, MECHPILOT, "You use your piloting skill " 01935 "to maneuver through the water."); 01936 skillmod = 0; 01937 dammod = 0; 01938 } 01939 skillmod += (MechRTerrain(mech) == HIGHWATER ? -2 : 01940 MechRTerrain(mech) == 01941 BRIDGE ? bridge_w_elevation(mech) : MechElev(mech) > 01942 3 ? 1 : (MechElev(mech) - 2)); 01943 01944 if(!MadePilotSkillRoll(mech, skillmod)) { 01945 mech_notify(mech, MECHALL, 01946 "You slip in the water and fall down"); 01947 MechLOSBroadcast(mech, "slips in the water and falls down!"); 01948 MechFalls(mech, 1, dammod); 01949 done = 1; 01950 } 01951 } 01952 break; 01953 01954 case MOVE_TRACK: 01955 01956 if(collision_check(mech, WALK_WALL, lastelevation, oldterrain)) { 01957 mech_notify(mech, MECHALL, 01958 "You attempt to climb a hill too steep for you."); 01959 01960 if(MechPilot(mech) == -1 || (!mudconf.btech_skidcliff && 01961 MadePilotSkillRoll_NoXP(mech, 01962 (int) (fabs((MechSpeed (mech)) + MP1) / MP1) / 3, 1)) 01963 || (mudconf.btech_skidcliff && 01964 MadePilotSkillRoll_NoXP(mech, 01965 SkidMod(fabs(MechSpeed(mech)) / MP1), 1))) { 01966 01967 mech_notify(mech, MECHALL, 01968 "You manage to stop before crashing."); 01969 MechLOSBroadcast(mech, "stops suddenly to avoid a cliff!"); 01970 01971 } else { 01972 01973 if(!mudconf.btech_skidcliff) { 01974 mech_notify(mech, MECHALL, "You smash into a cliff!"); 01975 MechLOSBroadcast(mech, "crashes to a cliff!"); 01976 MechFalls(mech, (int) (MechSpeed(mech) * MP_PER_KPH / 4), 01977 0); 01978 } else { 01979 mech_notify(mech, MECHALL, 01980 "You skid to a violent halt!"); 01981 MechLOSBroadcast(mech, "goes into a skid!"); 01982 MechFalls(mech, 0, 0); 01983 } 01984 } 01985 move_unit_back(mech, deltax, deltay, lastelevation, ot, le); 01986 MechDesiredSpeed(mech) = 0; 01987 MechSpeed(mech) = 0; 01988 return; 01989 01990 } else if(collision_check(mech, WALK_DROP, lastelevation, oldterrain)) { 01991 01992 mech_notify(mech, MECHALL, 01993 "You notice a large drop in front of you"); 01994 avoidbth = mudconf.btech_skidcliff ? 01995 SkidMod(fabs(MechSpeed(mech)) / MP1) : 01996 ((fabs((MechSpeed(mech)) + MP1) / MP1) / 3); 01997 if(MechPilot(mech) == -1 || (!MechAutoFall(mech) && 01998 MadePilotSkillRoll_NoXP(mech, 01999 avoidbth,1))) { 02000 mech_notify(mech, MECHALL, 02001 "You manage to stop before falling off."); 02002 MechLOSBroadcast(mech, 02003 "stops suddenly to avoid falling off a cliff!"); 02004 } else { 02005 mech_notify(mech, MECHALL, 02006 "You drive off the cliff and fall to the ground below."); 02007 MechLOSBroadcast(mech, 02008 "drives off a cliff and falls to the ground below."); 02009 MechFalls(mech, lastelevation - elevation, 0); 02010 domino_space(mech, 2); 02011 02012 if(MechRTerrain(mech) == WATER && 02013 !(MechSpecials2(mech) & WATERPROOF_TECH)) { 02014 02015 mech_notify(mech, MECHALL, 02016 "You drive into the water and your vehicle becomes inoperable."); 02017 Destroy(mech); 02018 ChannelEmitKill(mech, mech); 02019 } 02020 02021 return; 02022 } 02023 move_unit_back(mech, deltax, deltay, lastelevation, ot, le); 02024 MechDesiredSpeed(mech) = 0; 02025 MechSpeed(mech) = 0; 02026 return; 02027 02028 } else if(mudconf.btech_roll_on_backwalk && (MechSpeed(mech) < 0) && 02029 (collision_check 02030 (mech, WALK_BACK, lastelevation, oldterrain))) { 02031 02032 mech_printf(mech, MECHALL, "You notice a %s behind you!", 02033 (elevation > 02034 lastelevation ? "small incline" : "small drop")); 02035 02036 if(MechPilot(mech) == -1 || (MadePilotSkillRoll(mech, 02037 collision_check 02038 (mech, WALK_BACK, 02039 lastelevation, 02040 oldterrain) 02041 - 1))) { 02042 02043 mech_notify(mech, MECHALL, 02044 "You manage to overcome the obstacle."); 02045 } else { 02046 mech_printf(mech, MECHALL, "%s", 02047 (elevation > lastelevation ? 02048 "You stumble on your rear and fall down." : 02049 "You fall on your rear off the small incline.")); 02050 MechLOSBroadcast(mech, 02051 tprintf("%s", 02052 (elevation > 02053 lastelevation ? 02054 "falls on its back walking up an incline." 02055 : 02056 "falls off the back of a small incline."))); 02057 MechFalls(mech, abs(lastelevation - elevation), 1); 02058 MechDesiredSpeed(mech) = 0; 02059 MechSpeed(mech) = 0; 02060 if(elevation > lastelevation) { 02061 move_unit_back(mech, deltax, deltay, lastelevation, ot, 02062 le); 02063 } 02064 } 02065 return; 02066 } 02067 02068 if(!(MechSpecials2(mech) & WATERPROOF_TECH) && 02069 (MechRTerrain(mech) == WATER || 02070 (MechRTerrain(mech) == BRIDGE 02071 && (lastelevation < (elevation - 1)))) && elevation < 0) { 02072 02073 mech_notify(mech, MECHALL, 02074 "You notice a body of water in front of you"); 02075 if(MechPilot(mech) == -1 || 02076 MadePilotSkillRoll(mech, 02077 (int) (fabs((MechSpeed(mech)) + MP1) / 02078 MP1) / 3)) { 02079 mech_notify(mech, MECHALL, 02080 "You manage to stop before falling in."); 02081 MechLOSBroadcast(mech, 02082 "stops suddenly to avoid driving into the water!"); 02083 } else { 02084 mech_notify(mech, MECHALL, 02085 "You drive into the water and your vehicle becomes inoperable."); 02086 Destroy(mech); 02087 ChannelEmitKill(mech, mech); 02088 return; 02089 } 02090 move_unit_back(mech, deltax, deltay, lastelevation, ot, le); 02091 MechDesiredSpeed(mech) = 0; 02092 MechSpeed(mech) = 0; 02093 return; 02094 } 02095 02096 /* New terrain restrictions */ 02097 if(mudconf.btech_newterrain) { 02098 tt = MechRTerrain(mech); 02099 if((tt == HEAVY_FOREST) && fabs(MechSpeed(mech)) > MP1) { 02100 02101 #if 0 02102 mech_notify(mech, MECHALL, "You cruise at a bunch of trees!"); 02103 #endif 02104 mech_notify(mech, MECHALL, 02105 "You try to dodge the larger trees.."); 02106 02107 if(MechPilot(mech) == -1 || MadePilotSkillRoll(mech, 02108 (int) (fabs 02109 (MechSpeed 02110 (mech)) 02111 / MP1 / 02112 6))) { 02113 02114 mech_notify(mech, MECHALL, "You manage to dodge 'em!"); 02115 } else { 02116 mech_notify(mech, MECHALL, 02117 "You swerve, but not enough! This'll hurt!"); 02118 MechLOSBroadcast(mech, "cruises headlong at a tree!"); 02119 f = fabs(MechSpeed(mech)); 02120 MechSpeed(mech) = MechSpeed(mech) / 2.0; 02121 MechFalls(mech, MAX(1, (int) sqrt(f / MP1 / 2)), 0); 02122 } 02123 } 02124 } 02125 02126 /* Slow them if they made an elevation change */ 02127 le = elevation - lastelevation; 02128 le = (le < 0) ? -le : le; 02129 if(le > 0) { 02130 deltax = (le == 1) ? MP2 : MP3; 02131 if(MechSpeed(mech) > 0) { 02132 MechSpeed(mech) -= deltax; 02133 if(MechSpeed(mech) < 0) 02134 MechSpeed(mech) = 0; 02135 } else if(MechSpeed(mech) < 0) { 02136 MechSpeed(mech) += deltax; 02137 if(MechSpeed(mech) > 0) 02138 MechSpeed(mech) = 0; 02139 } 02140 } 02141 break; 02142 02143 case MOVE_WHEEL: 02144 02145 /* Cliff ! */ 02146 if(collision_check(mech, WALK_WALL, lastelevation, oldterrain)) { 02147 02148 mech_notify(mech, MECHALL, 02149 "You attempt to climb a hill too steep for you."); 02150 02151 if(MechPilot(mech) == -1 || (!mudconf.btech_skidcliff && 02152 MadePilotSkillRoll_NoXP(mech, 02153 (int) (fabs((MechSpeed (mech)) + MP1) / MP1) / 3, 1)) 02154 || (mudconf.btech_skidcliff && 02155 MadePilotSkillRoll_NoXP(mech, 02156 SkidMod(fabs(MechSpeed(mech)) / MP1), 1))) { 02157 02158 mech_notify(mech, MECHALL, 02159 "You manage to stop before crashing."); 02160 MechLOSBroadcast(mech, "stops suddenly to avoid a cliff!"); 02161 02162 } else { 02163 02164 if(!mudconf.btech_skidcliff) { 02165 mech_notify(mech, MECHALL, "You smash into a cliff!"); 02166 MechLOSBroadcast(mech, "crashes to a cliff!"); 02167 MechFalls(mech, (int) (MechSpeed(mech) * MP_PER_KPH / 4), 02168 0); 02169 } else { 02170 mech_notify(mech, MECHALL, "You skid to a violent halt!"); 02171 MechLOSBroadcast(mech, "skids to a halt!"); 02172 MechFalls(mech, 0, 0); 02173 } 02174 } 02175 02176 move_unit_back(mech, deltax, deltay, lastelevation, ot, le); 02177 MechDesiredSpeed(mech) = 0; 02178 MechSpeed(mech) = 0; 02179 return; 02180 02181 } else if(collision_check(mech, WALK_DROP, lastelevation, oldterrain)) { 02182 02183 mech_notify(mech, MECHALL, 02184 "You notice a large drop in front of you"); 02185 avoidbth = mudconf.btech_skidcliff ? 02186 SkidMod(fabs(MechSpeed(mech)) / MP1) : 02187 ((fabs((MechSpeed(mech)) + MP1) / MP1) / 3); 02188 02189 if(MechPilot(mech) == -1 || (!MechAutoFall(mech) && 02190 MadePilotSkillRoll_NoXP(mech, 02191 avoidbth,1))) { 02192 02193 mech_notify(mech, MECHALL, 02194 "You manage to stop before falling off."); 02195 MechLOSBroadcast(mech, 02196 "stops suddenly to avoid driving off a cliff!"); 02197 } else { 02198 mech_notify(mech, MECHALL, 02199 "You drive off the cliff and fall to the ground below."); 02200 MechLOSBroadcast(mech, 02201 "drives off a cliff and falls to the ground below."); 02202 MechFalls(mech, lastelevation - elevation, 0); 02203 domino_space(mech, 2); 02204 02205 if(MechRTerrain(mech) == WATER && 02206 !(MechSpecials2(mech) & WATERPROOF_TECH)) { 02207 02208 mech_notify(mech, MECHALL, 02209 "You drive into the water and your vehicle becomes inoperable."); 02210 Destroy(mech); 02211 ChannelEmitKill(mech, mech); 02212 } 02213 02214 return; 02215 } 02216 move_unit_back(mech, deltax, deltay, lastelevation, ot, le); 02217 MechDesiredSpeed(mech) = 0; 02218 MechSpeed(mech) = 0; 02219 return; 02220 02221 } else if(mudconf.btech_roll_on_backwalk && 02222 (MechSpeed(mech) < 0) && 02223 (collision_check 02224 (mech, WALK_BACK, lastelevation, oldterrain))) { 02225 02226 mech_printf(mech, MECHALL, "You notice a %s behind you!", 02227 (elevation > 02228 lastelevation ? "small incline" : "small drop")); 02229 02230 if(MechPilot(mech) == -1 || (MadePilotSkillRoll(mech, 02231 collision_check 02232 (mech, WALK_BACK, 02233 lastelevation, 02234 oldterrain) 02235 - 1))) { 02236 mech_notify(mech, MECHALL, 02237 "You manage to overcome the obstacle."); 02238 } else { 02239 mech_printf(mech, MECHALL, "%s", 02240 (elevation > lastelevation ? 02241 "You stumble on your rear and fall down." : 02242 "You fall on your rear off the small incline.")); 02243 MechLOSBroadcast(mech, 02244 tprintf("%s", (elevation > lastelevation ? 02245 "falls on its back walking up an incline." 02246 : 02247 "falls off the back of a small incline."))); 02248 MechFalls(mech, abs(lastelevation - elevation), 1); 02249 MechDesiredSpeed(mech) = 0; 02250 MechSpeed(mech) = 0; 02251 if(elevation > lastelevation) { 02252 move_unit_back(mech, deltax, deltay, lastelevation, ot, 02253 le); 02254 } 02255 } 02256 return; 02257 } 02258 02259 if(!(MechSpecials2(mech) & WATERPROOF_TECH) && 02260 (MechRTerrain(mech) == WATER || 02261 (MechRTerrain(mech) == BRIDGE 02262 && (lastelevation < (elevation - 1)))) && elevation < 0) { 02263 02264 mech_notify(mech, MECHALL, 02265 "You notice a body of water in front of you"); 02266 02267 if(MechPilot(mech) == -1 || 02268 MadePilotSkillRoll(mech, 02269 (int) (fabs((MechSpeed(mech)) + MP1) / 02270 MP1) / 3)) { 02271 02272 mech_notify(mech, MECHALL, 02273 "You manage to stop before falling in."); 02274 MechLOSBroadcast(mech, 02275 "stops suddenly to driving into the water!"); 02276 } else { 02277 mech_notify(mech, MECHALL, 02278 "You drive into the water and your vehicle becomes inoperable."); 02279 Destroy(mech); 02280 ChannelEmitKill(mech, mech); 02281 return; 02282 } 02283 move_unit_back(mech, deltax, deltay, lastelevation, ot, le); 02284 MechDesiredSpeed(mech) = 0; 02285 MechSpeed(mech) = 0; 02286 return; 02287 } 02288 02289 /* New terrain restrictions */ 02290 if(mudconf.btech_newterrain) { 02291 tt = MechRTerrain(mech); 02292 if((tt == HEAVY_FOREST || tt == LIGHT_FOREST) && 02293 fabs(MechSpeed(mech)) > MP1) { 02294 02295 #if 0 02296 mech_notify(mech, MECHALL, "You cruise at a bunch of trees!"); 02297 #endif 02298 mech_notify(mech, MECHALL, 02299 "You try to dodge the larger trees.."); 02300 if(MechPilot(mech) == -1 || 02301 MadePilotSkillRoll(mech, 02302 (tt == HEAVY_FOREST ? 3 : 0) + 02303 (fabs(MechSpeed(mech)) / MP1 / 6))) { 02304 02305 mech_notify(mech, MECHALL, "You manage to dodge 'em!"); 02306 02307 } else { 02308 mech_notify(mech, MECHALL, 02309 "You swerve, but not enough! This'll hurt!"); 02310 MechLOSBroadcast(mech, "cruises headlong at a tree!"); 02311 f = fabs(MechSpeed(mech)); 02312 MechSpeed(mech) = MechSpeed(mech) / 2.0; 02313 MechFalls(mech, MAX(1, (int) sqrt(f / MP1 / 2)), 0); 02314 } 02315 02316 } else if((tt == ROUGH) && fabs(MechSpeed(mech)) > MP1) { 02317 #if 0 02318 mech_notify(mech, MECHALL, 02319 "You cruise at some rough terrain!"); 02320 #endif 02321 mech_notify(mech, MECHALL, "You try to avoid the rocks.."); 02322 if(MechPilot(mech) == -1 || MadePilotSkillRoll(mech, 02323 (int) (fabs 02324 (MechSpeed 02325 (mech)) 02326 / MP1 / 02327 6))) { 02328 mech_notify(mech, MECHALL, "You manage to dodge 'em!"); 02329 } else { 02330 mech_notify(mech, MECHALL, 02331 "You swerve, but not enough! This'll hurt!"); 02332 MechLOSBroadcast(mech, "cruises headlong at a rock!"); 02333 f = fabs(MechSpeed(mech)); 02334 MechSpeed(mech) = MechSpeed(mech) / 2.0; 02335 MechFalls(mech, MAX(1, (int) sqrt(f / MP1 / 2)), 0); 02336 } 02337 } 02338 } 02339 02340 /* Slow them down if they change elevations */ 02341 le = elevation - lastelevation; 02342 le = (le < 0) ? -le : le; 02343 if(le > 0) { 02344 deltax = (le == 1) ? MP2 : MP3; 02345 if(MechSpeed(mech) > 0) { 02346 MechSpeed(mech) -= deltax; 02347 if(MechSpeed(mech) < 0) 02348 MechSpeed(mech) = 0; 02349 } else if(MechSpeed(mech) < 0) { 02350 MechSpeed(mech) += deltax; 02351 if(MechSpeed(mech) > 0) 02352 MechSpeed(mech) = 0; 02353 } 02354 } 02355 break; 02356 02357 case MOVE_HULL: 02358 case MOVE_FOIL: 02359 case MOVE_SUB: 02360 02361 if((MechRTerrain(mech) != WATER && MechRTerrain(mech) != BRIDGE) 02362 || abs(MechElev(mech)) < (abs(MechZ(mech)) + (MechMove(mech) == 02363 MOVE_FOIL ? -1 : 0))) 02364 { 02365 /* Run aground */ 02366 MechElev(mech) = le; 02367 MechTerrain(mech) = ot; 02368 mech_notify(mech, MECHALL, 02369 "You attempt to get too close with ground!"); 02370 if(MechPilot(mech) == -1 || 02371 MadePilotSkillRoll(mech, 02372 (int) (fabs((MechSpeed(mech)) + MP1) / 02373 MP1) / 3)) { 02374 mech_notify(mech, MECHALL, 02375 "You manage to stop before crashing."); 02376 MechLOSBroadcast(mech, 02377 "stops suddenly to avoid running aground!"); 02378 move_unit_back(mech, deltax, deltay, lastelevation, ot, le); 02379 } else { 02380 mech_notify(mech, MECHALL, "You smash into the ground!"); 02381 MechLOSBroadcast(mech, "smashes aground!"); 02382 MechFalls(mech, (int) (MechSpeed(mech) * MP_PER_KPH / 4), 0); 02383 } 02384 MechSpeed(mech) = 0; 02385 MechDesiredSpeed(mech) = 0; 02386 MechVerticalSpeed(mech) = 0; 02387 return; 02388 } 02389 if(elevation > 0) 02390 elevation = 0; 02391 break; 02392 02393 case MOVE_HOVER: 02394 02395 if(collision_check(mech, WALK_WALL, lastelevation, oldterrain)) { 02396 MechElev(mech) = le; 02397 MechTerrain(mech) = ot; 02398 mech_notify(mech, MECHALL, 02399 "You attempt to climb a hill too steep for you."); 02400 if(MechPilot(mech) == -1 || (!mudconf.btech_skidcliff && 02401 MadePilotSkillRoll_NoXP(mech, 02402 (int) (fabs((MechSpeed (mech)) + MP1) / MP1) / 3, 1)) 02403 || (mudconf.btech_skidcliff && 02404 MadePilotSkillRoll_NoXP(mech, 02405 SkidMod(fabs(MechSpeed(mech)) / MP1), 1))) { 02406 02407 mech_notify(mech, MECHALL, 02408 "You manage to stop before crashing."); 02409 MechLOSBroadcast(mech, "stops suddenly to avoid a cliff!"); 02410 02411 } else { 02412 02413 if(!mudconf.btech_skidcliff) { 02414 mech_notify(mech, MECHALL, "You smash into a cliff!"); 02415 MechLOSBroadcast(mech, "smashes into a cliff!"); 02416 MechFalls(mech, 02417 (int) (MechSpeed(mech) * MP_PER_KPH / 4), 0); 02418 } else { 02419 mech_notify(mech, MECHALL, "You skid to a violent halt!"); 02420 MechLOSBroadcast(mech, "skids to a halt!"); 02421 MechFalls(mech, 0, 0); 02422 } 02423 } 02424 move_unit_back(mech, deltax, deltay, lastelevation, ot, le); 02425 MechDesiredSpeed(mech) = 0; 02426 MechSpeed(mech) = 0; 02427 return; 02428 02429 } else if(collision_check(mech, WALK_DROP, lastelevation, oldterrain)) { 02430 02431 mech_notify(mech, MECHALL, 02432 "You notice a large drop in front of you"); 02433 02434 avoidbth = mudconf.btech_skidcliff ? 02435 SkidMod(fabs(MechSpeed(mech)) / MP1) : 02436 ((fabs((MechSpeed(mech)) + MP1) / MP1) / 3); 02437 02438 if(MechPilot(mech) == -1 || (!MechAutoFall(mech) && 02439 MadePilotSkillRoll_NoXP(mech, 02440 avoidbth,1))) { 02441 02442 mech_notify(mech, MECHALL, 02443 "You manage to stop before falling off."); 02444 MechLOSBroadcast(mech, 02445 "stops suddenly to avoid falling off a cliff!"); 02446 02447 } else { 02448 02449 mech_notify(mech, MECHALL, 02450 "You drive off the cliff and fall to the ground below."); 02451 MechLOSBroadcast(mech, 02452 "drives off a cliff and falls to the ground below."); 02453 MechFalls(mech, lastelevation - elevation, 0); 02454 return; 02455 } 02456 02457 move_unit_back(mech, deltax, deltay, lastelevation, ot, le); 02458 MechDesiredSpeed(mech) = 0; 02459 MechSpeed(mech) = 0; 02460 return; 02461 02462 } else if(collision_check(mech, HIT_UNDER_BRIDGE, lastelevation, 02463 oldterrain)) { 02464 02465 mech_notify(mech, MECHALL, 02466 "You notice the underside of the bridge in front of you!"); 02467 02468 if(MechPilot(mech) == -1 || (!mudconf.btech_skidcliff && 02469 MadePilotSkillRoll(mech, 02470 (int) (fabs 02471 ((MechSpeed 02472 (mech)) + 02473 MP1) / 02474 MP1) / 3)) 02475 || (mudconf.btech_skidcliff 02476 && MadePilotSkillRoll(mech, 02477 SkidMod(fabs(MechSpeed(mech)) / 02478 MP1)))) { 02479 02480 mech_notify(mech, MECHALL, 02481 "You manage to stop before slamming into the bridge."); 02482 MechLOSBroadcast(mech, 02483 "stops suddenly to avoid slamming into the bridge!"); 02484 } else { 02485 mech_notify(mech, MECHALL, 02486 "You drive right into the underside of the bridge."); 02487 MechLOSBroadcast(mech, 02488 "drives right into the underside of the bridge."); 02489 MechFalls(mech, 1, 0); 02490 } 02491 move_unit_back(mech, deltax, deltay, lastelevation, ot, le); 02492 MechDesiredSpeed(mech) = 0; 02493 MechSpeed(mech) = 0; 02494 return; 02495 02496 } else if(mudconf.btech_roll_on_backwalk && 02497 (MechSpeed(mech) < 0) && 02498 (collision_check 02499 (mech, WALK_BACK, lastelevation, oldterrain)) 02500 && !isunder) { 02501 02502 mech_printf(mech, MECHALL, "You notice a %s behind you!", 02503 (elevation > 02504 lastelevation ? "small incline" : "small drop")); 02505 02506 if(MechPilot(mech) == -1 || (MadePilotSkillRoll(mech, 02507 collision_check 02508 (mech, WALK_BACK, 02509 lastelevation, 02510 oldterrain) 02511 - 1))) { 02512 02513 mech_notify(mech, MECHALL, 02514 "You manage to overcome the obstacle."); 02515 02516 } else { 02517 02518 mech_printf(mech, MECHALL, "%s", 02519 (elevation > lastelevation ? 02520 "You stumble on your rear and fall down." : 02521 "You fall on your rear off the small incline.")); 02522 MechLOSBroadcast(mech, 02523 tprintf("%s", (elevation > lastelevation ? 02524 "falls on its back walking up an incline." 02525 : 02526 "falls off the back of a small incline."))); 02527 MechFalls(mech, abs(lastelevation - elevation), 1); 02528 MechDesiredSpeed(mech) = 0; 02529 MechSpeed(mech) = 0; 02530 if(elevation > lastelevation) { 02531 move_unit_back(mech, deltax, deltay, lastelevation, ot, 02532 le); 02533 } 02534 } 02535 return; 02536 } 02537 02538 tt = MechRTerrain(mech); 02539 if((tt == HEAVY_FOREST || tt == LIGHT_FOREST) && 02540 fabs(MechSpeed(mech)) > MP1) { 02541 #if 0 02542 mech_notify(mech, MECHALL, "You cruise at a bunch of trees!"); 02543 #endif 02544 mech_notify(mech, MECHALL, "You try to dodge the larger trees.."); 02545 02546 if(MechPilot(mech) == -1 || 02547 MadePilotSkillRoll(mech, 02548 (tt == HEAVY_FOREST ? 3 : 0) + 02549 (fabs(MechSpeed(mech)) / MP1 / 6))) { 02550 02551 mech_notify(mech, MECHALL, "You manage to dodge 'em!"); 02552 02553 } else { 02554 mech_notify(mech, MECHALL, 02555 "You swerve, but not enough! This'll hurt!"); 02556 MechLOSBroadcast(mech, "cruises headlong at a tree!"); 02557 f = fabs(MechSpeed(mech)); 02558 MechSpeed(mech) = MechSpeed(mech) / 2.0; 02559 MechFalls(mech, MAX(1, (int) sqrt(f / MP1 / 2)), 0); 02560 } 02561 } 02562 02563 /* Slow the unit down if its made an elevation change */ 02564 le = elevation - lastelevation; 02565 le = (le < 0) ? -le : le; 02566 if(le > 0) { 02567 deltax = (le == 1) ? MP2 : MP3; 02568 if(MechSpeed(mech) > 0) { 02569 MechSpeed(mech) -= deltax; 02570 if(MechSpeed(mech) < 0) 02571 MechSpeed(mech) = 0; 02572 } else if(MechSpeed(mech) < 0) { 02573 MechSpeed(mech) += deltax; 02574 if(MechSpeed(mech) > 0) 02575 MechSpeed(mech) = 0; 02576 } 02577 } 02578 break; 02579 02580 case MOVE_VTOL: 02581 case MOVE_FLY: 02582 02583 if((Landed(mech) && MechRTerrain(mech) != ROAD && 02584 MechRTerrain(mech) != BRIDGE && MechRTerrain(mech) != GRASSLAND 02585 && MechRTerrain(mech) != BUILDING) || 02586 (IsForest(MechRTerrain(mech)) && MechZ(mech) < (MechElevation(mech)+2))) { 02587 02588 mech_notify(mech, MECHALL, 02589 "You go where no flying thing has ever gone before.."); 02590 if(RGotPilot(mech) && MadePilotSkillRoll(mech, 5)) { 02591 mech_notify(mech, MECHALL, "You stop in time!"); 02592 move_unit_back(mech, deltax, deltay, lastelevation, ot, le); 02593 } else { 02594 mech_notify(mech, MECHALL, 02595 "Eww.. You've a bad feeling about this."); 02596 MechLOSBroadcast(mech, "crashes!"); 02597 MechFalls(mech, 1, 0); 02598 } 02599 MechDesiredSpeed(mech) = 0; 02600 MechSpeed(mech) = 0; 02601 return; 02602 02603 } else if(Landed(mech) && mudconf.btech_roll_on_backwalk && 02604 (MechSpeed(mech) < 0) && 02605 (collision_check 02606 (mech, WALK_BACK, lastelevation, oldterrain))) { 02607 02608 mech_printf(mech, MECHALL, "You notice a %s behind you!", 02609 (elevation > 02610 lastelevation ? "small incline" : "small drop")); 02611 02612 if(MechPilot(mech) == -1 || (MadePilotSkillRoll(mech, 02613 collision_check 02614 (mech, WALK_BACK, 02615 lastelevation, 02616 oldterrain) 02617 - 1))) { 02618 02619 mech_notify(mech, MECHALL, 02620 "You manage to overcome the obstacle."); 02621 02622 } else { 02623 02624 mech_printf(mech, MECHALL, "%s", (elevation > lastelevation ? 02625 "You stumble on your rear and fall down." 02626 : 02627 "You fall on your rear off the small incline.")); 02628 MechLOSBroadcast(mech, 02629 tprintf("%s", 02630 (elevation > 02631 lastelevation ? 02632 "falls on its back walking up an incline." 02633 : 02634 "falls off the back of a small incline."))); 02635 MechFalls(mech, (abs(lastelevation - elevation) + 1000), 1); 02636 MechDesiredSpeed(mech) = 0; 02637 MechSpeed(mech) = 0; 02638 if(elevation > lastelevation) { 02639 move_unit_back(mech, deltax, deltay, lastelevation, ot, 02640 le); 02641 } 02642 } 02643 return; 02644 } 02645 02646 if(MechRTerrain(mech) == WATER) 02647 return; 02648 02649 if(MechRTerrain(mech) == LIGHT_FOREST || 02650 MechRTerrain(mech) == HEAVY_FOREST) 02651 elevation = MechElevation(mech) + 2; 02652 else 02653 elevation = MechElevation(mech); 02654 02655 if(collision_check(mech, JUMP, 0, 0)) { 02656 MechFX(mech) -= deltax; 02657 MechFY(mech) -= deltay; 02658 MechX(mech) = MechLastX(mech); 02659 MechY(mech) = MechLastY(mech); 02660 MechZ(mech) = lastelevation; 02661 MechFZ(mech) = MechZ(mech) * ZSCALE; 02662 MechElev(mech) = le; 02663 MechTerrain(mech) = ot; 02664 mech_notify(mech, MECHALL, 02665 "You attempt to fly over elevation that is too high!"); 02666 02667 if(MechPilot(mech) == -1 || (MadePilotSkillRoll(mech, 02668 (int) (MechFZ 02669 (mech) / 02670 ZSCALE / 02671 3)) 02672 && (ot == GRASSLAND || ot == ROAD 02673 || ot == BUILDING))) { 02674 02675 mech_notify(mech, MECHALL, "You land safely."); 02676 MechStatus(mech) |= LANDED; 02677 MechSpeed(mech) = 0.0; 02678 MechVerticalSpeed(mech) = 0.0; 02679 02680 } else { 02681 mech_notify(mech, MECHALL, 02682 "You crash into the obstacle and fall from the sky!"); 02683 MechLOSBroadcast(mech, 02684 "crashes into an obstacle and falls from the sky!"); 02685 MechFalls(mech, MechsElevation(mech) + 1, 0); 02686 domino_space(mech, 2); 02687 } 02688 } 02689 break; 02690 } 02691 02692 if(!done) { 02693 possible_mine_poof(mech, MINE_STEP); 02694 if(mudconf.btech_fasaadvvhlfire && 02695 (MechType(mech) == CLASS_VEH_GROUND) && 02696 (MechTerrain(mech) == FIRE)) 02697 checkVehicleInFire(mech, 1); 02698 } 02699 }
| int OverheatMods | ( | MECH * | mech | ) |
Definition at line 1114 of file mech.update.c.
References MechHeat.
Referenced by FindNormalBTH().
01115 { 01116 int returnValue; 01117 01118 if(MechHeat(mech) >= 24.) { 01119 /* +4 to fire... */ 01120 returnValue = 4; 01121 } else if(MechHeat(mech) >= 17.) { 01122 /* +3 to fire... */ 01123 returnValue = 3; 01124 } else if(MechHeat(mech) >= 13.) { 01125 /* +2 to fire... */ 01126 returnValue = 2; 01127 } else if(MechHeat(mech) >= 8.) { 01128 /* +1 to fire... */ 01129 returnValue = 1; 01130 } else { 01131 returnValue = 0; 01132 } 01133 return (returnValue); 01134 }
| int recycle_weaponry | ( | MECH * | mech | ) |
Definition at line 1529 of file mech.update.c.
References arc_override, ArmorStringFromIndex(), CLASS_BSUIT, CLASS_MECH, CLASS_MW, CLASS_VEH_GROUND, CLASS_VTOL, Destroyed, FAIL_DESTROYED, FindWeapons, GetPartData, GetPartFireMode, MAX_WEAPS_SECTION, mech_printf(), MechLWRT, MechMove, MechSections, MECHSTARTED, MechType, MechWeapons, muxevent_tick, name, NUM_SECTIONS, PartTempNuke, ROCKET_FIRED, SectIsDestroyed, SetPartTempNuke, Started, and WpnIsRecycling.
Referenced by PrintEnemyWeaponStatus().
01530 { 01531 01532 int loop; 01533 int count, i; 01534 int crit[MAX_WEAPS_SECTION]; 01535 unsigned char weaptype[MAX_WEAPS_SECTION]; 01536 unsigned char weapdata[MAX_WEAPS_SECTION]; 01537 char location[20]; 01538 01539 int diff = (muxevent_tick - MechLWRT(mech)); 01540 int lowest = 0; 01541 01542 if(diff < 1) { 01543 if(diff < 0) 01544 MechLWRT(mech) = muxevent_tick; 01545 return 1; 01546 } 01547 MechLWRT(mech) = muxevent_tick; 01548 01549 if(!Started(mech) || Destroyed(mech)) 01550 return 0; 01551 01552 arc_override = 1; 01553 for(loop = 0; loop < NUM_SECTIONS; loop++) { 01554 count = FindWeapons(mech, loop, weaptype, weapdata, crit); 01555 for(i = 0; i < count; i++) { 01556 if(WpnIsRecycling(mech, loop, crit[i])) { 01557 /* Immediate recycle if its destroyed */ 01558 if(PartTempNuke(mech, loop, crit[i]) == FAIL_DESTROYED) 01559 GetPartData(mech, loop, crit[i]) = 0; 01560 if(diff >= GetPartData(mech, loop, crit[i])) { 01561 GetPartData(mech, loop, crit[i]) = 0; 01562 mech_printf(mech, MECHSTARTED, 01563 MechType(mech) == 01564 CLASS_MW ? 01565 "%%cgYou are ready to attack again with %s.%%c" 01566 : PartTempNuke(mech, loop, 01567 crit[i]) != 01568 0 ? "%%cg%s is operational again.%%c" : 01569 (GetPartFireMode(mech, loop, 01570 crit[i]) & ROCKET_FIRED) ? "" 01571 : "%%cg%s finished recycling.%%c", 01572 &MechWeapons[weaptype[i]].name[3]); 01573 SetPartTempNuke(mech, loop, crit[i], 0); 01574 } else { 01575 if(PartTempNuke(mech, loop, crit[i]) != FAIL_DESTROYED) { 01576 GetPartData(mech, loop, crit[i]) -= diff; 01577 if(GetPartData(mech, loop, crit[i]) < lowest || 01578 !lowest) 01579 lowest = GetPartData(mech, loop, crit[i]); 01580 } 01581 } 01582 } 01583 } 01584 01585 /* Cycle a section */ 01586 if(MechSections(mech)[loop].recycle && ((MechType(mech) == CLASS_MECH) 01587 || (MechType(mech) == 01588 CLASS_BSUIT) 01589 || (MechType(mech) == 01590 CLASS_VEH_GROUND) 01591 || (MechType(mech) == 01592 CLASS_VTOL))) { 01593 01594 /* Is the section finished cycling or do we deincrement it */ 01595 if(diff >= MechSections(mech)[loop].recycle && 01596 !SectIsDestroyed(mech, loop)) { 01597 01598 MechSections(mech)[loop].recycle = 0; 01599 ArmorStringFromIndex(loop, location, MechType(mech), 01600 MechMove(mech)); 01601 01602 mech_printf(mech, MECHSTARTED, 01603 "%%cg%s%s has finished its previous action.%%c", 01604 MechType(mech) == CLASS_BSUIT ? "" : "Your ", 01605 location); 01606 01607 } else { 01608 01609 MechSections(mech)[loop].recycle -= diff; 01610 if(MechSections(mech)[loop].recycle < lowest || !lowest) 01611 lowest = MechSections(mech)[loop].recycle; 01612 01613 } 01614 01615 } 01616 01617 } 01618 arc_override = 0; 01619 return lowest; 01620 }
| int SkidMod | ( | float | Speed | ) |
Definition at line 1622 of file mech.update.c.
Referenced by NewHexEntered().
01623 { 01624 if(Speed < 2.1) 01625 return -1; 01626 if(Speed < 4.1) 01627 return 0; 01628 if(Speed < 7.1) 01629 return 1; 01630 if(Speed < 10.1) 01631 return 2; 01632 return 4; 01633 }
| float terrain_speed | ( | MECH * | mech, | |
| float | tempspeed, | |||
| float | maxspeed, | |||
| int | terrain, | |||
| int | elev | |||
| ) |
Definition at line 936 of file mech.update.c.
References BRIDGE, CLASS_BSUIT, DECREASE, HEAVY_FOREST, ICE, INCREASE_OLD, LIGHT_FOREST, MechIsBiped, MechIsQuad, MechMove, MechStatus2, MechType, MechZ, MOUNTAINS, MOVE_TRACK, MOVE_WHEEL, MP1, MP2, MP3, ROAD, ROUGH, SNOW, SPRINTING, and WATER.
00938 { 00939 switch (terrain) { 00940 case SNOW: 00941 case ROUGH: 00942 DECREASE(MP1); 00943 break; 00944 case MOUNTAINS: 00945 DECREASE(MP2); 00946 break; 00947 case LIGHT_FOREST: 00948 if(MechType(mech) != CLASS_BSUIT) 00949 DECREASE(MP1); 00950 break; 00951 case HEAVY_FOREST: 00952 if(MechType(mech) != CLASS_BSUIT) 00953 DECREASE(MP2); 00954 break; 00955 case BRIDGE: 00956 case ROAD: 00957 /* Ground units (wheeled and tracked) get +1 MP moving on paved surface */ 00958 #ifndef BT_MOVEMENT_MODES 00959 if(MechMove(mech) == MOVE_TRACK || MechMove(mech) == MOVE_WHEEL) 00960 #else 00961 if(!(MechStatus2(mech) & SPRINTING) && 00962 (MechMove(mech) == MOVE_TRACK || MechMove(mech) == MOVE_WHEEL)) 00963 #endif 00964 INCREASE_OLD(MP1); 00965 case ICE: 00966 if(MechZ(mech) >= 0) 00967 break; 00968 /* FALLTHRU */ 00969 /* if he's under the ice/bridge, treat as water. */ 00970 case WATER: 00971 if(MechIsBiped(mech) || MechIsQuad(mech)) { 00972 if(elev <= -2) 00973 DECREASE(MP3); 00974 else if(elev == -1) 00975 DECREASE(MP1); 00976 } 00977 break; 00978 } 00979 return tempspeed; 00980 }
| void updateAutoturnTurret | ( | MECH * | mech | ) |
Definition at line 2899 of file mech.update.c.
References AcceptableDegree(), Blinded, FindBearing(), getMech(), GetSectInt, MapCoordToRealCoord(), MarkForLOSUpdate(), MechFacing, MechFX, MechFY, MechTankCritStatus, MechTarget, MechTargX, MechTargY, MechTurretFacing, Started, TURRET, TURRET_JAMMED, TURRET_LOCKED, and Uncon.
Referenced by mech_update().
02900 { 02901 MECH *target; 02902 int bearing; 02903 float fx, fy; 02904 02905 if(!Started(mech) || Uncon(mech) || Blinded(mech)) 02906 return; 02907 02908 if((MechTankCritStatus(mech) & TURRET_JAMMED) || 02909 (MechTankCritStatus(mech) & TURRET_LOCKED)) 02910 return; 02911 02912 if(!GetSectInt(mech, TURRET)) 02913 return; 02914 02915 if(MechTarget(mech) == -1 && (MechTargY(mech) == -1 || 02916 MechTargX(mech) == -1)) 02917 return; 02918 02919 if(MechTarget(mech) != -1) { 02920 target = getMech(MechTarget(mech)); 02921 fx = MechFX(target); 02922 fy = MechFY(target); 02923 } else { 02924 MapCoordToRealCoord(MechTargX(mech), MechTargY(mech), &fx, &fy); 02925 } 02926 02927 bearing = 02928 AcceptableDegree(FindBearing(MechFX(mech), MechFY(mech), fx, 02929 fy) - MechFacing(mech)); 02930 MechTurretFacing(mech) = bearing; 02931 MarkForLOSUpdate(mech); 02932 }
| void UpdateHeading | ( | MECH * | mech | ) |
Definition at line 825 of file mech.update.c.
References ACCEL_MOD, AddFacing, AddRFacing, confdata::btech_fasaturn, CHEAD, CLASS_BSUIT, CLASS_MW, EVADING, FASA_TURN_MOD, FindObjectsData(), GetTurnMode, HasBoolAdvantage(), is_aero, IsDS, IsRunning, Jumping, JumpSpeedMP, MECH::mapindex, MarkForLOSUpdate(), MechCritStatus, MechDesiredFacing, MechFacing, MechHeat, MechIsQuad, MechPilot, MechRFacing, MechSpecials, MechSpeed, MechStatus2, MechType, MMaxSpeed, MOVE_MOD, MP1, MP_PER_KPH, mudconf, SetRFacing, SHO2FSIM, SPRINTING, and TRIPLE_MYOMER_TECH.
Referenced by aero_move_event(), aero_UpdateHeading(), and mech_move_event().
00826 { 00827 int offset; 00828 int normangle; 00829 int mw_mod = 1; 00830 float maxspeed, omaxspeed; 00831 MAP *mech_map; 00832 00833 if(MechFacing(mech) == MechDesiredFacing(mech)) 00834 return; 00835 maxspeed = MMaxSpeed(mech); 00836 if(is_aero(mech)) 00837 maxspeed = maxspeed * ACCEL_MOD; 00838 if((MechHeat(mech) >= 9.) && (MechSpecials(mech) & TRIPLE_MYOMER_TECH)) 00839 maxspeed += 1.5 * MP1; 00840 omaxspeed = maxspeed; 00841 normangle = MechRFacing(mech) - SHO2FSIM(MechDesiredFacing(mech)); 00842 if(MechType(mech) == CLASS_MW || MechType(mech) == CLASS_BSUIT) 00843 mw_mod = 60; 00844 else if(MechIsQuad(mech)) 00845 mw_mod = 2; 00846 if(mudconf.btech_fasaturn) { 00847 #define FASA_TURN_MOD 3/2 00848 if(Jumping(mech)) 00849 offset = 2 * SHO2FSIM(1) * 2 * 360 * FASA_TURN_MOD / 60; 00850 else { 00851 float ts = MechSpeed(mech); 00852 00853 if(ts < 0) { 00854 maxspeed = maxspeed * 2.0 / 3.0; 00855 ts = -ts; 00856 } 00857 if(ts > maxspeed || maxspeed < 0.1) /* kludge */ 00858 offset = 0; 00859 else { 00860 offset = SHO2FSIM(1) * 2 * 360 * FASA_TURN_MOD / 60 * (maxspeed - ts) * (omaxspeed / maxspeed) * mw_mod * MP_PER_KPH / 6; /* hmm. */ 00861 } 00862 } 00863 } else { 00864 if(Jumping(mech)) { 00865 mech_map = FindObjectsData(mech->mapindex); 00866 offset = SHO2FSIM(1) * 6 * JumpSpeedMP(mech, mech_map) * mw_mod; 00867 } else if(fabs(MechSpeed(mech)) < 1.0) 00868 offset = SHO2FSIM(1) * 3 * maxspeed * MP_PER_KPH * mw_mod; 00869 else { 00870 offset = SHO2FSIM(1) * 2 * maxspeed * MP_PER_KPH * mw_mod; 00871 if((SHO2FSIM(abs(normangle)) > offset) && 00872 IsRunning(MechSpeed(mech), maxspeed)) { 00873 if(MechSpeed(mech) > maxspeed) 00874 offset -= offset / 2 * maxspeed / MechSpeed(mech); 00875 else 00876 offset -= 00877 offset / 2 * (3.0 * MechSpeed(mech) / maxspeed - 2.0); 00878 } 00879 } 00880 } 00881 /* offset = offset * 2 * MOVE_MOD; - Twice as fast as this;dunno why - */ 00882 offset = offset * MOVE_MOD; 00883 #ifdef BT_MOVEMENT_MODES 00884 if(GetTurnMode(mech) 00885 && HasBoolAdvantage(MechPilot(mech), "maneuvering_ace")) 00886 offset = (offset * 3) / 2; 00887 if(MechStatus2(mech) & (SPRINTING | EVADING) 00888 && !HasBoolAdvantage(MechPilot(mech), "maneuvering_ace")) { 00889 if(HasBoolAdvantage(MechPilot(mech), "speed_demon")) 00890 offset = (offset * 2) / 3; 00891 else 00892 offset = (offset / 2); 00893 } 00894 #endif 00895 if(normangle < 0) 00896 normangle += SHO2FSIM(360); 00897 if(IsDS(mech) && offset >= SHO2FSIM(10)) 00898 offset = SHO2FSIM(10); 00899 if(normangle > SHO2FSIM(180)) { 00900 AddRFacing(mech, offset); 00901 if(MechFacing(mech) >= 360) 00902 AddFacing(mech, -360); 00903 normangle += offset; 00904 if(normangle >= SHO2FSIM(360)) 00905 SetRFacing(mech, SHO2FSIM(MechDesiredFacing(mech))); 00906 } else { 00907 AddRFacing(mech, -offset); 00908 if(MechRFacing(mech) < 0) 00909 AddFacing(mech, 360); 00910 normangle -= offset; 00911 if(normangle < 0) 00912 SetRFacing(mech, SHO2FSIM(MechDesiredFacing(mech))); 00913 } 00914 MechCritStatus(mech) |= CHEAD; 00915 MarkForLOSUpdate(mech); 00916 }
| void UpdateHeat | ( | MECH * | mech | ) |
Definition at line 1361 of file mech.update.c.
References CLASS_MECH, DisableSomeHS(), EnableSomeHS(), Evading, Fallen, FindLegHeatSinks(), FindObjectsData(), FIRE, HandleOverheat(), headhitmwdamage(), Heatcutoff, InSpecial, InWater, IsRunning, Jellied, Jumping, LIFE_SUPPORT_DESTROYED, MapTemperature, MapUnderSpecialRules, mech_notify(), MechActiveNumsinks, MECHALL, MechCritStatus, MechDesiredSpeed, MechDisabledHS, MechEngineHeat, MechHasHeat, MechHeat, MechJumpSpeed, MechMinusHeat, MECHPILOT, MechPlusHeat, MechSpecials, MechSpeed, MechTerrain, MechType, MechWeapHeat, MechZ, MIN, MMaxSpeed, MP1, MP_PER_KPH, muxevent_tick, NullSigSysActive, Number, Sprinting, Started, StealthArmorActive, TRIPLE_MYOMER_TECH, TURN, and WEAPON_RECYCLE_TIME.
Referenced by aero_update(), and mech_update().
01362 { 01363 01364 int legsinks; 01365 float maxspeed; 01366 float intheat; 01367 float inheat; 01368 MAP *map; 01369 01370 // These guys don't get heat updates. 01371 if(!MechHasHeat(mech)) 01372 return; 01373 01374 inheat = MechHeat(mech); 01375 maxspeed = MMaxSpeed(mech); 01376 MechPlusHeat(mech) = 0.; 01377 01378 if(MechTerrain(mech) == FIRE && MechType(mech) == CLASS_MECH) 01379 MechPlusHeat(mech) += 5.; 01380 01381 /* We do a trick here. We look at the previous heat level to determine 01382 * if TSM is/was on. If it is/was, we recalc what running and walk speeds are 01383 * to better set how much heat the unit is putting out */ 01384 if(MechSpecials(mech) & TRIPLE_MYOMER_TECH) { 01385 if(inheat >= 9.) 01386 maxspeed = 01387 ceil((rint((MMaxSpeed(mech) / 1.5) / MP1) + 1) * 1.5) * MP1; 01388 } 01389 01390 if(fabs(MechSpeed(mech)) > 0.0) { 01391 #ifndef BT_MOVEMENT_MODES 01392 if(IsRunning(MechDesiredSpeed(mech), maxspeed)) 01393 MechPlusHeat(mech) += 2.; 01394 #else 01395 if(Sprinting(mech) || Evading(mech)) 01396 MechPlusHeat(mech) += 3.; 01397 else if(IsRunning(MechDesiredSpeed(mech), maxspeed)) 01398 MechPlusHeat(mech) += 2.; 01399 #endif 01400 else 01401 MechPlusHeat(mech) += 1.; 01402 } 01403 01404 if(Jumping(mech)) 01405 MechPlusHeat(mech) += (MechJumpSpeed(mech) * MP_PER_KPH > 3.) ? 01406 MechJumpSpeed(mech) * MP_PER_KPH : 3.; 01407 01408 if(Started(mech)) 01409 MechPlusHeat(mech) += (float) MechEngineHeat(mech); 01410 01411 if(StealthArmorActive(mech)) 01412 MechPlusHeat(mech) += 10; 01413 01414 if(NullSigSysActive(mech)) 01415 MechPlusHeat(mech) += 10; 01416 01417 intheat = MechPlusHeat(mech); 01418 01419 MechPlusHeat(mech) += MechWeapHeat(mech); 01420 01421 /* ADD Water effects here */ 01422 if(InWater(mech) && MechZ(mech) <= -1) { 01423 legsinks = FindLegHeatSinks(mech); 01424 legsinks = (legsinks > 4) ? 4 : legsinks; 01425 if(MechZ(mech) == -1 && !Fallen(mech)) { 01426 MechMinusHeat(mech) = MIN(2 * MechActiveNumsinks(mech), 01427 legsinks + MechActiveNumsinks(mech)); 01428 } else { 01429 MechMinusHeat(mech) = MIN(2 * MechActiveNumsinks(mech), 01430 6 + MechActiveNumsinks(mech)); 01431 } 01432 } else { 01433 MechMinusHeat(mech) = (float) (MechActiveNumsinks(mech)); 01434 } 01435 01436 /* Infernoed */ 01437 if(Jellied(mech)) { 01438 MechMinusHeat(mech) = MechMinusHeat(mech) - 6; 01439 if(MechMinusHeat(mech) < 0) 01440 MechMinusHeat(mech) = 0; 01441 } 01442 01443 if(InSpecial(mech)) 01444 if((map = FindObjectsData(mech->mapindex))) 01445 if(MapUnderSpecialRules(map)) 01446 if(MapTemperature(map) < -30 || MapTemperature(map) > 50) { 01447 if(MapTemperature(map) < -30) 01448 MechMinusHeat(mech) += 01449 (-30 - MapTemperature(map) + 9) / 10; 01450 else 01451 MechMinusHeat(mech) -= 01452 (MapTemperature(map) - 50 + 9) / 10; 01453 } 01454 01455 /* Handle heat cutoff now */ 01456 /* En/DisableSomeHS() take care of MechMinusHeat also. */ 01457 /* Re-Written to use Exile's code - Dany 12/05 */ 01458 if(Heatcutoff(mech)) { 01459 float overheat = MechPlusHeat(mech) - MechMinusHeat(mech); 01460 01461 if(overheat >= 10.) 01462 EnableSomeHS(mech, floor(overheat - 10.) + 1); 01463 else if(overheat < 9.) 01464 DisableSomeHS(mech, floor(9. - overheat) + 1); 01465 01466 } else if(MechDisabledHS(mech)) { 01467 EnableSomeHS(mech, 100); 01468 } 01469 01470 MechHeat(mech) = MechPlusHeat(mech) - MechMinusHeat(mech); 01471 01472 /* No lowering of heat if heat is under 9 */ 01473 MechWeapHeat(mech) -= 01474 (MechMinusHeat(mech) - intheat) / WEAPON_RECYCLE_TIME; 01475 01476 if(MechWeapHeat(mech) < 0.0) 01477 MechWeapHeat(mech) = 0.0; 01478 01479 if(MechHeat(mech) < 0.0) 01480 MechHeat(mech) = 0.0; 01481 01482 if((muxevent_tick % TURN) == 0) 01483 if(MechCritStatus(mech) & LIFE_SUPPORT_DESTROYED || 01484 (MechHeat(mech) > 30. && Number(0, 1) == 0)) { 01485 if(MechHeat(mech) > 25.) { 01486 mech_notify(mech, MECHPILOT, 01487 "You take personal injury from heat!"); 01488 headhitmwdamage(mech, mech, 01489 MechCritStatus(mech) & LIFE_SUPPORT_DESTROYED 01490 ? 2 : 1); 01491 } else if(MechHeat(mech) >= 15.) { 01492 mech_notify(mech, MECHPILOT, 01493 "You take personal injury from heat!"); 01494 headhitmwdamage(mech, mech, 1); 01495 } 01496 } 01497 01498 if(MechHeat(mech) >= 19) { 01499 if(inheat < 19) { 01500 mech_notify(mech, MECHALL, 01501 "%ch%cr====================================="); 01502 mech_notify(mech, MECHALL, 01503 "Your Excess Heat indicator turns RED!"); 01504 mech_notify(mech, MECHALL, 01505 "=====================================%c"); 01506 } 01507 } else if(MechHeat(mech) >= 14) { 01508 if(inheat >= 19 || inheat < 14) { 01509 mech_notify(mech, MECHALL, 01510 "%ch%cy======================================="); 01511 mech_notify(mech, MECHALL, 01512 "Your Excess Heat indicator turns YELLOW"); 01513 mech_notify(mech, MECHALL, 01514 "=======================================%c"); 01515 } 01516 } else { 01517 if(inheat >= 14) { 01518 mech_notify(mech, MECHALL, 01519 "%cg======================================"); 01520 mech_notify(mech, MECHALL, 01521 "Your Excess Heat indicator turns GREEN"); 01522 mech_notify(mech, MECHALL, 01523 "======================================%c"); 01524 } 01525 } 01526 HandleOverheat(mech); 01527 }
| void UpdatePilotSkillRolls | ( | MECH * | mech | ) |
Definition at line 2825 of file mech.update.c.
References CheckDamage(), CheckGenericFail(), CLASS_MECH, DamageMech(), Fallen, GYRO_DAMAGED, HIP_DAMAGED, InGravity, InSpecial, IsRunning, Jumping, LARM, LLEG, MadePilotSkillRoll(), mech_notify(), MECHALL, MechCritStatus, MechFalls(), MechHeat, MechIsQuad, MechLOSBroadcast(), MechMaxSpeed, MechMove, MechSpecials, MechSpeed, MechTurnDamage, MechType, MMaxSpeed, MOVE_NONE, MoveModeChange, MP1, muxevent_tick, OODing, RARM, RLEG, SectIsDestroyed, Started, TRIPLE_MYOMER_TECH, and TURN.
Referenced by aero_update(), and mech_update().
02826 { 02827 int makeroll = 0, grav = 0; 02828 float maxspeed; 02829 02830 if(((muxevent_tick % TURN) == 0) && !Fallen(mech) && !Jumping(mech) && 02831 !OODing(mech)) 02832 /* do this once a turn (30 secs), only if mech is standing */ 02833 { 02834 maxspeed = MMaxSpeed(mech); 02835 02836 if(!Started(mech)) 02837 makeroll = 4; 02838 02839 if((MechHeat(mech) >= 9.) && 02840 (MechSpecials(mech) & TRIPLE_MYOMER_TECH)) 02841 maxspeed = 02842 ceil((rint((MMaxSpeed(mech) / 1.5) / MP1) + 1) * 1.5) * MP1; 02843 /* maxspeed += 1.5 * MP1; */ 02844 #ifndef BT_MOVEMENT_MODES 02845 if(InSpecial(mech) && InGravity(mech)) 02846 #else 02847 if(InSpecial(mech) && InGravity(mech) && !MoveModeChange(mech)) 02848 #endif 02849 if(MechSpeed(mech) > MechMaxSpeed(mech) && 02850 MechType(mech) == CLASS_MECH) { 02851 grav = 1; 02852 makeroll = 1; 02853 } 02854 if(IsRunning(MechSpeed(mech), maxspeed) && 02855 ((MechCritStatus(mech) & GYRO_DAMAGED) || 02856 (MechCritStatus(mech) & HIP_DAMAGED))) 02857 makeroll = 1; 02858 02859 if(makeroll) { 02860 if(!MadePilotSkillRoll(mech, (makeroll - 1))) { 02861 if(grav) { 02862 int dam = 02863 (MechSpeed(mech) - MechMaxSpeed(mech)) / MP1 + 1; 02864 mech_notify(mech, MECHALL, "Your legs take some damage!"); 02865 if(MechIsQuad(mech)) { 02866 if(!SectIsDestroyed(mech, LARM)) 02867 DamageMech(mech, mech, 0, -1, LARM, 0, 0, 0, 02868 dam, 0, 0, -1, 0, 1); 02869 if(!SectIsDestroyed(mech, RARM)) 02870 DamageMech(mech, mech, 0, -1, RARM, 0, 0, 0, 02871 dam, 0, 0, -1, 0, 1); 02872 02873 } 02874 if(!SectIsDestroyed(mech, LLEG)) 02875 DamageMech(mech, mech, 0, -1, LLEG, 0, 0, 0, 02876 dam, 0, 0, -1, 0, 1); 02877 if(!SectIsDestroyed(mech, RLEG)) 02878 DamageMech(mech, mech, 0, -1, RLEG, 0, 0, 0, 02879 dam, 0, 0, -1, 0, 1); 02880 } else { 02881 mech_notify(mech, MECHALL, 02882 "Your damaged mech falls as you try to run!"); 02883 MechLOSBroadcast(mech, "falls down."); 02884 MechFalls(mech, 1, 0); 02885 } 02886 } 02887 } 02888 } 02889 if(MechType(mech) == CLASS_MECH) 02890 CheckDamage(mech); 02891 else 02892 MechTurnDamage(mech) = 0; 02893 if((muxevent_tick % TURN) == 0) { 02894 if(Started(mech) && MechMove(mech) != MOVE_NONE) 02895 CheckGenericFail(mech, -1, NULL, NULL); 02896 } 02897 }
| void UpdateSpeed | ( | MECH * | mech | ) |
Definition at line 982 of file mech.update.c.
References confdata::btech_slowdown, CHEAD, CLASS_MW, DECREASE_HEAT, DECREASE_OLD, Evading, Fallen, getMech(), HasBoolAdvantage(), Jumping, Landed, MASC_ENABLED, MechCarrying, MechCritStatus, MechDesiredFacing, MechDesiredSpeed, MechElevation, MechFacing, MechHeat, MechIsQuad, MechLateral, MechMaxSpeed, MechMove, MechPilot, MechRTerrain, MechSpecials, MechSpeed, MechStatus, MechType, MMaxSpeed, MOVE_FLY, MOVE_VTOL, MP1, MP2, MP3, MP4, MP5, mudconf, SCHARGE_ENABLED, Sprinting, terrain_speed(), and TRIPLE_MYOMER_TECH.
Referenced by aero_move_event(), and mech_move_event().
00983 { 00984 float acc, tempspeed, maxspeed; 00985 MECH *target; 00986 00987 if(!(!Fallen(mech) && !Jumping(mech) && (MechMaxSpeed(mech) > 0.0))) 00988 return; 00989 tempspeed = fabs(MechDesiredSpeed(mech)); 00990 maxspeed = MMaxSpeed(mech); 00991 if(maxspeed < 0.0) 00992 maxspeed = 0.0; 00993 00994 if((MechStatus(mech) & MASC_ENABLED) && 00995 (MechStatus(mech) & SCHARGE_ENABLED)) 00996 maxspeed = ceil((rint(maxspeed / 1.5) / MP1) * 2.5) * MP1; 00997 else if(MechStatus(mech) & MASC_ENABLED) 00998 maxspeed = (4. / 3.) * maxspeed; 00999 else if(MechStatus(mech) & SCHARGE_ENABLED) 01000 maxspeed = (4. / 3.) * maxspeed; 01001 01002 if(MechSpecials(mech) & TRIPLE_MYOMER_TECH) { 01003 if(MechHeat(mech) >= 9.) 01004 maxspeed = 01005 ceil((rint((MMaxSpeed(mech) / 1.5) / MP1) + 1) * 1.5) * MP1; 01006 /* maxspeed *= ((maxspeed + 1.5 * MP1) / maxspeed); */ 01007 if(MechDesiredSpeed(mech) >= maxspeed) 01008 MechDesiredSpeed(mech) = maxspeed; 01009 } 01010 01011 if(MechHeat(mech) >= 5.) { 01012 01013 /* if ((MechHeat(mech) >= 9.) && (MechSpecials(mech) & TRIPLE_MYOMER_TECH)) { 01014 tempspeed *= ((maxspeed + 1.5 * MP1) / maxspeed); 01015 } 01016 */ 01017 if(MechHeat(mech) >= 25.) 01018 DECREASE_HEAT(MP5); 01019 else if(MechHeat(mech) >= 20.) 01020 DECREASE_HEAT(MP4); 01021 else if(MechHeat(mech) >= 15.) 01022 DECREASE_HEAT(MP3); 01023 else if(MechHeat(mech) >= 10.) 01024 DECREASE_HEAT(MP2); 01025 else if(!((MechSpecials(mech) & TRIPLE_MYOMER_TECH) && 01026 MechHeat(mech) >= 9)) 01027 DECREASE_HEAT(MP1); 01028 } 01029 if(MechType(mech) != CLASS_MW && MechMove(mech) != MOVE_VTOL && 01030 (MechMove(mech) != MOVE_FLY || Landed(mech))) 01031 tempspeed = 01032 terrain_speed(mech, tempspeed, maxspeed, MechRTerrain(mech), 01033 MechElevation(mech)); 01034 if(MechCritStatus(mech) & CHEAD) { 01035 if(mudconf.btech_slowdown == 2) { 01036 /* _New_ slowdown based on facing vs desired difference */ 01037 int dif = MechFacing(mech) - MechDesiredFacing(mech); 01038 01039 if(dif < 0) 01040 dif = -dif; 01041 if(dif > 180) 01042 dif = 360 - dif; 01043 if(dif) { 01044 dif = (dif - 1) / 30; 01045 dif = (dif + 2); /* whee */ 01046 /* dif = 2 to 7 */ 01047 tempspeed = tempspeed * (10 - dif) / 10; 01048 } 01049 } else if(mudconf.btech_slowdown == 1) { 01050 if(MechFacing(mech) != MechDesiredFacing(mech)) 01051 tempspeed = tempspeed * 2.0 / 3.0; 01052 else 01053 tempspeed = tempspeed * 3.0 / 4.0; 01054 } 01055 #ifdef BT_MOVEMENT_MODES 01056 if((Sprinting(mech) || Evading(mech)) 01057 && !(HasBoolAdvantage(MechPilot(mech), "speed_demon") 01058 || HasBoolAdvantage(MechPilot(mech), "maneuvering_ace"))) 01059 tempspeed = (tempspeed * 2) / 3; 01060 #endif 01061 MechCritStatus(mech) &= ~CHEAD; 01062 } 01063 if(MechIsQuad(mech) && MechLateral(mech)) 01064 DECREASE_OLD(MP1); /* In truth 1 MP */ 01065 #ifdef BT_MOVEMENT_MODES 01066 else if(MechLateral(mech)) { 01067 if(HasBoolAdvantage(MechPilot(mech), "maneuvering_ace")) 01068 DECREASE_OLD(MP2); 01069 else 01070 DECREASE_OLD(MP3); 01071 } 01072 #endif 01073 if(tempspeed <= 0.0) 01074 tempspeed = 0.0; 01075 if(MechDesiredSpeed(mech) < 0.) 01076 tempspeed = -tempspeed; 01077 01078 /* if (MechSpecials(mech) & TRIPLE_MYOMER_TECH) 01079 { 01080 if (MechHeat(mech) >= 9.) 01081 maxspeed *= ((maxspeed + 1.5 * MP1) / maxspeed); 01082 if (MechDesiredSpeed(mech) >= maxspeed) 01083 MechDesiredSpeed(mech) = maxspeed; 01084 } 01085 */ 01086 01087 if(tempspeed != MechSpeed(mech)) { 01088 if(MechIsQuad(mech)) 01089 acc = maxspeed / 10.; 01090 else 01091 acc = maxspeed / 20.; 01092 if(HasBoolAdvantage(MechPilot(mech), "speed_demon")) 01093 acc *= 1.25; 01094 01095 if(tempspeed < MechSpeed(mech)) { 01096 /* Decelerating */ 01097 MechSpeed(mech) -= acc; 01098 if(tempspeed > MechSpeed(mech)) 01099 MechSpeed(mech) = tempspeed; 01100 } else { 01101 /* Accelerating */ 01102 MechSpeed(mech) += acc; 01103 if(tempspeed < MechSpeed(mech)) 01104 MechSpeed(mech) = tempspeed; 01105 } 01106 } 01107 if(MechCarrying(mech) > 0) { 01108 target = getMech(MechCarrying(mech)); 01109 if(target) 01110 MechSpeed(target) = MechSpeed(mech); 01111 } 01112 }
| int arc_override |
Definition at line 21 of file ds.turret.c.
1.4.7