#include "config.h"#include <stdio.h>#include <stdlib.h>#include <math.h>#include <sys/file.h>#include "mech.h"#include "mech.events.h"#include "p.mech.events.h"#include "p.mech.ice.h"#include "p.mech.utils.h"#include "p.mine.h"#include "p.bsuit.h"#include "p.mech.los.h"#include "p.mech.update.h"#include "p.mech.physical.h"#include "p.mech.combat.h"#include "p.mech.combat.misc.h"#include "p.mech.damage.h"#include "p.btechstats.h"#include "p.mech.hitloc.h"#include "p.template.h"#include "p.map.conditions.h"#include "p.mech.fire.h"Include dependency graph for mech.move.c:
Go to the source code of this file.
Enumerations | |
| enum | { NORMAL, PUNCH, KICK } |
Functions | |
| const char * | LateralDesc (MECH *mech) |
| void | mech_lateral (dbref player, void *data, char *buffer) |
| void | mech_turnmode (dbref player, void *data, char *buffer) |
| void | mech_bootlegger (dbref player, void *data, char *buffer) |
| void | mech_eta (dbref player, void *data, char *buffer) |
| float | MechCargoMaxSpeed (MECH *mech, float mspeed) |
| void | mech_drop (dbref player, void *data, char *buffer) |
| void | mech_stand (dbref player, void *data, char *buffer) |
| void | mech_land (dbref player, void *data, char *buffer) |
| void | mech_heading (dbref player, void *data, char *buffer) |
| void | mech_turret (dbref player, void *data, char *buffer) |
| void | mech_rotatetorso (dbref player, void *data, char *buffer) |
| void | mech_speed (dbref player, void *data, char *buffer) |
| void | mech_vertical (dbref player, void *data, char *buffer) |
| void | mech_thrash (dbref player, void *data, char *buffer) |
| void | mech_jump (dbref player, void *data, char *buffer) |
| static void | mech_hulldown_event (MUXEVENT *e) |
| void | mech_hulldown (dbref player, void *data, char *buffer) |
| int | DropGetElevation (MECH *mech) |
| void | DropSetElevation (MECH *mech, int wantdrop) |
| void | LandMech (MECH *mech) |
| void | MechFloodsLoc (MECH *mech, int loc, int lev) |
| void | MechFloods (MECH *mech) |
| void | MechFalls (MECH *mech, int levels, int seemsg) |
| int | mechs_in_hex (MAP *map, int x, int y, int friendly, int team) |
| void | cause_damage (MECH *att, MECH *mech, int dam, int table) |
| int | domino_space_in_hex (MAP *map, MECH *me, int x, int y, int friendly, int mode, int cnt) |
| int | domino_space (MECH *mech, int mode) |
Variables | |
| struct { | |
| char * name | |
| char * full | |
| int ofs | |
| } | lateral_modes [] |
| struct { | |
| char * name | |
| int flag | |
| } | speed_tables [] |
| anonymous enum |
Definition at line 1937 of file mech.move.c.
References BACK, CLASS_MECH, DamageMech(), Fallen, FindAreaHitGroup(), FindHitLocation(), FindKickLocation(), FindPunchLocation(), FRONT, MechPilot, MechType, NORMAL, and PUNCH.
01938 { 01939 int hitGroup, isrear, iscrit = 0, hitloc = 0; 01940 int i, sp = (dam - 1) / 5; 01941 01942 if(!dam) 01943 return; 01944 if(att == mech) 01945 hitGroup = FRONT; 01946 else 01947 hitGroup = FindAreaHitGroup(att, mech); 01948 isrear = (hitGroup == BACK); 01949 if(Fallen(mech)) 01950 table = NORMAL; 01951 for(i = 0; i <= sp; i++) { 01952 switch (table) { 01953 case NORMAL: 01954 hitloc = FindHitLocation(mech, hitGroup, &iscrit, &isrear); 01955 break; 01956 case PUNCH: 01957 if (MechType(mech) != CLASS_MECH) { 01958 hitloc = FindHitLocation(mech, hitGroup, &iscrit, &isrear); 01959 } else { 01960 hitloc = FindPunchLocation(mech, hitGroup); 01961 } 01962 break; 01963 case KICK: 01964 if (MechType(mech) != CLASS_MECH) { 01965 hitloc = FindHitLocation(mech, hitGroup, &iscrit, &isrear); 01966 } else { 01967 hitloc = FindKickLocation(mech, hitGroup); 01968 } 01969 break; 01970 } 01971 if(dam <= 0) 01972 return; 01973 DamageMech(mech, att, (att == mech) ? 0 : 1, 01974 (att == mech) ? -1 : MechPilot(att), hitloc, isrear, 01975 iscrit, dam > 5 ? 5 : dam, 0, -1, 0, -1, 0, 0); 01976 dam -= 5; 01977 } 01978 }
| int domino_space | ( | MECH * | mech, | |
| int | mode | |||
| ) |
Definition at line 2099 of file mech.move.c.
References confdata::btech_stacking, CLASS_MECH, domino_space_in_hex(), FindObjectsData(), MECH::mapindex, mechs_in_hex(), MechTeam, MechType, MechX, MechY, and mudconf.
Referenced by DestroyParts(), HandleMechCrit(), HandleOverheat(), LandMech(), mech_ood_event(), mech_shutdown(), move_mech(), and NewHexEntered().
02100 { 02101 MAP *map = FindObjectsData(mech->mapindex); 02102 int cnt, fcnt; 02103 02104 if(!map) 02105 return 0; 02106 if(MechType(mech) != CLASS_MECH) 02107 return 0; 02108 if(mudconf.btech_stacking == 0) 02109 return 0; 02110 cnt = mechs_in_hex(map, MechX(mech), MechY(mech), -1, 0); 02111 if(cnt <= 2) 02112 return 0; 02113 /* Possible nastiness */ 02114 if((fcnt = 02115 mechs_in_hex(map, MechX(mech), MechY(mech), 1, MechTeam(mech))) > 2) 02116 return domino_space_in_hex(map, mech, MechX(mech), MechY(mech), 1, 02117 mode, fcnt); 02118 else if(cnt > 6) 02119 return domino_space_in_hex(map, mech, MechX(mech), MechY(mech), 0, 02120 mode, cnt - fcnt); 02121 return 0; 02122 }
Definition at line 1980 of file mech.move.c.
References CLASS_MECH, FindObjectsData(), MAP::first_free, IsDS, Jumping, Landed, MAP::mechsOnMap, MechTeam, MechType, MechX, MechY, Number, OODing, Started, and team.
Referenced by domino_space().
01982 { 01983 int tar = Number(0, cnt - 1), i, head, td; 01984 MECH *mech = NULL; 01985 int team = MechTeam(me); 01986 01987 for(i = 0; i < map->first_free; i++) 01988 if((mech = FindObjectsData(map->mechsOnMap[i]))) { 01989 if(MechX(mech) != x || MechY(mech) != y) 01990 continue; 01991 if(mech == me) 01992 continue; 01993 if(IsDS(mech) && (Landed(mech) || !Started(mech))) { 01994 tar -= 2; 01995 } else { 01996 if(!Started(mech)) 01997 continue; 01998 if(MechType(mech) != CLASS_MECH) 01999 continue; 02000 if(Jumping(mech) || OODing(mech)) 02001 continue; 02002 if(friendly < 0 || ((MechTeam(mech) == team) == friendly)) 02003 tar--; 02004 else 02005 continue; 02006 } 02007 if(tar <= 0) 02008 break; 02009 } 02010 if(i == map->first_free) 02011 return 0; 02012 /* Now we got a mech we hit, accidentally or otherwise */ 02013 /* Next, we figure out what'll happen */ 02014 02015 /* 'wannabe-charge' is entirely based on the directional difference */ 02016 /* Multiplied by the speed - if both go in same direction at same speed, 02017 nothing untoward happens (unlikely, though) */ 02018 /* Jumping to a hex with multiple guys is BAD Thing(tm), though */ 02019 02020 switch (mode) { 02021 case 1: 02022 case 2: 02023 head = MechJumpHeading(me); 02024 td = JumpSpeedMP(me, map) * (MechRTons(me) / 1024 + 5) / 10; 02025 break; 02026 default: 02027 head = MechFacing(me) + MechLateral(me); 02028 td = fabs(((MechSpeed(me) - MechSpeed(mech) * cos((head - 02029 (MechFacing(mech) + 02030 MechLateral 02031 (mech))) * (M_PI / 02032 180.))) 02033 * MP_PER_KPH) * (MechRTons(me) / 1024 + 5) / 15); 02034 break; 02035 } 02036 if(td > 10) 02037 td = 10 + (td - 10) / 3; 02038 if(td <= 1) /* No point in 1pt hits */ 02039 return 0; 02040 switch (mode) { 02041 case 1: 02042 case 2: 02043 if(mudconf.btech_stacking == 2) { 02044 int factor = mudconf.btech_stackdamage; 02045 mech_printf(me, MECHALL, "You land on %s!", 02046 GetMechToMechID(me, mech)); 02047 mech_printf(mech, MECHALL, "%s lands on you!", 02048 GetMechToMechID(mech, me)); 02049 MechLOSBroadcasti(me, mech, "lands on %s!"); 02050 if(IsDS(mech)) { 02051 cause_damage(me, mech, MAX(1, td * factor / 500), PUNCH); 02052 cause_damage(me, me, MAX(1, td * factor / 100), KICK); 02053 } else { 02054 cause_damage(me, mech, MAX(1, td * factor / 100), PUNCH); 02055 cause_damage(me, me, MAX(1, td * factor / 500), KICK); 02056 } 02057 } else { 02058 mech_printf(me, MECHALL, "You nearly land on %s!", 02059 GetMechToMechID(me, mech)); 02060 mech_printf(mech, MECHALL, "%s nearly lands on you!", 02061 GetMechToMechID(mech, me)); 02062 MechLOSBroadcasti(me, mech, "nearly lands on %s!"); 02063 if(!MadePilotSkillRoll(me, cnt + JumpSpeedMP(me, map) / 2)) 02064 MechFalls(me, 1, JumpSpeedMP(me, map) / 2); 02065 } 02066 return 1; 02067 } 02068 if(mudconf.btech_stacking == 2) { 02069 int factor = mudconf.btech_stackdamage; 02070 mech_printf(me, MECHALL, "You bump into %s!", 02071 GetMechToMechID(me, mech)); 02072 mech_printf(mech, MECHALL, "%s bumps into you!", 02073 GetMechToMechID(mech, me)); 02074 MechLOSBroadcasti(me, mech, "bumps into %s!"); 02075 if(IsDS(mech)) { 02076 cause_damage(me, mech, MAX(1, td * factor / 500), NORMAL); 02077 cause_damage(me, me, MAX(1, td * factor / 100), NORMAL); 02078 } else { 02079 cause_damage(me, mech, MAX(1, td * factor / 100), NORMAL); 02080 cause_damage(me, me, MAX(1, td * factor / 500), NORMAL); 02081 } 02082 } else { 02083 mech_printf(me, MECHALL, "You nearly bump into %s!", 02084 GetMechToMechID(me, mech)); 02085 mech_printf(mech, MECHALL, "%s nearly bumps into you!", 02086 GetMechToMechID(mech, me)); 02087 MechLOSBroadcasti(me, mech, "nearly bumps into %s!"); 02088 if(!MadePilotSkillRoll(me, cnt)) 02089 MechFalls(me, 1, 0); 02090 MechDesiredSpeed(me) = 0; 02091 MechSpeed(me) = 0; 02092 } 02093 MechChargeTarget(me) = -1; 02094 MechChargeTimer(me) = 0; 02095 MechChargeDistance(me) = 0; 02096 return 1; 02097 }
| int DropGetElevation | ( | MECH * | mech | ) |
Definition at line 1508 of file mech.move.c.
References BRIDGE, bridge_w_elevation(), ICE, MAX, MechElev, MechElevation, MechRTerrain, MechZ, and Overwater.
Referenced by DropSetElevation(), and mech_ood_event().
01509 { 01510 if(MechRTerrain(mech) == BRIDGE) { 01511 if(MechZ(mech) < (MechElev(mech))) { 01512 if(Overwater(mech)) 01513 return 0; 01514 return bridge_w_elevation(mech); 01515 } 01516 return MechElevation(mech); 01517 } 01518 if(Overwater(mech) || (MechRTerrain(mech) == ICE && MechZ(mech) >= 0)) 01519 return MAX(0, MechElevation(mech)); 01520 else 01521 return MechElevation(mech); 01522 }
| void DropSetElevation | ( | MECH * | mech, | |
| int | wantdrop | |||
| ) |
Definition at line 1524 of file mech.move.c.
References BRIDGE, bridge_set_elevation(), DropGetElevation(), ICE, MechFZ, MechRTerrain, MechZ, possibly_drop_thru_ice(), and ZSCALE.
Referenced by LandMech(), mech_ood_event(), mech_Rsetxy(), MechFalls(), move_mech(), and StopSwarming().
01525 { 01526 if(MechRTerrain(mech) == BRIDGE) { 01527 bridge_set_elevation(mech); 01528 return; 01529 } 01530 MechZ(mech) = DropGetElevation(mech); 01531 MechFZ(mech) = MechZ(mech) * ZSCALE; 01532 if(wantdrop) 01533 if(MechRTerrain(mech) == ICE && MechZ(mech) >= 0) 01534 possibly_drop_thru_ice(mech); 01535 }
| void LandMech | ( | MECH * | mech | ) |
Definition at line 1537 of file mech.move.c.
References calcStaggerBTHMod(), CLASS_MECH, CLASS_VEH_GROUND, CountDestroyedLegs(), CountSwarmers(), DeathFromAbove(), DFA_ATTACK, domino_space(), DropSetElevation(), EVENT_JUMPSTABIL, Fallen, FindObjectsData(), GetElev, getMap(), getMech(), GYRO_DAMAGED, GYRO_DESTROYED, JUMP_TO_HIT_RECYCLE, Jumping, JUMPING, LLEG, MadePilotSkillRoll(), MECH::mapindex, MaybeMove, mech_notify(), mech_stabilizing_event(), MECHALL, MechCritStatus, MechDFATarget, MechElev, MECHEVENT, MechFalls(), MechFloods(), MechFZ, MechGoingX, MechGoingY, MechLOSBroadcast(), MECHPILOT, MechSections, MechSpeed, MechStatus, MechType, MechX, MechY, MechZ, MINE_LAND, possible_mine_poof(), RLEG, Staggering, StopBSuitSwarmers(), StopJump, StopStaggerCheck, Uncon, water_extinguish_inferno(), and ZSCALE.
Referenced by CheckEdgeOfMap(), mech_land(), move_mech(), and NewHexEntered().
01538 { 01539 MECH *target; 01540 MAP *mech_map = getMap(mech->mapindex); 01541 int dfa = 0; 01542 int done = 0; 01543 01544 /* 01545 * Added check to see if we're actually awake when we try to land 01546 * - Kipsta 01547 * - 8/3/99 01548 */ 01549 01550 if(Uncon(mech)) { 01551 mech_notify(mech, MECHALL, 01552 "Your lack of conciousness makes you fall to the ground. Not like you can read this anyway."); 01553 MechFalls(mech, 1, 0); 01554 dfa = 1; 01555 done = 1; 01556 } else { 01557 /* Handle DFA attack */ 01558 if(MechStatus(mech) & DFA_ATTACK) { 01559 /* is the target here? */ 01560 target = getMech(MechDFATarget(mech)); 01561 if(target) { 01562 if(MechX(target) == MechX(mech) && 01563 MechY(target) == MechY(mech)) 01564 dfa = DeathFromAbove(mech, target); 01565 else 01566 mech_notify(mech, MECHPILOT, 01567 "Your DFA target has moved!"); 01568 } else 01569 mech_notify(mech, MECHPILOT, 01570 "Your target has become invalid."); 01571 } 01572 01573 if(!dfa) 01574 mech_notify(mech, MECHALL, "You finish your jump."); 01575 01576 /* Better reset the FZ */ 01577 MechElev(mech) = GetElev(mech_map, MechX(mech), MechY(mech)); 01578 MechZ(mech) = MechElev(mech) - 1; 01579 MechFZ(mech) = ZSCALE * MechZ(mech); 01580 DropSetElevation(mech, 1); 01581 01582 if(Staggering(mech)) { 01583 mech_notify(mech, MECHALL, 01584 "The damage you've taken makes the landing a bit harder..."); 01585 01586 if(!MadePilotSkillRoll(mech, calcStaggerBTHMod(mech))) { 01587 mech_notify(mech, MECHALL, 01588 "... something you apparently can't handle!"); 01589 MechLOSBroadcast(mech, "lands, staggers, and falls down!"); 01590 MechFalls(mech, 1, 0); 01591 return; 01592 } 01593 } 01594 01595 /* Check piloting rolls, etc. */ 01596 if(MechType(mech) == CLASS_MECH) { 01597 if(CountDestroyedLegs(mech) > 0) { 01598 mech_notify(mech, MECHPILOT, 01599 "Your missing leg makes it harder to land"); 01600 if(!MadePilotSkillRoll(mech, 0)) { 01601 mech_notify(mech, MECHALL, 01602 "Your missing leg has caused you to fall upon landing!"); 01603 MechLOSBroadcast(mech, 01604 "lands, unbalanced, and falls down!"); 01605 dfa = 1; 01606 MechFalls(mech, 1, 0); 01607 done = 1; 01608 } 01609 } else if(MechSections(mech)[RLEG].basetohit || 01610 MechSections(mech)[LLEG].basetohit) { 01611 mech_notify(mech, MECHPILOT, 01612 "Your damaged leg actuators make it harder to land"); 01613 if(!MadePilotSkillRoll(mech, 0)) { 01614 mech_notify(mech, MECHALL, 01615 "Your damaged leg actuators have caused you to fall upon landing!"); 01616 MechLOSBroadcast(mech, 01617 "lands, stumbles, and falls down!"); 01618 dfa = 1; 01619 done = 1; 01620 MechFalls(mech, 1, 0); 01621 } 01622 } else if((MechCritStatus(mech) & GYRO_DAMAGED) || (MechCritStatus(mech) & GYRO_DESTROYED)) { 01623 mech_notify(mech, MECHPILOT, "Your damaged gyro makes it harder to land"); 01624 if(!MadePilotSkillRoll(mech, 0)) { 01625 mech_notify(mech, MECHALL, 01626 "Your damaged gyro has caused you to fall upon landing!"); 01627 MechLOSBroadcast(mech, 01628 "lands, twists awkwardly, and falls down!"); 01629 dfa = 1; 01630 done = 1; 01631 MechFalls(mech,1,0); 01632 } 01633 } 01634 } 01635 } 01636 01637 if((MechType(mech) == CLASS_MECH) && CountSwarmers(mech)) { 01638 mech_notify(mech, MECHALL, 01639 "The suits hanging off you make landing harder!"); 01640 01641 if(MadePilotSkillRoll(mech, 4)) { 01642 StopBSuitSwarmers(FindObjectsData(mech->mapindex), mech, 0); 01643 } else { 01644 mech_notify(mech, MECHALL, 01645 "You fail to properly control your unbalanced landing!"); 01646 MechLOSBroadcast(mech, 01647 "lands and crashes to the ground from the weight of the battlesuits!"); 01648 MechFalls(mech, 1, 0); 01649 } 01650 } 01651 01652 if(!dfa && !Fallen(mech) && !domino_space(mech, 1)) { 01653 if(MechType(mech) != CLASS_VEH_GROUND) 01654 MechLOSBroadcast(mech, "lands gracefully."); 01655 else 01656 MechLOSBroadcast(mech, "returns to the ground where it belongs."); 01657 } 01658 01659 /* If we aren't jumping anymore, we already took care of the event. 01660 (e.g. in MechFalls()) */ 01661 if(Jumping(mech)) 01662 MECHEVENT(mech, EVENT_JUMPSTABIL, mech_stabilizing_event, 01663 JUMP_TO_HIT_RECYCLE, 0); 01664 MechStatus(mech) &= ~JUMPING; 01665 MechStatus(mech) &= ~DFA_ATTACK; 01666 MechDFATarget(mech) = -1; 01667 MechGoingX(mech) = MechGoingY(mech) = 0; 01668 MechSpeed(mech) = 0; 01669 StopJump(mech); /* Kill the event for moving 'round */ 01670 MaybeMove(mech); /* Possibly start movin' on da ground */ 01671 01672 01673 if(!done) 01674 possible_mine_poof(mech, MINE_LAND); 01675 01676 MechFloods(mech); 01677 water_extinguish_inferno(mech); 01678 StopStaggerCheck(mech); 01679 }
| const char* LateralDesc | ( | MECH * | mech | ) |
Definition at line 56 of file mech.move.c.
References foo::full, lateral_modes, MechLateral, and foo::ofs.
Referenced by PrintInfoStatus(), and PrintReport().
00057 { 00058 int i; 00059 00060 for(i = 0; MechLateral(mech) != lateral_modes[i].ofs; i++); 00061 return lateral_modes[i].full; 00062 }
| void mech_bootlegger | ( | dbref | player, | |
| void * | data, | |||
| char * | buffer | |||
| ) |
Definition at line 129 of file mech.move.c.
References AcceptableDegree(), args, ArmorStringFromIndex(), cch, CountDestroyedLegs(), DOCHECK, InWater, LARM, LLEG, MadePilotSkillRoll(), MAX, mech_notify(), mech_parseattributes(), mech_printf(), MECH_USUALO, MECHALL, MechDesiredFacing, MechFacing, MechFalls(), MechIsQuad, MechLOSBroadcast(), MechMove, MechSections, MechSpeed, MechTons, MechType, MP1, MECH::mynum, NUM_SECTIONS, RARM, RLEG, SectHasBusyWeap(), SendDebug, SetFacing, SetRecycleLimb, skipws, and tprintf().
00130 { 00131 MECH *mech = (MECH *) data; 00132 float fMinSpeed = (4 * MP1); 00133 int wBTHMod = 0; 00134 int wFallLevels = 0; 00135 int i; 00136 int wHeadingChange = 0; 00137 int wNewHeading; 00138 float fMechSpeed = MechSpeed(mech); 00139 int wMechTons = MechTons(mech); 00140 char strLocation[50]; 00141 char *args[1]; 00142 00143 cch(MECH_USUALO); 00144 00145 DOCHECK(mech_parseattributes(buffer, args, 1) != 1, 00146 "Invalid number of arguments!"); 00147 DOCHECK(CountDestroyedLegs(mech) > 0, 00148 "You can't perform a bootlegger with destroyed legs!"); 00149 DOCHECK(fMechSpeed < fMinSpeed, 00150 tprintf 00151 ("You are going too slow to perform a bootlegger! The required minimum speed is %4.1f KPH.", 00152 fMinSpeed)); 00153 00154 switch (toupper(args[0][0])) { 00155 case 'R': 00156 wHeadingChange = 90; 00157 break; 00158 case 'L': 00159 wHeadingChange = -90; 00160 break; 00161 } 00162 00163 DOCHECK(wHeadingChange == 0, "Invalid turn direction!"); 00164 00165 for(i = 0; i < NUM_SECTIONS; i++) { 00166 if((i == LLEG) || (i == RLEG) || (MechIsQuad(mech) && ((i == LARM) 00167 || (i == 00168 RARM)))) { 00169 ArmorStringFromIndex(i, strLocation, MechType(mech), 00170 MechMove(mech)); 00171 00172 if(SectHasBusyWeap(mech, i)) { 00173 mech_printf(mech, MECHALL, 00174 "You have weapons recycling in your %s.", 00175 strLocation); 00176 return; 00177 } 00178 00179 if(MechSections(mech)[i].recycle) { 00180 mech_printf(mech, MECHALL, 00181 "Your %s is still recovering from its last action.", 00182 strLocation); 00183 return; 00184 } 00185 00186 wBTHMod += MechSections(mech)[i].basetohit; 00187 } 00188 } 00189 00190 if(fMechSpeed <= (4 * MP1)) { 00191 wBTHMod += 0; 00192 } else if(fMechSpeed <= (8 * MP1)) { 00193 wBTHMod += 1; 00194 } else if(fMechSpeed <= (12 * MP1)) { 00195 wBTHMod += 2; 00196 } else { 00197 wBTHMod += 3; 00198 } 00199 00200 if(wMechTons <= 35) { 00201 wBTHMod += 0; 00202 } else if(wMechTons <= 55) { 00203 wBTHMod += 1; 00204 } else if(wMechTons <= 75) { 00205 wBTHMod += 2; 00206 } else { 00207 wBTHMod += 3; 00208 } 00209 00210 wBTHMod += (InWater(mech) ? 2 : 0); 00211 00212 wBTHMod = MAX(wBTHMod, 1); 00213 00214 skipws(buffer); 00215 00216 SendDebug(tprintf 00217 ("#%d attempts to do a bootlegger (mech). Tonnage: %d, Speed: %4.1f, BTHMod: %d", 00218 mech->mynum, wMechTons, fMechSpeed, wBTHMod)); 00219 00220 if(MadePilotSkillRoll(mech, wBTHMod)) { 00221 wNewHeading = AcceptableDegree(MechFacing(mech) + wHeadingChange); 00222 00223 SetFacing(mech, wNewHeading); 00224 MechDesiredFacing(mech) = wNewHeading; 00225 MechSpeed(mech) = MechSpeed(mech) / 2; 00226 00227 mech_printf(mech, MECHALL, 00228 "You plant a foot and swivel, changing your heading to %d.", 00229 wNewHeading); 00230 00231 for(i = 0; i < NUM_SECTIONS; i++) { 00232 if((i == LLEG) || (i == RLEG) || (MechIsQuad(mech) && 00233 ((i == LARM) || (i == RARM)))) 00234 SetRecycleLimb(mech, i, 30); 00235 } 00236 00237 } else { 00238 wFallLevels = MAX(wBTHMod, 1); 00239 00240 mech_notify(mech, MECHALL, "You plant a foot and try to swivel..."); 00241 mech_notify(mech, MECHALL, 00242 "... but realize a little late that this is harder than it looks!"); 00243 MechLOSBroadcast(mech, 00244 "attempts to fight the forces of inertia but looses the battle miserably!"); 00245 00246 if(wFallLevels > 2) 00247 MechLOSBroadcast(mech, "tumbles over and over and over!"); 00248 00249 MechFalls(mech, wFallLevels, 1); 00250 } 00251 }
| void mech_drop | ( | dbref | player, | |
| void * | data, | |||
| char * | buffer | |||
| ) |
Definition at line 436 of file mech.move.c.
References cch, CLASS_BSUIT, CLASS_MECH, CLASS_MW, CountSwarmers(), DOCHECK, Fallen, FindObjectsData(), Jumping, MadePilotSkillRoll(), MakeMechFall, mech_notify(), MECH_USUAL, MECHALL, MechDesiredSpeed, MechFalls(), MechFloods(), MechLOSBroadcast(), MechSpeed, MechType, MINE_STEP, MMaxSpeed, OODing, possible_mine_poof(), Staggering, StaggerLevel, Standing, StopBSuitSwarmers(), and water_extinguish_inferno().
Referenced by auto_radio_command_prone().
00437 { 00438 MECH *mech = (MECH *) data; 00439 float s1; 00440 int wDropLevels = 0; 00441 int wDropBTH = 0; 00442 int tHasSwarmers = 0; 00443 00444 cch(MECH_USUAL); 00445 DOCHECK(MechType(mech) == CLASS_BSUIT, "No crawling!"); 00446 DOCHECK(MechType(mech) != CLASS_MECH && 00447 MechType(mech) != CLASS_MW, "You can't prone in this!"); 00448 DOCHECK(Fallen(mech), "You are already prone."); 00449 DOCHECK(Jumping(mech) || OODing(mech), "You can't prone in the air!"); 00450 DOCHECK(Standing(mech), "You can't drop while trying to stand up!"); 00451 00452 s1 = MMaxSpeed(mech) / 3.0; 00453 00454 if((MechType(mech) == CLASS_MECH) && CountSwarmers(mech)) 00455 tHasSwarmers = 1; 00456 00457 if(MechType(mech) != CLASS_MW && fabs(MechSpeed(mech)) > s1 * 2) { 00458 mech_notify(mech, MECHALL, 00459 "You attempt a controlled drop while running."); 00460 wDropLevels = 2; 00461 wDropBTH = 2; 00462 } else if(fabs(MechSpeed(mech)) > s1) { 00463 mech_notify(mech, MECHALL, 00464 "You attempt a controlled drop from your fast walk."); 00465 wDropLevels = 1; 00466 } 00467 00468 if(Staggering(mech)) { 00469 mech_notify(mech, MECHALL, 00470 "Still staggering, you try not to fall on your face."); 00471 wDropLevels = (wDropLevels == 0 ? 1 : wDropLevels); 00472 wDropBTH = wDropBTH + StaggerLevel(mech); 00473 } 00474 00475 if(tHasSwarmers) 00476 mech_notify(mech, MECHALL, 00477 "The suits hanging off you make a controlled drop harder!"); 00478 00479 if((wDropLevels > 0) || tHasSwarmers) { 00480 if(MadePilotSkillRoll(mech, wDropBTH)) { 00481 mech_notify(mech, MECHALL, 00482 "You hit the ground with minimal damage"); 00483 MechLOSBroadcast(mech, "drops to the ground!"); 00484 00485 if(tHasSwarmers) 00486 StopBSuitSwarmers(FindObjectsData(mech->mapindex), mech, 0); 00487 00488 } else { 00489 mech_notify(mech, MECHALL, "You fall to the ground hard"); 00490 MechLOSBroadcast(mech, "falls hard to the ground!"); 00491 00492 if(wDropLevels <= 0) 00493 wDropLevels = 1; 00494 00495 if(tHasSwarmers) 00496 StopBSuitSwarmers(FindObjectsData(mech->mapindex), mech, 0); 00497 00498 MechFalls(mech, wDropLevels, 1); 00499 } 00500 } else { 00501 mech_notify(mech, MECHALL, "You drop to the ground prone!"); 00502 MechLOSBroadcast(mech, "drops to the ground!"); 00503 } 00504 00505 MakeMechFall(mech); 00506 MechDesiredSpeed(mech) = 0; 00507 MechSpeed(mech) = 0; 00508 MechFloods(mech); 00509 water_extinguish_inferno(mech); 00510 00511 possible_mine_poof(mech, MINE_STEP); 00512 }
| void mech_eta | ( | dbref | player, | |
| void * | data, | |||
| char * | buffer | |||
| ) |
Definition at line 253 of file mech.move.c.
References args, cch, DOCHECK, FindRange(), getMap(), KPH_PER_MP, MapCoordToRealCoord(), MECH::mapindex, mech_parseattributes(), mech_printf(), MECH_USUAL, MECHALL, MechFX, MechFY, MechSpeed, MechTarget, MechTargX, MechTargY, and notify.
Referenced by turret_eta().
00254 { 00255 MECH *mech = (MECH *) data; 00256 MAP *mech_map; 00257 int argc, eta_x, eta_y; 00258 float fx, fy, range; 00259 int etahr, etamin; 00260 char *args[3]; 00261 00262 cch(MECH_USUAL); 00263 mech_map = getMap(mech->mapindex); 00264 argc = mech_parseattributes(buffer, args, 2); 00265 DOCHECK(argc == 1, "Invalid number of arguments!"); 00266 switch (argc) { 00267 case 0: 00268 DOCHECK(!(MechTargX(mech) >= 0 && 00269 MechTarget(mech) < 0), 00270 "You have invalid default target for ETA!"); 00271 eta_x = MechTargX(mech); 00272 eta_y = MechTargY(mech); 00273 break; 00274 case 2: 00275 eta_x = atoi(args[0]); 00276 eta_y = atoi(args[1]); 00277 break; 00278 default: 00279 notify(player, "Invalid arguments!"); 00280 return; 00281 } 00282 MapCoordToRealCoord(eta_x, eta_y, &fx, &fy); 00283 range = FindRange(MechFX(mech), MechFY(mech), 0, fx, fy, 0); 00284 if(fabs(MechSpeed(mech)) < 0.1) 00285 mech_printf(mech, MECHALL, 00286 "Range to hex (%d,%d) is %.1f. ETA: Never, mech not moving.", 00287 eta_x, eta_y, range); 00288 else { 00289 etamin = abs(range / (MechSpeed(mech) / KPH_PER_MP)); 00290 etahr = etamin / 60; 00291 etamin = etamin % 60; 00292 mech_printf(mech, MECHALL, 00293 "Range to hex (%d,%d) is %.1f. ETA: %.2d:%.2d.", 00294 eta_x, eta_y, range, etahr, etamin); 00295 } 00296 }
| void mech_heading | ( | dbref | player, | |
| void * | data, | |||
| char * | buffer | |||
| ) |
Definition at line 661 of file mech.move.c.
References AcceptableDegree(), args, cch, ChangingHulldown, Digging, DOCHECK, is_aero, IsHulldown, Landed, MaybeMove, mech_notify(), mech_parseattributes(), mech_printf(), MECH_USUAL, MECHALL, MechDesiredFacing, MechDugIn, MechFacing, MechMove, MOVE_NONE, notify_printf(), NotInWater, PerformingAction, Spinning, StopDigging, and WaterBeast.
Referenced by ai_set_heading(), auto_dumbfollow_event(), auto_radio_command_heading(), and update_wanted_heading().
00662 { 00663 MECH *mech = (MECH *) data; 00664 char *args[1]; 00665 int newheading; 00666 00667 cch(MECH_USUAL); 00668 if(mech_parseattributes(buffer, args, 1) == 1) { 00669 DOCHECK(MechMove(mech) == MOVE_NONE, 00670 "This piece of equipment is stationary!"); 00671 DOCHECK(WaterBeast(mech) && 00672 NotInWater(mech), 00673 "You are regrettably unable to move at this time. We apologize for the inconvenience."); 00674 DOCHECK(is_aero(mech) && Spinning(mech) && 00675 !Landed(mech), 00676 "You are unable to control your craft at the moment."); 00677 DOCHECK(PerformingAction(mech), 00678 "You are too busy at the moment to turn."); 00679 DOCHECK(MechDugIn(mech), 00680 "You are in a hole you dug, unable to move [use speed cmd to get out]."); 00681 DOCHECK(IsHulldown(mech), "You can not turn while hulldown"); 00682 DOCHECK(ChangingHulldown(mech), 00683 "You are busy changing your hulldown mode"); 00684 if(Digging(mech)) { 00685 mech_notify(mech, MECHALL, 00686 "You cease your attempts at digging in."); 00687 StopDigging(mech); 00688 } 00689 newheading = AcceptableDegree(atoi(args[0])); 00690 MechDesiredFacing(mech) = newheading; 00691 mech_printf(mech, MECHALL, "Heading changed to %d.", newheading); 00692 MaybeMove(mech); 00693 } else { 00694 notify_printf(player, "Your current heading is %i.", 00695 MechFacing(mech)); 00696 } 00697 }
| void mech_hulldown | ( | dbref | player, | |
| void * | data, | |||
| char * | buffer | |||
| ) |
Definition at line 1448 of file mech.move.c.
References args, cch, ChangingHulldown, DOCHECK, EVENT_CHANGING_HULLDOWN, Fallen, IsHulldown, Jumping, mech_hulldown_event(), mech_notify(), mech_parseattributes(), MECH_USUALO, MECHALL, MechDesiredSpeed, MECHEVENT, MechIsQuad, MechLOSBroadcast(), MechSpeed, OODing, Stabilizing, Standing, StandMechTime, and StopHullDown.
01449 { 01450 MECH *mech = (MECH *) data; 01451 char *args[1]; 01452 int argc; 01453 01454 cch(MECH_USUALO); 01455 01456 DOCHECK(OODing(mech), "While falling out of the sky?"); 01457 DOCHECK(!MechIsQuad(mech), "Only QUADs can hulldown."); 01458 DOCHECK(Fallen(mech), "You can't hulldown from a FALLEN position"); 01459 DOCHECK(Jumping(mech), "You can't hulldown while jumping!"); 01460 DOCHECK(MechSpeed(mech) > 0.5, "You can't hulldown while moving!"); 01461 DOCHECK(Stabilizing(mech), 01462 "You are still stabilizing from your last jump."); 01463 DOCHECK(Standing(mech), "You haven't finished standing up yet."); 01464 01465 argc = mech_parseattributes(buffer, args, 1); 01466 01467 if(argc > 0) { 01468 if(!strcmp(args[0], "-")) { 01469 if(!IsHulldown(mech)) 01470 mech_notify(mech, MECHALL, "You are not hulldown."); 01471 else if(ChangingHulldown(mech)) 01472 mech_notify(mech, MECHALL, 01473 "You are busy changing your hulldown mode."); 01474 else { 01475 mech_notify(mech, MECHALL, "You start to lift yourself up."); 01476 MechLOSBroadcast(mech, "begins to raise up on its legs."); 01477 01478 MECHEVENT(mech, EVENT_CHANGING_HULLDOWN, 01479 mech_hulldown_event, StandMechTime(mech), 0); 01480 } 01481 } else if(!strcasecmp(args[0], "stop")) { 01482 if(!ChangingHulldown(mech)) 01483 mech_notify(mech, MECHALL, 01484 "You are not currently changing your hulldown mode."); 01485 else { 01486 StopHullDown(mech); 01487 mech_notify(mech, MECHALL, 01488 "You stop changing your hulldown mode."); 01489 } 01490 } else 01491 mech_notify(mech, MECHALL, "Invalid argument for 'hulldown'."); 01492 01493 return; 01494 } 01495 01496 DOCHECK(IsHulldown(mech), "You are already hulldown."); 01497 DOCHECK(ChangingHulldown(mech), 01498 "You are busy changing your hulldown mode."); 01499 01500 mech_notify(mech, MECHALL, "You start to lower yourself to the ground."); 01501 MechLOSBroadcast(mech, "begins to lower itself to the ground."); 01502 MechDesiredSpeed(mech) = 0; 01503 01504 MECHEVENT(mech, EVENT_CHANGING_HULLDOWN, mech_hulldown_event, 01505 StandMechTime(mech), 1); 01506 }
| static void mech_hulldown_event | ( | MUXEVENT * | e | ) | [static] |
Definition at line 1276 of file mech.move.c.
References ChangingHulldown, my_event_type::data, my_event_type::data2, HULLDOWN, mech_notify(), MECHALL, MechLOSBroadcast(), MechStatus, and Started.
Referenced by mech_hulldown().
01277 { 01278 MECH *mech = (MECH *) e->data; 01279 int type = (int) e->data2; 01280 01281 if(!ChangingHulldown(mech)) 01282 return; 01283 01284 if(!Started(mech)) 01285 return; 01286 01287 if(type == 0) { 01288 MechStatus(mech) &= ~HULLDOWN; 01289 mech_notify(mech, MECHALL, "You finish lifting yourself up."); 01290 MechLOSBroadcast(mech, "finishes lifting itself up"); 01291 } else { 01292 MechStatus(mech) |= HULLDOWN; 01293 mech_notify(mech, MECHALL, 01294 "You finish lowering yourself to the ground."); 01295 MechLOSBroadcast(mech, "finishes lowering itself to the ground."); 01296 } 01297 }
| void mech_jump | ( | dbref | player, | |
| void * | data, | |||
| char * | buffer | |||
| ) |
Definition at line 1107 of file mech.move.c.
References args, calcStaggerBTHMod(), cch, ChangingHulldown, CLASS_BSUIT, CLASS_MECH, CLASS_MW, CLASS_VEH_GROUND, DFA_ATTACK, DOCHECK, doJettisonChecks(), Dumping, Elevation, EVENT_JUMP, Fallen, FaMechRange, FindBearing(), FindTargetDBREFFromMapNumber(), FindXY(), getMap(), getMech(), GetRTerrain, ICE, InLineOfSight(), IsHulldown, JUMP_TICK, Jumping, JUMPING, JumpSpeedMP, length_hypotenuse(), MadePilotSkillRoll(), MAP::map_height, MAP::map_width, MapCoordToRealCoord(), MECH::mapindex, MapIsUnderground, mech_jump_event(), mech_notify(), mech_parseattributes(), MECH_USUALO, MECHALL, MechCarrying, MechCocoon, MechDFATarget, MechEndFZ, MECHEVENT, MechFalls(), MechFX, MechFY, MechFZ, MechGoingX, MechGoingY, MechJumpHeading, MechJumpLength, MechJumpSpeed, MechJumpTop, MechLOSBroadcast(), MechMaxSpeed, MechSpeed, MechStartFX, MechStartFY, MechStartFZ, MechStatus, MechSwarmTarget, MechTarget, MechType, MechX, MechY, MechZ, MIN, MMaxSpeed, MoveModeLock, MP1, MECH::mynum, OODing, RealCoordToMapCoord(), RemovingPods, Stabilizing, Staggering, Standing, UnJammingAmmo, and ZSCALE.
Referenced by auto_radio_command_jumpjet().
01108 { 01109 MECH *mech = (MECH *) data; 01110 MECH *tempMech = NULL; 01111 MAP *mech_map; 01112 char *args[3]; 01113 int argc; 01114 int target; 01115 char targetID[2]; 01116 short mapx, mapy; 01117 int bearing; 01118 float range = 0.0; 01119 float realx, realy; 01120 int sz, tz, jps; 01121 01122 mech_map = getMap(mech->mapindex); 01123 cch(MECH_USUALO); 01124 #ifdef BT_MOVEMENT_MODES 01125 DOCHECK(MoveModeLock(mech), "Movement modes disallow jumping."); 01126 #endif 01127 DOCHECK(MechType(mech) != CLASS_MECH && MechType(mech) != CLASS_MW && 01128 MechType(mech) != CLASS_BSUIT && 01129 MechType(mech) != CLASS_VEH_GROUND, "This unit cannot jump."); 01130 DOCHECK(MechCarrying(mech) > 0, "You can't jump while towing someone!"); 01131 DOCHECK((MechMaxSpeed(mech) - MMaxSpeed(mech)) > MP1, 01132 "No, with this cargo you won't!"); 01133 DOCHECK(Fallen(mech), "You can't Jump from a FALLEN position"); 01134 DOCHECK(IsHulldown(mech), "You can't Jump while hulldown"); 01135 DOCHECK(ChangingHulldown(mech), 01136 "You are busy changing your hulldown mode"); 01137 DOCHECK(Jumping(mech), "You're already jumping!"); 01138 DOCHECK(Stabilizing(mech), 01139 "You haven't stabilized from your last jump yet."); 01140 DOCHECK(Standing(mech), "You haven't finished standing up yet."); 01141 DOCHECK(fabs(MechJumpSpeed(mech)) <= 0.0, 01142 "This mech doesn't have jump jets!"); 01143 argc = mech_parseattributes(buffer, args, 3); 01144 DOCHECK(Dumping(mech), "You can not jump while dumping ammo!"); 01145 DOCHECK(UnJammingAmmo(mech), 01146 "You can not jump while unjamming your weapon!"); 01147 DOCHECK(RemovingPods(mech), "You are too busy removing iNARC pods!"); 01148 DOCHECK(MapIsUnderground(mech_map), 01149 "Realize the ceiling in this grotto is a bit to low for that!"); 01150 DOCHECK(OODing(mech), "You can't jump while orbital dropping!"); 01151 01152 if(Staggering(mech)) { 01153 mech_notify(mech, MECHALL, 01154 "The damage inhibits your coordination..."); 01155 01156 if(!MadePilotSkillRoll(mech, calcStaggerBTHMod(mech))) { 01157 mech_notify(mech, MECHALL, 01158 "... something you apparently can't handle!"); 01159 MechLOSBroadcast(mech, 01160 "engages jumpjets, rolls to the side and slams into the ground!"); 01161 MechFalls(mech, 1, 0); 01162 return; 01163 } 01164 } 01165 01166 if(doJettisonChecks(mech)) 01167 return; 01168 01169 DOCHECK(argc > 2, "Too many arguments to JUMP function!"); 01170 MechStatus(mech) &= ~DFA_ATTACK; /* By default no DFA */ 01171 switch (argc) { 01172 case 0: 01173 /* DFA current target... */ 01174 01175 DOCHECK(MechType(mech) != CLASS_MECH, 01176 "Only mechs can do Death From Above attacks!"); 01177 01178 target = MechTarget(mech); 01179 tempMech = getMech(target); 01180 DOCHECK(!tempMech, "Invalid Target!"); 01181 range = FaMechRange(mech, tempMech); 01182 DOCHECK(!InLineOfSight(mech, tempMech, MechX(tempMech), 01183 MechY(tempMech), range), 01184 "Target is not in line of sight!"); 01185 DOCHECK(MechType(tempMech) == CLASS_MW, 01186 "Even you can't aim your jump well enough to squish that!"); 01187 mapx = MechX(tempMech); 01188 mapy = MechY(tempMech); 01189 MechDFATarget(mech) = MechTarget(mech); 01190 break; 01191 case 1: 01192 /* Jump Target */ 01193 DOCHECK(MechType(mech) != CLASS_MECH, 01194 "Only mechs can do Death From Above attacks!"); 01195 01196 targetID[0] = args[0][0]; 01197 targetID[1] = args[0][1]; 01198 target = FindTargetDBREFFromMapNumber(mech, targetID); 01199 tempMech = getMech(target); 01200 DOCHECK(!tempMech, "Target is not in line of sight!"); 01201 range = FaMechRange(mech, tempMech); 01202 DOCHECK(!InLineOfSight(mech, tempMech, MechX(tempMech), 01203 MechY(tempMech), range), 01204 "Target is not in line of sight!"); 01205 DOCHECK(MechType(tempMech) == CLASS_MW, 01206 "Even you can't aim your jump well enough to squish that!"); 01207 mapx = MechX(tempMech); 01208 mapy = MechY(tempMech); 01209 MechDFATarget(mech) = tempMech->mynum; 01210 break; 01211 case 2: 01212 bearing = atoi(args[0]); 01213 range = atof(args[1]); 01214 FindXY(MechFX(mech), MechFY(mech), bearing, range, &realx, &realy); 01215 01216 /* This is so we are jumping to the center of a hex */ 01217 /* and the bearing jives with the target hex */ 01218 RealCoordToMapCoord(&mapx, &mapy, realx, realy); 01219 break; 01220 } 01221 DOCHECK(mapx >= mech_map->map_width || mapy >= mech_map->map_height || 01222 mapx < 0 || mapy < 0, "That would take you off the map!"); 01223 DOCHECK(MechX(mech) == mapx && 01224 MechY(mech) == mapy, "You're already in the target hex."); 01225 sz = MechZ(mech); 01226 if(GetRTerrain(mech_map, mapx, mapy) == ICE) 01227 tz = 0; 01228 else 01229 tz = Elevation(mech_map, mapx, mapy); 01230 jps = JumpSpeedMP(mech, mech_map); 01231 DOCHECK(range > jps, "That target is out of range!"); 01232 if(MechType(mech) != CLASS_BSUIT && tempMech) 01233 MechStatus(mech) |= DFA_ATTACK; 01234 /* MechJumpTop(mech) = BOUNDED(3, (jps - range) + 2, jps - 1); */ 01235 /* New idea: JumpTop = (JP + 1 - range / 3) - in another words, 01236 SDR jumping for 1 hexes has 8 + 1 = 9 hex elevation in mid-flight, 01237 SDR jumping for 8 hexes has 8 + 1 - 2 = 7 hex elevation in mid-flight, 01238 TDR jumping for 4 hexes has 4 + 1 - 1 = 4 hex elevation in mid-flight 01239 01240 Come to think of it, the last SDR figure was ridiculous. New 01241 value: 2 * 1 + 2 = 4 01242 */ 01243 MechJumpTop(mech) = MIN(jps + 1 - range / 3, 2 * range + 2); 01244 DOCHECK((tz - sz) > jps, 01245 "That target's high for you to reach with a single jump!"); 01246 DOCHECK((sz - tz) > jps, 01247 "That target's low for you to reach with a single jump!"); 01248 DOCHECK(sz < -1, "Glub glub glub."); 01249 MapCoordToRealCoord(mapx, mapy, &realx, &realy); 01250 bearing = FindBearing(MechFX(mech), MechFY(mech), realx, realy); 01251 01252 /* TAKE OFF! */ 01253 MechCocoon(mech) = 0; 01254 MechJumpHeading(mech) = bearing; 01255 MechStatus(mech) |= JUMPING; 01256 MechStartFX(mech) = MechFX(mech); 01257 MechStartFY(mech) = MechFY(mech); 01258 MechStartFZ(mech) = MechFZ(mech); 01259 MechJumpLength(mech) = 01260 length_hypotenuse((double) (realx - MechStartFX(mech)), 01261 (double) (realy - MechStartFY(mech))); 01262 MechGoingX(mech) = mapx; 01263 MechGoingY(mech) = mapy; 01264 MechEndFZ(mech) = ZSCALE * tz; 01265 MechSpeed(mech) = 0.0; 01266 if(MechStatus(mech) & DFA_ATTACK) 01267 mech_notify(mech, MECHALL, 01268 "You engage your jump jets for a Death From Above attack!"); 01269 else 01270 mech_notify(mech, MECHALL, "You engage your jump jets."); 01271 MechSwarmTarget(mech) = -1; 01272 MechLOSBroadcast(mech, "engages jumpjets!"); 01273 MECHEVENT(mech, EVENT_JUMP, mech_jump_event, JUMP_TICK, 0); 01274 }
| void mech_land | ( | dbref | player, | |
| void * | data, | |||
| char * | buffer | |||
| ) |
Definition at line 627 of file mech.move.c.
References aero_land(), cch, CLASS_BSUIT, CLASS_MECH, CLASS_MW, CLASS_VEH_GROUND, Jumping, LandMech(), MadePilotSkillRoll(), MaybeMove, mech_notify(), MECH_USUAL, MECHALL, MechDFATarget, MechFalls(), MechGoingX, MechGoingY, MechLOSBroadcast(), MechSpeed, MechType, and notify.
Referenced by move_mech().
00628 { 00629 MECH *mech = (MECH *) data; 00630 00631 cch(MECH_USUAL); 00632 if(MechType(mech) != CLASS_MECH && MechType(mech) != CLASS_MW && 00633 MechType(mech) != CLASS_BSUIT && MechType(mech) != CLASS_VEH_GROUND) { 00634 aero_land(player, data, buffer); 00635 return; 00636 } 00637 if(Jumping(mech)) { 00638 mech_notify(mech, MECHALL, 00639 "You abort your full jump and attempt to land early"); 00640 if(MadePilotSkillRoll(mech, 0)) { 00641 mech_notify(mech, MECHALL, "You are able to abort the jump."); 00642 00643 /* MechLOSBroadcast (mech, "lands abruptly!"); */ 00644 LandMech(mech); 00645 } else { 00646 mech_notify(mech, MECHALL, "You don't quite make it."); 00647 MechLOSBroadcast(mech, 00648 "attempts a landing, but crashes to the ground!"); 00649 MechFalls(mech, 1, 0); 00650 MechDFATarget(mech) = -1; 00651 MechGoingX(mech) = MechGoingY(mech) = 0; 00652 MechSpeed(mech) = 0; 00653 MaybeMove(mech); 00654 00655 } 00656 } else 00657 notify(player, "You're not jumping!"); 00658 }
| void mech_lateral | ( | dbref | player, | |
| void * | data, | |||
| char * | buffer | |||
| ) |
Definition at line 64 of file mech.move.c.
References cch, ChangingLateral, CLASS_MECH, CLASS_VTOL, CountDestroyedLegs(), DOCHECK, EVENT_LATERAL, full, lateral_modes, LATERAL_TICK, mech_lateral_event(), mech_notify(), mech_printf(), MECH_USUALO, MECHALL, MECHEVENT, MechIsQuad, MechLateral, MechMove, MechType, MOVE_HOVER, foo::name, name, ofs, skipws, and StopLateral.
00065 { 00066 MECH *mech = (MECH *) data; 00067 int i; 00068 00069 cch(MECH_USUALO); 00070 #ifndef BT_MOVEMENT_MODES 00071 DOCHECK(MechType(mech) != CLASS_MECH || 00072 !MechIsQuad(mech), 00073 "Only quadrupeds can alter their lateral movement!"); 00074 #else 00075 DOCHECK(!((MechType(mech) == CLASS_MECH && MechIsQuad(mech)) || 00076 (MechType(mech) == CLASS_VTOL) || 00077 (MechMove(mech) == MOVE_HOVER)), 00078 "You cannot alter your lateral movement!"); 00079 #endif 00080 DOCHECK(CountDestroyedLegs(mech) > 0, 00081 "You need all four legs to use lateral movement!"); 00082 skipws(buffer); 00083 00084 for(i = 0; lateral_modes[i].name; i++) 00085 if(!strcasecmp(lateral_modes[i].name, buffer)) 00086 break; 00087 DOCHECK(!lateral_modes[i].name, "Invalid mode!"); 00088 if(lateral_modes[i].ofs == MechLateral(mech)) { 00089 DOCHECK(!ChangingLateral(mech), "You are going that way already!"); 00090 mech_notify(mech, MECHALL, "Lateral mode change aborted."); 00091 StopLateral(mech); 00092 return; 00093 } 00094 mech_printf(mech, MECHALL, 00095 "Wanted lateral movement mode changed to %s.", 00096 lateral_modes[i].full); 00097 StopLateral(mech); 00098 MECHEVENT(mech, EVENT_LATERAL, mech_lateral_event, LATERAL_TICK, i); 00099 }
| void mech_rotatetorso | ( | dbref | player, | |
| void * | data, | |||
| char * | buffer | |||
| ) |
Definition at line 728 of file mech.move.c.
References args, cch, CLASS_BSUIT, CLASS_MECH, CLASS_MW, DOCHECK, Fallen, MarkForLOSUpdate(), mech_notify(), mech_parseattributes(), MECH_USUALO, MECHALL, MechIsQuad, MechStatus, MechType, notify, TORSO_LEFT, and TORSO_RIGHT.
00729 { 00730 MECH *mech = (MECH *) data; 00731 char *args[2]; 00732 00733 cch(MECH_USUALO); 00734 DOCHECK(MechType(mech) == CLASS_BSUIT, "Huh?"); 00735 DOCHECK(MechType(mech) != CLASS_MECH && 00736 MechType(mech) != CLASS_MW, "You don't have a torso."); 00737 DOCHECK(Fallen(mech), 00738 "You're lying flat on your face, you can't rotate your torso."); 00739 DOCHECK((MechType(mech) == CLASS_MECH) && 00740 (MechIsQuad(mech)), "Quads can't rotate their torsos."); 00741 if(mech_parseattributes(buffer, args, 2) == 1) { 00742 switch (args[0][0]) { 00743 case 'L': 00744 case 'l': 00745 DOCHECK(MechStatus(mech) & TORSO_LEFT, 00746 "You cannot rotate torso beyond 60 degrees!"); 00747 if(MechStatus(mech) & TORSO_RIGHT) 00748 MechStatus(mech) &= ~TORSO_RIGHT; 00749 else 00750 MechStatus(mech) |= TORSO_LEFT; 00751 mech_notify(mech, MECHALL, "You rotate your torso left."); 00752 break; 00753 case 'R': 00754 case 'r': 00755 DOCHECK(MechStatus(mech) & TORSO_RIGHT, 00756 "You cannot rotate torso beyond 60 degrees!"); 00757 if(MechStatus(mech) & TORSO_LEFT) 00758 MechStatus(mech) &= ~TORSO_LEFT; 00759 else 00760 MechStatus(mech) |= TORSO_RIGHT; 00761 mech_notify(mech, MECHALL, "You rotate your torso right."); 00762 break; 00763 case 'C': 00764 case 'c': 00765 MechStatus(mech) &= ~(TORSO_RIGHT | TORSO_LEFT); 00766 mech_notify(mech, MECHALL, "You center your torso."); 00767 break; 00768 default: 00769 notify(player, "Rotate must have LEFT RIGHT or CENTER."); 00770 break; 00771 } 00772 } else 00773 notify(player, "Invalid number of arguments!"); 00774 MarkForLOSUpdate(mech); 00775 }
| void mech_speed | ( | dbref | player, | |
| void * | data, | |||
| char * | buffer | |||
| ) |
Definition at line 791 of file mech.move.c.
References AeroFreeFuel, AeroFuel, args, BRIDGE, cch, ChangingHulldown, CLASS_MECH, CLASS_MW, CLASS_VTOL, CrewStunned, Digging, DOCHECK, DUG_IN, Dumping, Fallen, flag, FlyingT, HIDDEN, HIGHWATER, ICE, In_Character, IsHulldown, IsRunning, Landed, MaybeMove, mech_notify(), mech_parseattributes(), mech_printf(), MECH_STUNNED, MECH_USUAL, MECHALL, MechCarrying, MechCritStatus, MechDesiredSpeed, MechHeat, MechMove, MechPilot, MechRTerrain, MechSpecials, MechSpeed, MechSwarmTarget, MechTankCritStatus, MechType, MechVerticalSpeed, MechZ, MMaxSpeed, MOVE_NONE, MOVE_VTOL, MP1, name, notify, notify_printf(), NotInWater, PerformingAction, RemovingPods, RollingT, SALVAGE_TECH, speed_tables, Sprinting, Standing, StopDigging, StopSwarming(), TAIL_ROTOR_DESTROYED, TRIPLE_MYOMER_TECH, UnJammingAmmo, WalkingSpeed, WATER, WaterBeast, and Wizard.
Referenced by ai_run_speed(), ai_set_speed(), ai_stop(), auto_dumbfollow_event(), auto_radio_command_heading(), and auto_radio_command_stop().
00792 { 00793 MECH *mech = (MECH *) data; 00794 char *args[1]; 00795 float newspeed, walkspeed, maxspeed; 00796 int i; 00797 00798 cch(MECH_USUAL); 00799 if(RollingT(mech)) { 00800 DOCHECK(!Landed(mech), "Use thrust command instead!"); 00801 } else if(FlyingT(mech)) { 00802 DOCHECK(MechType(mech) != CLASS_VTOL, "Use thrust command instead!"); 00803 } 00804 DOCHECK(MechMove(mech) == MOVE_NONE, 00805 "This piece of equipment is stationary!"); 00806 DOCHECK(PerformingAction(mech), 00807 "You are too busy at the moment to turn."); 00808 DOCHECK(Standing(mech), "You are currently standing up and cannot move."); 00809 DOCHECK((Fallen(mech)) && (MechType(mech) != CLASS_MECH && 00810 MechType(mech) != CLASS_MW), 00811 "Your vehicle's movement system is destroyed."); 00812 DOCHECK(Fallen(mech), "You are currently prone and cannot move."); 00813 DOCHECK(WaterBeast(mech) && 00814 NotInWater(mech), 00815 "You are regrettably unable to move at this time. We apologize for the inconvenience."); 00816 00817 if(MechType(mech) != CLASS_MECH) 00818 DOCHECK(RemovingPods(mech), "You are too busy removing iNARC pods!"); 00819 DOCHECK(IsHulldown(mech), "You can not move while hulldown"); 00820 DOCHECK(ChangingHulldown(mech), 00821 "You are busy changing your hulldown mode"); 00822 00823 if(mech_parseattributes(buffer, args, 1) != 1) { 00824 notify_printf(player, "Your current speed is %.2f.", MechSpeed(mech)); 00825 return; 00826 } 00827 DOCHECK(FlyingT(mech) && AeroFuel(mech) <= 0 && 00828 !AeroFreeFuel(mech), "You're out of fuel!"); 00829 maxspeed = MMaxSpeed(mech); 00830 00831 if(MechMove(mech) == MOVE_VTOL) 00832 maxspeed = sqrt((float) maxspeed * maxspeed - 00833 MechVerticalSpeed(mech) * MechVerticalSpeed(mech)); 00834 00835 maxspeed = maxspeed > 0.0 ? maxspeed : 0.0; 00836 00837 if((MechHeat(mech) >= 9.) && (MechSpecials(mech) & TRIPLE_MYOMER_TECH)) 00838 maxspeed = ceil((rint((maxspeed / 1.5) / MP1) + 1) * 1.5) * MP1; 00839 00840 /* if (MechStatus(mech) & MASC_ENABLED) maxspeed = (4. / 3. ) * maxspeed; */ 00841 walkspeed = WalkingSpeed(maxspeed); 00842 newspeed = atof(args[0]); 00843 00844 if(newspeed < 0.1) { 00845 00846 /* Possibly a string speed instead? */ 00847 for(i = 0; speed_tables[i].name; i++) 00848 if(!strcasecmp(speed_tables[i].name, args[0])) { 00849 switch (speed_tables[i].flag) { 00850 case 0: 00851 newspeed = 0.0; 00852 break; 00853 case -1: 00854 newspeed = -walkspeed; 00855 break; 00856 case 1: 00857 newspeed = walkspeed; 00858 break; 00859 case 2: 00860 newspeed = maxspeed; 00861 break; 00862 } 00863 break; 00864 } 00865 } 00866 00867 if(newspeed > maxspeed) 00868 newspeed = maxspeed; 00869 if(newspeed < -walkspeed) 00870 newspeed = -walkspeed; 00871 00872 DOCHECK((newspeed < 0) && (MechCarrying(mech) > 0) && 00873 (!(MechSpecials(mech) & SALVAGE_TECH)), 00874 "You can not backup while towing!"); 00875 00876 DOCHECK((newspeed < 0) && Sprinting(mech), 00877 "You can not backup while sprinting!"); 00878 00879 if(IsRunning(newspeed, maxspeed)) { 00880 DOCHECK(Dumping(mech), "You can not run while dumping ammo!"); 00881 DOCHECK(UnJammingAmmo(mech), 00882 "You can not run while unjamming your weapon!"); 00883 00884 /* Exile Stun Code Effect */ 00885 if(MechCritStatus(mech) & MECH_STUNNED) { 00886 mech_notify(mech, MECHALL, "You cannot move faster than cruise" 00887 " speed while stunned!"); 00888 return; 00889 } 00890 00891 DOCHECK(CrewStunned(mech), 00892 "Your cannot possibly control a vehicle going this fast in your " 00893 "current mental state!"); 00894 DOCHECK(MechTankCritStatus(mech) & TAIL_ROTOR_DESTROYED, 00895 "Your cannot possibly control a VTOL going this fast with a destroyed tail rotor!"); 00896 DOCHECK(MechType(mech) == CLASS_MECH && ((MechZ(mech) < 0 && 00897 (MechRTerrain(mech) == WATER 00898 || MechRTerrain(mech) == 00899 BRIDGE 00900 || MechRTerrain(mech) == 00901 ICE)) 00902 || MechRTerrain(mech) == 00903 HIGHWATER), 00904 "You can't run through water!"); 00905 } 00906 if(!Wizard(player) && In_Character(mech->mynum) && 00907 MechPilot(mech) != player) { 00908 if(newspeed < 0.0) { 00909 notify(player, 00910 "Not being the Pilot of this beast, you cannot move it backwards."); 00911 return; 00912 } else if(newspeed > walkspeed) { 00913 notify(player, 00914 "Not being the Pilot of this beast, you cannot go faster than walking speed."); 00915 return; 00916 } 00917 } 00918 MechDesiredSpeed(mech) = newspeed; 00919 MaybeMove(mech); 00920 if(fabs(newspeed) > 0.1) { 00921 if(MechSwarmTarget(mech) > 0) { 00922 StopSwarming(mech, 1); 00923 MechCritStatus(mech) &= ~HIDDEN; 00924 } 00925 if(Digging(mech)) { 00926 mech_notify(mech, MECHALL, 00927 "You cease your attempts at digging in."); 00928 StopDigging(mech); 00929 } 00930 MechTankCritStatus(mech) &= ~DUG_IN; 00931 } 00932 mech_printf(mech, MECHALL, "Desired speed changed to %d KPH", 00933 (int) newspeed); 00934 }
| void mech_stand | ( | dbref | player, | |
| void * | data, | |||
| char * | buffer | |||
| ) |
Definition at line 514 of file mech.move.c.
References args, break_thru_ice(), cch, ChangingHulldown, CLASS_BSUIT, CLASS_MECH, CLASS_MW, CountDestroyedLegs(), DOCHECK, DROP_TO_STAND_RECYCLE, EVENT_STAND, EVENT_STANDFAIL, Fallen, GYRO_DESTROYED, ICE, IsHulldown, Jumping, MadePilotSkillRoll(), MakeMechStand, MAX, mech_notify(), mech_stand_event(), mech_standfail_event(), MECH_USUAL, MECHALL, MechCritStatus, MECHEVENT, MechFalls(), MechIsQuad, MechLOSBroadcast(), MechPilotSkillRoll_BTH(), MechRTerrain, MechType, MechZ, notify, notify_printf(), OODing, proper_explodearguments(), StandMechTime, and Standrecovering.
Referenced by auto_astar_follow_event(), auto_astar_goto_event(), auto_astar_roam_event(), auto_dumbfollow_event(), auto_dumbgoto_event(), auto_enter_event(), auto_leave_event(), and auto_radio_command_stand().
00515 { 00516 MECH *mech = (MECH *) data; 00517 char *args[2]; 00518 int wcDeadLegs = 0; 00519 int tNeedsPSkill = 1; 00520 int tDoStand = 1; 00521 int bth, mechstandtime, standanyway = 0, standcarefulmod = 0; 00522 int i; 00523 00524 cch(MECH_USUAL); 00525 DOCHECK(MechType(mech) == CLASS_BSUIT, "You're standing already!"); 00526 DOCHECK(MechType(mech) != CLASS_MECH && 00527 MechType(mech) != CLASS_MW, 00528 "This vehicle cannot stand like a 'Mech."); 00529 DOCHECK(Jumping(mech), "You're standing while jumping!"); 00530 DOCHECK(OODing(mech), "You're standing while flying!"); 00531 00532 /* set the number of dead legs we have */ 00533 wcDeadLegs = CountDestroyedLegs(mech); 00534 00535 DOCHECK(((MechIsQuad(mech) && (wcDeadLegs > 3)) || (!MechIsQuad(mech) 00536 && (wcDeadLegs > 1))), 00537 "You have no legs to stand on!"); 00538 DOCHECK(wcDeadLegs > 2, "You'd be far too unstable!"); 00539 DOCHECK(MechCritStatus(mech) & GYRO_DESTROYED, 00540 "You cannot stand with a destroyed gyro!"); 00541 00542 DOCHECK(!Fallen(mech), "You're already standing!"); 00543 DOCHECK(Standrecovering(mech), 00544 "You're still recovering from your last attempt!"); 00545 DOCHECK(IsHulldown(mech), "You can not stand while hulldown"); 00546 DOCHECK(ChangingHulldown(mech), 00547 "You are busy changing your hulldown mode"); 00548 00549 bth = MechPilotSkillRoll_BTH(mech, 0); 00550 00551 /* Check to see if the user specified an argument for the command */ 00552 if(proper_explodearguments(buffer, args, 2)) { 00553 if(strcmp(args[0], "check") == 0) { 00554 notify_printf(player, "Your BTH to stand would be: %d", bth); 00555 for(i = 0; i < 2; i++) { 00556 if(args[i]) 00557 free(args[i]); 00558 } 00559 return; 00560 } else if(strcmp(args[0], "anyway") == 0) { 00561 standanyway = 1; 00562 } else if(strcmp(args[0], "careful") == 0) { 00563 standcarefulmod = -2; 00564 } else { 00565 notify(player, "Unknown argument! use 'stand check', " 00566 "'stand anyway', or 'stand careful'"); 00567 for(i = 0; i < 2; i++) { 00568 if(args[i]) 00569 free(args[i]); 00570 } 00571 return; 00572 } 00573 } 00574 00575 DOCHECK(!standanyway && bth > 12, 00576 "You would fail; use 'stand anyway' if you really want to stand."); 00577 00578 MakeMechStand(mech); 00579 00580 /* quads with all 4 legs don't have to roll to stand */ 00581 if(((wcDeadLegs == 0) && MechIsQuad(mech)) || 00582 (MechType(mech) == CLASS_MW)) { 00583 tNeedsPSkill = 0; 00584 } 00585 00586 MechLOSBroadcast(mech, "attempts to stand up."); 00587 00588 if(MechRTerrain(mech) == ICE && MechZ(mech) == -1) 00589 break_thru_ice(mech); 00590 00591 if(tNeedsPSkill) { 00592 if(!MadePilotSkillRoll(mech, standcarefulmod)) { 00593 mech_notify(mech, MECHALL, 00594 "You fail your attempt to stand and fall back on the ground"); 00595 MechFalls(mech, 1, 1); 00596 mechstandtime = ((MechType(mech) == CLASS_MW) ? 00597 DROP_TO_STAND_RECYCLE / 3 : StandMechTime(mech)); 00598 /* Not strictly FASA, but allows legged mechs to stand careful */ 00599 if(standcarefulmod) { 00600 mechstandtime = MAX(30, mechstandtime * 2); 00601 } 00602 MECHEVENT(mech, EVENT_STANDFAIL, mech_standfail_event, 00603 mechstandtime, 0); 00604 tDoStand = 0; 00605 } 00606 } 00607 00608 if(tDoStand) { 00609 /* Now we set a counter in goingy to keep him from moving or jumping until he is finished standing */ 00610 mech_notify(mech, MECHALL, "You begin to stand up."); 00611 mechstandtime = ((MechType(mech) == CLASS_MW) ? 00612 DROP_TO_STAND_RECYCLE / 3 : StandMechTime(mech)); 00613 /* Not strictly FASA, but allows legged mechs to stand careful */ 00614 if(standcarefulmod) { 00615 mechstandtime = mechstandtime * 2; 00616 } 00617 MECHEVENT(mech, EVENT_STAND, mech_stand_event, mechstandtime, 0); 00618 } 00619 /* Free args */ 00620 for(i = 0; i < 2; i++) { 00621 if(args[i]) 00622 free(args[i]); 00623 } 00624 00625 }
| void mech_thrash | ( | dbref | player, | |
| void * | data, | |||
| char * | buffer | |||
| ) |
Definition at line 986 of file mech.move.c.
References ArmorStringFromIndex(), BRIDGE, cch, CLASS_BSUIT, DamageMech(), DOCHECK, Fallen, FaMechRange, FindObjectsData(), MAP::first_free, getMap(), GetMechToMechID(), GetRTerrain, GRASSLAND, Jumping, LARM, LLEG, MECH::mapindex, mech_notify(), mech_printf(), MECH_USUALO, MECHALL, MechLOSBroadcast(), MechMove, MechPilot, MechRealTons, MechSections, MAP::mechsOnMap, MechTeam, MechTons, MechType, MechX, MechY, NUM_BSUIT_MEMBERS, Number, OODing, RARM, RLEG, ROAD, SectHasBusyWeap(), SectIsDestroyed, and tprintf().
00987 { 00988 MECH *mech = (MECH *) data; 00989 MECH *target; 00990 MAP *map = getMap(mech->mapindex); 00991 int terrain; 00992 int limbs = 4; 00993 int aLimbs[] = { RARM, LARM, LLEG, RLEG }; 00994 int i; 00995 int tempLoc; 00996 char locName[50]; 00997 int damage, tempDamage; 00998 00999 cch(MECH_USUALO); 01000 DOCHECK(!Fallen(mech), "You need to be prone to thrash!"); 01001 DOCHECK(!map, "Invalid map! Contact a wizard!"); 01002 01003 terrain = GetRTerrain(map, MechX(mech), MechY(mech)); 01004 01005 DOCHECK(!((terrain == GRASSLAND) || (terrain == ROAD) || 01006 (terrain == BRIDGE)), 01007 "Thrashing only works in clear terrain or on roads or bridges."); 01008 01009 /* Check locations */ 01010 for(i = 0; i < 4; i++) { 01011 tempLoc = aLimbs[i]; 01012 01013 if(SectIsDestroyed(mech, tempLoc)) { 01014 limbs--; 01015 continue; 01016 } 01017 01018 ArmorStringFromIndex(tempLoc, locName, MechType(mech), 01019 MechMove(mech)); 01020 01021 DOCHECK(SectHasBusyWeap(mech, tempLoc), 01022 tprintf("You have weapons recycling on your %s.", locName)); 01023 DOCHECK(MechSections(mech)[tempLoc].recycle, 01024 tprintf("Your %s is still recovering from your last attack.", 01025 locName)); 01026 } 01027 01028 /* Can't thrash if we have no limbs */ 01029 if(!limbs) { 01030 mech_notify(mech, MECHALL, "You can't thrash if you have no limbs!"); 01031 return; 01032 } 01033 #ifndef REALWEIGHT_DAMAGE 01034 damage = MechTons(mech) / 3; 01035 #else 01036 damage = MechRealTons(mech) / 3; 01037 #endif /* REALWEIGHT_DAMAGE */ 01038 damage = (damage * limbs) / 4; 01039 01040 mech_notify(mech, MECHALL, 01041 "You start to flail your arms and legs like a wild man!"); 01042 MechLOSBroadcast(mech, 01043 "starts to flail its arms and legs like a wild beast!"); 01044 01045 /* Let's see who we can smack around */ 01046 for(i = 0; i < map->first_free; i++) { 01047 if(map->mechsOnMap[i] >= 0) { 01048 target = (MECH *) FindObjectsData(map->mechsOnMap[i]); 01049 01050 if(!target) 01051 continue; 01052 01053 if(MechType(target) != CLASS_BSUIT) 01054 continue; 01055 01056 if(MechTeam(target) == MechTeam(mech)) 01057 continue; 01058 01059 if(Jumping(target) || OODing(target)) 01060 continue; 01061 01062 if(FaMechRange(mech, target) > 1.0) 01063 continue; 01064 01065 mech_printf(mech, MECHALL, "You manage to hit %s!", 01066 GetMechToMechID(mech, target)); 01067 mech_printf(target, MECHALL, 01068 "You get hit by %s's thrashing limbs!", 01069 GetMechToMechID(target, mech)); 01070 01071 tempDamage = damage; 01072 01073 while (tempDamage > 0) { 01074 if(tempDamage > 5) { 01075 DamageMech(target, mech, 1, MechPilot(mech), Number(0, 01076 NUM_BSUIT_MEMBERS 01077 - 1), 01078 0, 0, 5, 0, -1, 0, -1, 0, 1); 01079 tempDamage -= 5; 01080 } else { 01081 DamageMech(target, mech, 1, MechPilot(mech), Number(0, 01082 NUM_BSUIT_MEMBERS 01083 - 1), 01084 0, 0, tempDamage, 0, -1, 0, -1, 0, 1); 01085 tempDamage = 0; 01086 } 01087 } 01088 } 01089 } 01090 01091 /* Make our roll and recycle our limbs -- Removed. You gotta be prone anyways! */ 01092 /* if(!MadePilotSkillRoll_Advanced(mech, 0, 0)) { 01093 MechFalls(mech, 1, 1); 01094 } 01095 */ 01096 01097 for(i = 0; i < 4; i++) { 01098 tempLoc = aLimbs[i]; 01099 01100 if(SectIsDestroyed(mech, tempLoc)) 01101 continue; 01102 01103 SetRecycleLimb(mech, tempLoc, PHYSICAL_RECYCLE_TIME); 01104 } 01105 }
| void mech_turnmode | ( | dbref | player, | |
| void * | data, | |||
| char * | buffer | |||
| ) |
Definition at line 100 of file mech.move.c.
References GetTurnMode, GotPilot, HasBoolAdvantage(), mech_notify(), mech_printf(), MECHALL, MechPilot, MECHPILOT, notify, and SetTurnMode.
00101 { 00102 MECH *mech = (MECH *) data; 00103 00104 if(!GotPilot(mech) || MechPilot(mech) != player) { 00105 notify(player, "You're not the pilot!"); 00106 return; 00107 } 00108 00109 if(!HasBoolAdvantage(player, "maneuvering_ace")) { 00110 mech_notify(mech, MECHPILOT, "You're not skilled enough to do that."); 00111 return; 00112 } 00113 00114 if(buffer && !strcasecmp(buffer, "tight")) { 00115 SetTurnMode(mech, 1); 00116 mech_notify(mech, MECHALL, "You brace for tighter turns."); 00117 return; 00118 } 00119 if(buffer && !strcasecmp(buffer, "normal")) { 00120 SetTurnMode(mech, 0); 00121 mech_notify(mech, MECHALL, "You assume a normal turn mode."); 00122 return; 00123 } 00124 mech_printf(mech, MECHALL, "Your turning type is : %s", 00125 GetTurnMode(mech) ? "TIGHT" : "NORMAL"); 00126 return; 00127 }
| void mech_turret | ( | dbref | player, | |
| void * | data, | |||
| char * | buffer | |||
| ) |
Definition at line 699 of file mech.move.c.
References AcceptableDegree(), args, cch, CLASS_BSUIT, CLASS_MECH, CLASS_MW, DOCHECK, GetSectInt, is_aero, MarkForLOSUpdate(), mech_parseattributes(), mech_printf(), MECH_USUALO, MECHALL, MechFacing, MechTankCritStatus, MechTurretFacing, MechType, notify_printf(), TURRET, TURRET_JAMMED, and TURRET_LOCKED.
00700 { 00701 MECH *mech = (MECH *) data; 00702 char *args[1]; 00703 int newheading; 00704 00705 cch(MECH_USUALO); 00706 DOCHECK(MechType(mech) == CLASS_MECH || MechType(mech) == CLASS_MW || 00707 MechType(mech) == CLASS_BSUIT || is_aero(mech) || 00708 !GetSectInt(mech, TURRET), "You don't have a turret."); 00709 DOCHECK(MechTankCritStatus(mech) & TURRET_JAMMED, 00710 "Your turret is jammed in position."); 00711 DOCHECK(MechTankCritStatus(mech) & TURRET_LOCKED, 00712 "Your turret is locked in position."); 00713 if(mech_parseattributes(buffer, args, 1) == 1) { 00714 newheading = AcceptableDegree(atoi(args[0]) - MechFacing(mech)); 00715 MechTurretFacing(mech) = newheading; 00716 mech_printf(mech, MECHALL, "Turret facing changed to %d.", 00717 AcceptableDegree(MechTurretFacing(mech) + 00718 MechFacing(mech))); 00719 } else { 00720 notify_printf(player, "Your turret is currently facing %d.", 00721 AcceptableDegree(MechTurretFacing(mech) + 00722 MechFacing(mech))); 00723 } 00724 00725 MarkForLOSUpdate(mech); 00726 }
| void mech_vertical | ( | dbref | player, | |
| void * | data, | |||
| char * | buffer | |||
| ) |
Definition at line 936 of file mech.move.c.
References AeroFreeFuel, AeroFuel, args, cch, CLASS_VTOL, DOCHECK, Fallen, Landed, MaybeMove, mech_parseattributes(), mech_printf(), MECH_USUAL, MECHALL, MechDesiredSpeed, MechMove, MechType, MechVerticalSpeed, MMaxSpeed, MOVE_SUB, notify, NotInWater, tprintf(), and WaterBeast.
00937 { 00938 MECH *mech = (MECH *) data; 00939 char *args[1], buff[50]; 00940 float newspeed, maxspeed; 00941 00942 cch(MECH_USUAL); 00943 DOCHECK(MechType(mech) != CLASS_VTOL && 00944 MechMove(mech) != MOVE_SUB, "This command is for VTOLs only."); 00945 DOCHECK(MechType(mech) == CLASS_VTOL && 00946 AeroFuel(mech) <= 0 00947 && !AeroFreeFuel(mech), "You're out of fuel!"); 00948 DOCHECK(WaterBeast(mech) 00949 && NotInWater(mech), 00950 "You are regrettably unable to move at this time. We apologize for the inconvenience."); 00951 DOCHECK(mech_parseattributes(buffer, args, 1) != 1, 00952 tprintf("Current vertical speed is %.2f KPH.", 00953 (float) MechVerticalSpeed(mech))); 00954 newspeed = atof(args[0]); 00955 maxspeed = MMaxSpeed(mech); 00956 maxspeed = 00957 sqrt((float) maxspeed * maxspeed - 00958 MechDesiredSpeed(mech) * MechDesiredSpeed(mech)); 00959 if((newspeed > maxspeed) || (newspeed < -maxspeed)) { 00960 sprintf(buff, "Max vertical speed is + %d KPH and - %d KPH", 00961 (int) maxspeed, (int) maxspeed); 00962 notify(player, buff); 00963 } else { 00964 DOCHECK(Fallen(mech), "Your vehicle's movement system is destroyed."); 00965 DOCHECK(MechType(mech) == CLASS_VTOL && 00966 Landed(mech), "You need to take off first."); 00967 MechVerticalSpeed(mech) = newspeed; 00968 mech_printf(mech, MECHALL, 00969 "Vertical speed changed to %d KPH", (int) newspeed); 00970 MaybeMove(mech); 00971 } 00972 }
| float MechCargoMaxSpeed | ( | MECH * | mech, | |
| float | mspeed | |||
| ) |
Definition at line 298 of file mech.move.c.
References c, CARGO_TECH, CARRIER_TECH, CLASS_MECH, Destroyed, FindObjectsData(), get_weight(), getMech(), HasBoolAdvantage(), InGravity, InSpecial, LOAD_OK, MapGravity, MECH::mapindex, MASC_ENABLED, MAX, MechCarriedCargo, MechCarrying, MechCritStatus, MechHeat, MechMaxSpeed, MechPilot, MechRCTonsV, MechRealTons, MechRMaxSpeed, MechRTonsV, MechSpecials, MechSpecials2, MechStatus, MechStatus2, MechTons, MechType, MechWalkXPFactor, MMaxSpeed, MoveModeChange, MP1, OWEIGHT_OK, SALVAGE_TECH, SCHARGE_ENABLED, SPEED_OK, SPRINTING, TRIPLE_MYOMER_TECH, and WalkingSpeed.
Referenced by fun_btgetrealmaxspeed().
00299 { 00300 int lugged = 0, mod = 2; 00301 MECH *c; 00302 MAP *map; 00303 00304 if(MechCarrying(mech) > 0) { /* Ug-lee! */ 00305 MECH *t; 00306 00307 if((t = getMech(MechCarrying(mech)))) 00308 if(!(MechCritStatus(t) & OWEIGHT_OK)) 00309 MechCritStatus(mech) &= ~LOAD_OK; 00310 00311 } 00312 00315 if((MechCritStatus(mech) & LOAD_OK) && 00316 (MechCritStatus(mech) & OWEIGHT_OK) && 00317 (MechCritStatus(mech) & SPEED_OK)) { 00318 00319 mspeed = MechRMaxSpeed(mech); 00320 #if 0 00321 00322 /* Is masc and/or scharge on */ 00323 if((MechStatus(mech) & MASC_ENABLED) && 00324 (MechStatus(mech) & SCHARGE_ENABLED)) 00325 mspeed = ceil((rint(mspeed / 1.5) / MP1) * 2.5) * MP1; 00326 else if(MechStatus(mech) & MASC_ENABLED) 00327 mspeed *= 4. / 3.; 00328 else if(MechStatus(mech) & SCHARGE_ENABLED) 00329 mspeed *= 4. / 3.; 00330 00331 if(InSpecial(mech) && InGravity(mech)) 00332 if((map = FindObjectsData(mech->mapindex))) 00333 mspeed = mspeed * 100 / MAX(50, MapGravity(map)); 00334 00335 #else 00336 /* Is masc and/or scharge and/or sprinting on */ 00337 if(MechStatus(mech) & (MASC_ENABLED | SCHARGE_ENABLED) || 00338 MechStatus2(mech) & SPRINTING) 00339 mspeed = WalkingSpeed(mspeed) * (1.5 + 00340 (MechStatus(mech) & MASC_ENABLED 00341 ? 0.5 : 0.0) + 00342 (MechStatus(mech) & 00343 SCHARGE_ENABLED ? 0.5 : 0.0) + 00344 (!MoveModeChange(mech) 00345 && MechStatus2(mech) & SPRINTING 00346 ? 0.5 : 0.0)); 00347 00348 /* if the player has speed demon give him his boost in speed */ 00349 if(!MoveModeChange(mech) && MechStatus2(mech) & SPRINTING 00350 && HasBoolAdvantage(MechPilot(mech), "speed_demon")) 00351 mspeed += MP1; 00352 00353 if(InSpecial(mech) && InGravity(mech)) 00354 if((map = FindObjectsData(mech->mapindex))) 00355 mspeed = mspeed * 100.0 / (float)MAX(50, MapGravity(map)); 00356 00357 #endif 00358 return mspeed; 00359 } 00360 MechRTonsV(mech) = get_weight(mech); 00361 00363 if(!(MechCritStatus(mech) & LOAD_OK)) { 00364 if(MechCarrying(mech) > 0) 00365 if((c = getMech(MechCarrying(mech)))) { 00366 lugged = get_weight(c) * 2; 00367 if(MechSpecials(mech) & SALVAGE_TECH) 00368 lugged = lugged / 2; 00369 if((MechSpecials(mech) & TRIPLE_MYOMER_TECH) && 00370 (MechHeat(mech) >= 9.)) 00371 lugged = lugged / 2; 00372 00373 if(MechSpecials2(mech) & CARRIER_TECH) 00374 lugged = lugged / 2; 00375 } 00376 00377 if(MechSpecials(mech) & CARGO_TECH) 00378 mod = 1; 00379 00380 if(MechType(mech) == CLASS_MECH) 00381 mod = mod * 2; 00382 00383 lugged += MechCarriedCargo(mech) * mod / 2; 00384 MechRCTonsV(mech) = lugged; 00385 MechCritStatus(mech) |= LOAD_OK; 00386 } 00387 if(Destroyed(mech)) 00388 mspeed = 0.0; 00389 else { 00390 int mv = MechRTonsV(mech); 00391 int sv = MechTons(mech) * 1024; 00392 00393 if(mv == 1 && !Destroyed(mech)) 00394 mv = sv; 00395 else { 00396 if(mv > sv) 00397 mv = mv + (mv - sv) / 2; 00398 else 00399 mv = mv + (sv - mv) / 3; 00400 } 00401 if(3 * sv < (MechRCTonsV(mech) + mv)) 00402 mspeed = 0.0; 00403 else 00404 #ifdef WEIGHT_OVERSPEEDING 00405 mspeed = 00406 MechMaxSpeed(mech) * MechTons(mech) * 1024.0 / MAX(1024 * 00407 MechRealTons 00408 (mech) + 00409 MechRCTonsV 00410 (mech) / 3, 00411 (MAX 00412 (1024, 00413 mv + 00414 MechRCTonsV 00415 (mech)))); 00416 #else 00417 mspeed = 00418 MechMaxSpeed(mech) * MechTons(mech) * 1024.0 / MAX(1024 * 00419 MechTons 00420 (mech) + 00421 MechRCTonsV 00422 (mech) / 3, 00423 (MAX 00424 (1024, 00425 mv + 00426 MechRCTonsV 00427 (mech)))); 00428 #endif /* WEIGHT_OVERSPEEDING */ 00429 } 00430 MechRMaxSpeed(mech) = mspeed; 00431 MechWalkXPFactor(mech) = MAX(1, (int) mspeed / MP1) * 2; 00432 MechCritStatus(mech) |= SPEED_OK; 00433 return MMaxSpeed(mech); 00434 }
| void MechFalls | ( | MECH * | mech, | |
| int | levels, | |||
| int | seemsg | |||
| ) |
Definition at line 1766 of file mech.move.c.
References AcceptableDegree(), AddFacing, BACK, CLASS_BSUIT, CLASS_MECH, CLASS_MW, CountSwarmers(), DamageMech(), DFA_ATTACK, DropSetElevation(), EVENT_JUMPSTABIL, EVENT_MOVEMODE, FALLEN, FindHitLocation(), FindObjectsData(), FRONT, headhitmwdamage(), HIGHWATER, InSpecial, InWater, JUMP_TO_HIT_RECYCLE, Jumping, JUMPING, LANDED, LEFTSIDE, MadePilotSkillRoll(), MakeMechFall, MapGravity, MECH::mapindex, MapUnderSpecialRules, MarkForLOSUpdate(), MaybeMove, mech_notify(), mech_stabilizing_event(), MECHALL, MechCocoon, MechDesiredFacing, MechDesiredSpeed, MECHEVENT, MechFacing, MechFloods(), MechFZ, MechGoingY, MechLOSBroadcast(), MechMove, MECHPILOT, MechRealTons, MechRTerrain, MechSpeed, MechStartFX, MechStartFY, MechStartFZ, MechStatus, MechStatus2, MechTons, MechType, MechVerticalSpeed, MechZ, MIN, MINE_FALL, MODE_EVADE, MODE_OFF, MODE_SPRINT, MOVE_FLY, MOVE_VTOL, MoveModeChange, Number, possible_mine_poof(), RIGHTSIDE, SetFacing, SPRINTING, StopBSuitSwarmers(), StopJump, StopMoveMode, StopMoving, TURN, water_extinguish_inferno(), and ZSCALE.
Referenced by ChargeMech(), check_stagger_event(), CheckDamage(), CheckVTOLHeight(), DeathFromAbove(), DestroyParts(), DoVehicleEngineHit(), drop_thru_ice(), fun_btmakepilotroll(), HandleMechCrit(), HandleOverheat(), HandleVTOLCrit(), LandMech(), mech_bootlegger(), mech_drop(), mech_fall_event(), mech_jump(), mech_land(), mech_masc_event(), mech_ood_event(), mech_shutdown(), mech_stand(), mech_udisembark(), move_mech(), NewHexEntered(), PhysicalAttack(), PhysicalDamage(), PhysicalTrip(), swim_except(), and UpdatePilotSkillRolls().
01767 { 01768 int roll, spread, i, hitloc, hitGroup = 0; 01769 int isrear = 0, damage, iscritical = 0; 01770 MAP *map; 01771 01772 /* get rid of our swarmers */ 01773 if(CountSwarmers(mech)) 01774 StopBSuitSwarmers(FindObjectsData(mech->mapindex), mech, 0); 01775 01776 /* damage pilot */ 01777 MechCocoon(mech) = 0; 01778 if(MechType(mech) == CLASS_MECH || MechType(mech) == CLASS_MW || seemsg) 01779 mech_notify(mech, MECHPILOT, 01780 "You try to avoid taking damage in the fall."); 01781 else 01782 mech_notify(mech, MECHPILOT, "You try to avoid taking damage."); 01783 if(!MadePilotSkillRoll(mech, levels)) { 01784 if(MechType(mech) == CLASS_MECH || MechType(mech) == CLASS_MW || 01785 seemsg) 01786 mech_notify(mech, MECHPILOT, 01787 "You take personal injury from the fall!"); 01788 else 01789 mech_notify(mech, MECHPILOT, "You take personal injury!"); 01790 headhitmwdamage(mech, mech, 1); 01791 } 01792 MechSpeed(mech) = 0; 01793 MechDesiredSpeed(mech) = 0; 01794 if(Jumping(mech)) { 01795 MechStatus(mech) &= ~JUMPING; 01796 MechStatus(mech) &= ~DFA_ATTACK; 01797 StopJump(mech); 01798 MECHEVENT(mech, EVENT_JUMPSTABIL, mech_stabilizing_event, 01799 JUMP_TO_HIT_RECYCLE, 0); 01800 } 01801 #ifdef BT_MOVEMENT_MODES 01802 if(MoveModeChange(mech)) 01803 StopMoveMode(mech); 01804 if(MechStatus2(mech) & SPRINTING) 01805 MECHEVENT(mech, EVENT_MOVEMODE, mech_movemode_event, 01806 (MechType(mech) == CLASS_BSUIT 01807 || MechType(mech) == CLASS_MW) ? TURN / 2 : TURN, 01808 MODE_SPRINT | MODE_OFF); 01809 if(MechStatus2(mech) & EVADING) 01810 MECHEVENT(mech, EVENT_MOVEMODE, mech_movemode_event, 01811 (MechType(mech) == CLASS_BSUIT 01812 || MechType(mech) == CLASS_MW) ? TURN / 2 : TURN, 01813 MODE_EVADE | MODE_OFF); 01814 #endif 01815 if(MechMove(mech) == MOVE_VTOL || MechMove(mech) == MOVE_FLY) { 01816 MechVerticalSpeed(mech) = 0; 01817 MechGoingY(mech) = 0; 01818 MechStartFX(mech) = 0.0; 01819 MechStartFY(mech) = 0.0; 01820 MechStartFZ(mech) = 0.0; 01821 MechStatus(mech) |= LANDED; 01822 if(MechMove(mech) == MOVE_VTOL) 01823 mech_notify(mech, MECHALL,"Your rotor has been destroyed!"); 01824 MechStatus(mech) |= FALLEN; 01825 StopMoving(mech); 01826 } else 01827 MaybeMove(mech); 01828 if(MechType(mech) == CLASS_MECH || MechType(mech) == CLASS_MW) 01829 MakeMechFall(mech); 01830 01831 if(seemsg) 01832 MechLOSBroadcast(mech, "falls down!"); 01833 DropSetElevation(mech, 1); 01834 MechFZ(mech) = MechZ(mech) * ZSCALE; 01835 01836 roll = Number(1, 6); 01837 switch (roll) { 01838 case 1: 01839 hitGroup = FRONT; 01840 break; 01841 case 2: 01842 AddFacing(mech, 60); 01843 hitGroup = RIGHTSIDE; 01844 break; 01845 case 3: 01846 AddFacing(mech, 120); 01847 hitGroup = RIGHTSIDE; 01848 break; 01849 case 4: 01850 AddFacing(mech, 180); 01851 hitGroup = BACK; 01852 break; 01853 case 5: 01854 AddFacing(mech, 240); 01855 hitGroup = LEFTSIDE; 01856 break; 01857 case 6: 01858 AddFacing(mech, 300); 01859 hitGroup = LEFTSIDE; 01860 break; 01861 } 01862 if(hitGroup == BACK) 01863 isrear = 1; 01864 SetFacing(mech, AcceptableDegree(MechFacing(mech))); 01865 MechDesiredFacing(mech) = MechFacing(mech); 01866 if(!InWater(mech) && MechRTerrain(mech) != HIGHWATER) 01867 #ifndef REALWEIGHT_DAMAGE 01868 damage = (levels * (MechTons(mech) + 5)) / 10; 01869 #else 01870 damage = (levels * (MechRealTons(mech) + 5)) / 10; 01871 #endif /* REALWEIGHT_DAMAGE */ 01872 else 01873 #ifndef REALWEIGHT_DAMAGE 01874 damage = (levels * (MechTons(mech) + 5)) / 20; 01875 #else 01876 damage = (levels * (MechRealTons(mech) + 5)) / 20; 01877 #endif /* REALWEIGHT_DAMAGE */ 01878 if(InSpecial(mech)) 01879 if((map = FindObjectsData(mech->mapindex))) 01880 if(MapUnderSpecialRules(map)) 01881 damage = damage * MIN(100, MapGravity(map)) / 100; 01882 01883 if(MechType(mech) == CLASS_MW) 01884 damage *= 40; 01885 01886 spread = damage / 5; 01887 01888 for(i = 0; i < spread; i++) { 01889 hitloc = FindHitLocation(mech, hitGroup, &iscritical, &isrear); 01890 DamageMech(mech, mech, 0, -1, hitloc, isrear, iscritical, 5, -1, 01891 -1, 0, -1, 0, 0); 01892 MechFloods(mech); 01893 water_extinguish_inferno(mech); 01894 } 01895 if(damage % 5) { 01896 hitloc = FindHitLocation(mech, hitGroup, &iscritical, &isrear); 01897 DamageMech(mech, mech, 0, -1, hitloc, isrear, iscritical, 01898 (damage % 5), -1, -1, 0, -1, 0, 0); 01899 MechFloods(mech); 01900 water_extinguish_inferno(mech); 01901 } 01902 01903 possible_mine_poof(mech, MINE_FALL); 01904 MarkForLOSUpdate(mech); 01905 }
| void MechFloods | ( | MECH * | mech | ) |
Definition at line 1724 of file mech.move.c.
References CLASS_BSUIT, CLASS_MECH, DestroyMech(), InWater, KillMechContentsIfIC(), mech_notify(), MECHALL, MechElevation, MechFloodsLoc(), MechLOSBroadcast(), MechSpecials2, MechSwarmTarget, MechType, MechZ, NUM_SECTIONS, and WATERPROOF_TECH.
Referenced by DeathFromAbove(), LandMech(), mech_drop(), mech_ood_event(), MechFalls(), move_mech(), NewHexEntered(), and StopSwarming().
01725 { 01726 int i; 01727 int elev = MechElevation(mech); 01728 01729 if(!InWater(mech)) 01730 return; 01731 01732 /* Waterproof Tech - no flooding if we have this */ 01733 if(MechSpecials2(mech) & WATERPROOF_TECH) 01734 return; 01735 01736 if(MechType(mech) == CLASS_BSUIT) { 01737 01738 if(MechSwarmTarget(mech) > 0) 01739 return; 01740 01741 mech_notify(mech, MECHALL, 01742 "You somehow find yourself in water and realize this may really really suck..."); 01743 mech_notify(mech, MECHALL, 01744 "Everything gets very dark as water starts to fill your suit " 01745 "and you sink towards the bottom!"); 01746 01747 MechLOSBroadcast(mech, 01748 "shudders, splashes in the water for a second, then goes limp " 01749 "and sinks to the bottom."); 01750 01751 KillMechContentsIfIC(mech->mynum); 01752 DestroyMech(mech, mech, 0); 01753 return; 01754 } 01755 01756 if(MechType(mech) != CLASS_MECH) 01757 return; 01758 01759 if(MechZ(mech) >= 0) 01760 return; 01761 01762 for(i = 0; i < NUM_SECTIONS; i++) 01763 MechFloodsLoc(mech, i, elev); 01764 }
| void MechFloodsLoc | ( | MECH * | mech, | |
| int | loc, | |||
| int | lev | |||
| ) |
Definition at line 1685 of file mech.move.c.
References ArmorStringFromIndex(), CLASS_MECH, COMBAT_SAFE, DestroyParts(), Fallen, GetSectArmor, GetSectInt, GetSectORArmor, GetSectRArmor, InWater, LARM, LLEG, mech_printf(), MECHALL, MechIsQuad, MechLOSBroadcast(), MechMove, MechStatus, MechType, RARM, RLEG, SectIsFlooded, SetSectFlooded, and tprintf().
Referenced by cause_armordamage(), DamageMech(), and MechFloods().
01686 { 01687 char locbuff[32];; 01688 01689 if(MechStatus(mech) & COMBAT_SAFE) 01690 return; 01691 01692 if((GetSectArmor(mech, loc) && (GetSectRArmor(mech, loc) || 01693 !GetSectORArmor(mech, loc))) 01694 || !GetSectInt(mech, loc)) 01695 return; 01696 if(!InWater(mech)) 01697 return; 01698 if(lev >= 0) 01699 return; 01700 /* No armor, and in water. */ 01701 if(lev == -1 && (!Fallen(mech) && loc != LLEG && loc != RLEG && 01702 (!MechIsQuad(mech) || (loc != LARM && loc != RARM)))) 01703 return; 01704 if(MechType(mech) != CLASS_MECH) 01705 return; 01706 01707 if(SectIsFlooded(mech, loc)) 01708 return; 01709 01710 /* Woo, valid target. */ 01711 ArmorStringFromIndex(loc, locbuff, MechType(mech), MechMove(mech)); 01712 mech_printf(mech, MECHALL, 01713 "%%ch%%crWater floods into your %s disabling everything that was there!%%c", 01714 locbuff); 01715 MechLOSBroadcast(mech, 01716 tprintf("has a gaping hole in %s, and water pours in!", 01717 locbuff)); 01718 01719 SetSectFlooded(mech, loc); 01720 DestroyParts(mech, mech, loc, 1, 1); 01721 01722 }
| int mechs_in_hex | ( | MAP * | map, | |
| int | x, | |||
| int | y, | |||
| int | friendly, | |||
| int | team | |||
| ) |
Definition at line 1907 of file mech.move.c.
References CARRIER_TECH, CLASS_MECH, Destroyed, FindObjectsData(), MAP::first_free, IsDS, Jumping, Landed, MAP::mechsOnMap, MechSpecials2, MechTeam, MechType, MechX, MechY, OODing, and Started.
Referenced by domino_space().
01908 { 01909 MECH *mech; 01910 int i, cnt = 0; 01911 01912 for(i = 0; i < map->first_free; i++) 01913 if((mech = FindObjectsData(map->mechsOnMap[i]))) { 01914 if(MechX(mech) != x || MechY(mech) != y) 01915 continue; 01916 if(Destroyed(mech)) 01917 continue; 01918 if(!(MechSpecials2(mech) & CARRIER_TECH) && IsDS(mech) 01919 && (Landed(mech) || !Started(mech))) { 01920 cnt += 2; 01921 continue; 01922 } 01923 if(MechType(mech) != CLASS_MECH) 01924 continue; 01925 if(Jumping(mech) || OODing(mech)) 01926 continue; 01927 if(friendly < 0 || ((MechTeam(mech) == team) == friendly)) 01928 cnt++; 01929 } 01930 return cnt; 01931 }
| int flag |
Definition at line 779 of file mech.move.c.
Referenced by char_getskilltargetbycode_base(), CheckGenericFail(), CheckWeaponFailed(), critslot_func(), do_channelwho(), do_search(), DoSpecialObjectHelp(), fun_foreach(), list_xcodestuff(), Mech_ShowFlags(), mech_speed(), PrintArmorStatus(), and show_charstatus().
| char* full |
Definition at line 40 of file mech.move.c.
Referenced by mech_lateral(), mech_lateral_event(), and TECHCOMMANDH().
| struct { ... } lateral_modes[] |
Referenced by LateralDesc(), and mech_lateral().
| char* name |
Definition at line 778 of file mech.move.c.
| char* name |
Definition at line 39 of file mech.move.c.
| int ofs |
| struct { ... } speed_tables[] |
Referenced by mech_speed().
1.4.7