/*
* Copyright (c) 1999-2005 Kevin Stevens
* All rights reserved
*/
/*
Code to read and write mech and vehicle templates
Created by Nim 9/16/96
$Id: template.c,v 1.9 2005/08/10 14:09:34 av1-op Exp $
Last modified: Fri Sep 18 13:02:31 1998 fingon
*/
/* 01/21/02 Added many commods <GB> */
/* 09/16/96 Some touches by Markus Stenberg <fingon@iki.fi> */
/* 09/16/96 Some?? ... ya right ;-) (nim) */
/* 09/17/96 Ok, ton of touches then :-P (Mark) */
#include "config.h"
#define MAX_STRING_LENGTH 8192
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "mech.h"
#include "create.h"
#include "mech.events.h"
#include "coolmenu.h"
#include "failures.h"
#include "aero.bomb.h"
#include "mech.partnames.h"
#include "p.mech.utils.h"
#include "p.mech.partnames.h"
#include "p.mech.consistency.h"
#include "p.map.conditions.h"
#include "p.aero.bomb.h"
#include "p.mech.mechref_ident.h"
#include "p.crit.h"
#include "p.bsuit.h"
#include "p.mech.c3.h"
#define MODE_UNKNOWN 0
#define MODE_NORMAL 1
char *load_cmds[] = {
"Reference", "Type", "Move_Type", "Tons", "Tac_Range",
"LRS_Range", "Radio_Range", "Scan_Range", "Heat_Sinks",
"Max_Speed", "Specials", "Armor", "Internals", "Rear",
"Config", "Computer", "Name", "Jump_Speed", "Radio",
"SI", "Fuel", "Comment", "RadioType",
"Mech_BV", "Cargo_Space", "Max_Suits", "InfantrySpecials",
"Max_Ton",
NULL
};
char *internals[] = {
"ShoulderOrHip",
"UpperActuator",
"LowerActuator",
"HandOrFootActuator",
"LifeSupport",
"Sensors",
"Cockpit",
"Engine",
"Gyro",
"HeatSink",
"JumpJet",
"Case",
"FerroFibrous",
"EndoSteel",
"TripleStrengthMyomer",
"TargetingComputer",
"Masc",
"C3Master",
"C3Slave",
"BeagleProbe",
"ArtemisIV",
"Ecm",
"Axe",
"Sword",
"Mace",
"Claw",
"DSAeroDoor",
"DSMechDoor",
"Fuel_Tank",
"TAG",
"DSVehicleDoor",
"DSCargoDoor",
"LAM_Equipment",
"CaseII",
"StealthArmor",
"NullSig_Device",
"C3i",
"AngelEcm",
"HvyFerroFibrous",
"LtFerroFibrous",
"BloodhoundProbe",
"PurifierArmor",
"KageStealthUnit",
"AchileusStealthUnit",
"InfiltratorStealthUnit",
"InfiltratorIIStealthUnit",
"SuperCharger",
NULL
};
#ifdef BT_PART_WEIGHTS
int internalsweight[] = {
102, /* ShoulderOrHip */
102, /* UpperActuator */
102, /* LowerActuator */
102, /* HandOrFootActuator */
204, /* LifeSupport */
102, /* Sensors */
512, /* Cockpit */
1024, /* Engine */
512, /* Gyro */
204, /* HeatSink */
204, /* JumpJet */
51, /* Case */
153, /* FerroFibrous */
153, /* EndoSteel */
51, /* TripleStrengthMyomer */
204, /* TargetingComputer */
51, /* Masc */
512, /* C3Master */
102, /* C3Slave */
102, /* BeagleProbe */
153, /* ArtemisIV */
204, /* Ecm */
51, /* Axe */
25, /* Sword */
102, /* Mace */
75, /* Claw */
1024, /* DSAeroDoor */
1024, /* DSMechDoor */
102, /* Fuel_Tank */
51, /* TAG */
1024, /* DSVehicleDoor */
1024, /* DSCargoDoor */
306, /* LAM_Equipment */
306, /* CaseII */
3, /* StealthArmor */
1024, /* NullSig_Device */
512, /* C3i */
204, /* AngelECM */
7, /* HvyFerroFibrous */
1, /* LtFerroFibrous */
102, /* BloodhoundProbe */
2, /* PurifierArmor */
102, /* KageStealthUnit */
102, /* AchileusStealthUnit */
102, /* InfiltratorStealthUnit */
102, /* InfiltratorIIStealthUnit */
};
#endif /* BT_PART_WEIGHTS */
char *cargo[] = {
"Ammo_LBX2",
"Ammo_LBX5_LBX",
"Ammo_LBX10_LBX",
"Ammo_LBX20_LBX",
"Ammo_LRM",
"Ammo_SRM",
"Ammo_SSRM",
"Ammo_LRM_NARC",
"Ammo_SRM_NARC",
"Ammo_SSRM_NARC",
"Ammo_LRM_Artemis",
"Ammo_SRM_Artemis",
"Ammo_SSRM_Artemis",
"Petroleum",
"Phosphorus",
"Hydrogen",
"Gold",
"Natural_Extracts",
"Marijuana",
"Sulfur",
"Sodium",
"Plutonium",
"Ore",
"Steel",
"Plastics",
"Medical_Supplies",
"Computers",
"Explosives",
"ES_Internal",
"FF_Armor",
"XL_Engine",
"Double_HeatSink",
"ICE_Engine",
"Electric",
"Internal",
"Armor",
"Actuator",
"Aero_Fuel",
"DS_Fuel",
"VTOL_Fuel",
"Ammo_LRM_Swarm",
"Ammo_LRM_Swarm1",
"Ammo_SRM_Inferno",
"XXL_Engine",
"Compact_Engine",
"HD_Armor",
"RE_Internals",
"CO_Internals",
"Ammo_MRM",
"Light_Engine",
"CaseII",
"STH_Armor",
"NullSigSys",
"Silicon",
"HVY_FF_Armor",
"LT_FF_Armor",
"Ammo_iNARC_Explosive",
"Ammo_iNARC_Haywire",
"Ammo_iNARC_ECM",
"Ammo_iNARC_Nemesis",
"Ammo_AC2_Pierce",
"Ammo_AC5_Pierce",
"Ammo_AC10_Pierce",
"Ammo_AC20_Pierce",
"Ammo_LAC2_Pierce",
"Ammo_LAC5_Pierce",
"Ammo_AC2_Flechette",
"Ammo_AC5_Flechette",
"Ammo_AC10_Flechette",
"Ammo_AC20_Flechette",
"Ammo_LAC2_Flechette",
"Ammo_LAC5_Flechette",
"Ammo_AC2_Incendiary",
"Ammo_AC5_Incendiary",
"Ammo_AC10_Incendiary",
"Ammo_AC20_Incendiary",
"Ammo_LAC2_Incendiary",
"Ammo_LAC5_Incendiary",
"Ammo_AC2_Precision",
"Ammo_AC5_Precision",
"Ammo_AC10_Precision",
"Ammo_AC20_Precision",
"Ammo_LAC2_Precision",
"Ammo_LAC5_Precision",
"Ammo_LR_DFM",
"Ammo_SR_DFM",
"Ammo_SLRM",
"Ammo_ELRM",
"BSuit_Sensor",
"BSuit_LifeSupport",
"BSuit_Electronic",
"Oil",
"Water",
"Earth",
"Oxygen",
"Nitrogen",
"Nickel",
"Steel",
"Iron",
"Brass",
"Platinum",
"Copper",
"Aluminum",
"Consumer_Good",
"Machinery",
"Slaves",
"Timbiqui_Dark",
"Cocaine",
"Heroine",
"Marble",
"Glass",
"Diamond",
"Coal",
"Food",
"Zinc",
"Fabric",
"Clothing",
"Wood",
"Pulp",
"Lumber",
"Rubber",
"Seeds",
"Fertilizer",
"Salt",
"Lithium",
"Helium",
"Larium",
"Uranium",
"Iridium",
"Titanium",
"Concrete",
"FerroCrete",
"Building_Supplies",
"Kevlar",
"Waste",
"Livestock",
"Paper",
"XL_Gyro",
"HeavyDuty_Gyro",
"Compact_Gyro",
"Compact_HeatSink",
"SearchLight",
#ifdef BT_COMPLEXREPAIRS
"Sensors_10",
"Sensors_20",
"Sensors_30",
"Sensors_40",
"Sensors_50",
"Sensors_60",
"Sensors_70",
"Sensors_80",
"Sensors_90",
"Sensors_100",
"Myomer_10",
"Myomer_20",
"Myomer_30",
"Myomer_40",
"Myomer_50",
"Myomer_60",
"Myomer_70",
"Myomer_80",
"Myomer_90",
"Myomer_100",
"TripleMyomer_10",
"TripleMyomer_20",
"TripleMyomer_30",
"TripleMyomer_40",
"TripleMyomer_50",
"TripleMyomer_60",
"TripleMyomer_70",
"TripleMyomer_80",
"TripleMyomer_90",
"TripleMyomer_100",
"Internal_10",
"Internal_20",
"Internal_30",
"Internal_40",
"Internal_50",
"Internal_60",
"Internal_70",
"Internal_80",
"Internal_90",
"Internal_100",
"ES_Internal_10",
"ES_Internal_20",
"ES_Internal_30",
"ES_Internal_40",
"ES_Internal_50",
"ES_Internal_60",
"ES_Internal_70",
"ES_Internal_80",
"ES_Internal_90",
"ES_Internal_100",
"JumpJet_10",
"JumpJet_20",
"JumpJet_30",
"JumpJet_40",
"JumpJet_50",
"JumpJet_60",
"JumpJet_70",
"JumpJet_80",
"JumpJet_90",
"JumpJet_100",
"UpperArmActuator_10",
"UpperArmActuator_20",
"UpperArmActuator_30",
"UpperArmActuator_40",
"UpperArmActuator_50",
"UpperArmActuator_60",
"UpperArmActuator_70",
"UpperArmActuator_80",
"UpperArmActuator_90",
"UpperArmActuator_100",
"LowerArmActuator_10",
"LowerArmActuator_20",
"LowerArmActuator_30",
"LowerArmActuator_40",
"LowerArmActuator_50",
"LowerArmActuator_60",
"LowerArmActuator_70",
"LowerArmActuator_80",
"LowerArmActuator_90",
"LowerArmActuator_100",
"HandActuator_10",
"HandActuator_20",
"HandActuator_30",
"HandActuator_40",
"HandActuator_50",
"HandActuator_60",
"HandActuator_70",
"HandActuator_80",
"HandActuator_90",
"HandActuator_100",
"UpperLegActuator_10",
"UpperLegActuator_20",
"UpperLegActuator_30",
"UpperLegActuator_40",
"UpperLegActuator_50",
"UpperLegActuator_60",
"UpperLegActuator_70",
"UpperLegActuator_80",
"UpperLegActuator_90",
"UpperLegActuator_100",
"LowerLegActuator_10",
"LowerLegActuator_20",
"LowerLegActuator_30",
"LowerLegActuator_40",
"LowerLegActuator_50",
"LowerLegActuator_60",
"LowerLegActuator_70",
"LowerLegActuator_80",
"LowerLegActuator_90",
"LowerLegActuator_100",
"FootActuator_10",
"FootActuator_20",
"FootActuator_30",
"FootActuator_40",
"FootActuator_50",
"FootActuator_60",
"FootActuator_70",
"FootActuator_80",
"FootActuator_90",
"FootActuator_100",
"Engine_20",
"Engine_40",
"Engine_60",
"Engine_80",
"Engine_100",
"Engine_120",
"Engine_140",
"Engine_160",
"Engine_180",
"Engine_200",
"Engine_220",
"Engine_240",
"Engine_260",
"Engine_280",
"Engine_300",
"Engine_320",
"Engine_340",
"Engine_360",
"Engine_380",
"Engine_400",
"XL_Engine_20",
"XL_Engine_40",
"XL_Engine_60",
"XL_Engine_80",
"XL_Engine_100",
"XL_Engine_120",
"XL_Engine_140",
"XL_Engine_160",
"XL_Engine_180",
"XL_Engine_200",
"XL_Engine_220",
"XL_Engine_240",
"XL_Engine_260",
"XL_Engine_280",
"XL_Engine_300",
"XL_Engine_320",
"XL_Engine_340",
"XL_Engine_360",
"XL_Engine_380",
"XL_Engine_400",
"ICE_Engine_20",
"ICE_Engine_40",
"ICE_Engine_60",
"ICE_Engine_80",
"ICE_Engine_100",
"ICE_Engine_120",
"ICE_Engine_140",
"ICE_Engine_160",
"ICE_Engine_180",
"ICE_Engine_200",
"ICE_Engine_220",
"ICE_Engine_240",
"ICE_Engine_260",
"ICE_Engine_280",
"ICE_Engine_300",
"ICE_Engine_320",
"ICE_Engine_340",
"ICE_Engine_360",
"ICE_Engine_380",
"ICE_Engine_400",
"Light_Engine_20",
"Light_Engine_40",
"Light_Engine_60",
"Light_Engine_80",
"Light_Engine_100",
"Light_Engine_120",
"Light_Engine_140",
"Light_Engine_160",
"Light_Engine_180",
"Light_Engine_200",
"Light_Engine_220",
"Light_Engine_240",
"Light_Engine_260",
"Light_Engine_280",
"Light_Engine_300",
"Light_Engine_320",
"Light_Engine_340",
"Light_Engine_360",
"Light_Engine_380",
"Light_Engine_400",
"CO_Internal_10",
"CO_Internal_20",
"CO_Internal_30",
"CO_Internal_40",
"CO_Internal_50",
"CO_Internal_60",
"CO_Internal_70",
"CO_Internal_80",
"CO_Internal_90",
"CO_Internal_100",
"RE_Internal_10",
"RE_Internal_20",
"RE_Internal_30",
"RE_Internal_40",
"RE_Internal_50",
"RE_Internal_60",
"RE_Internal_70",
"RE_Internal_80",
"RE_Internal_90",
"RE_Internal_100",
"Gyro_1",
"Gyro_2",
"Gyro_3",
"Gyro_4",
"XL_Gyro_1",
"XL_Gyro_2",
"XL_Gyro_3",
"XL_Gyro_4",
"HD_Gyro_1",
"HD_Gyro_2",
"HD_Gyro_3",
"HD_Gyro_4",
"Compact_Gyro_1",
"Compact_Gyro_2",
"Compact_Gyro_3",
"Compact_Gyro_4",
"XXL_Engine_20",
"XXL_Engine_40",
"XXL_Engine_60",
"XXL_Engine_80",
"XXL_Engine_100",
"XXL_Engine_120",
"XXL_Engine_140",
"XXL_Engine_160",
"XXL_Engine_180",
"XXL_Engine_200",
"XXL_Engine_220",
"XXL_Engine_240",
"XXL_Engine_260",
"XXL_Engine_280",
"XXL_Engine_300",
"XXL_Engine_320",
"XXL_Engine_340",
"XXL_Engine_360",
"XXL_Engine_380",
"XXL_Engine_400",
"Compact_Engine_20",
"Compact_Engine_40",
"Compact_Engine_60",
"Compact_Engine_80",
"Compact_Engine_100",
"Compact_Engine_120",
"Compact_Engine_140",
"Compact_Engine_160",
"Compact_Engine_180",
"Compact_Engine_200",
"Compact_Engine_220",
"Compact_Engine_240",
"Compact_Engine_260",
"Compact_Engine_280",
"Compact_Engine_300",
"Compact_Engine_320",
"Compact_Engine_340",
"Compact_Engine_360",
"Compact_Engine_380",
"Compact_Engine_400",
#endif
NULL
};
#ifdef BT_PART_WEIGHTS
int cargoweight[] = {
1024, /* Ammo_LBX2 */
1024, /* Ammo_LBX5_LBX */
1024, /* Ammo_LBX10_LBX */
1024, /* Ammo_LBX20_LBX */
1024, /* Ammo_LRM */
1024, /* Ammo_SRM */
1024, /* Ammo_SSRM */
1024, /* Ammo_LRM_NARC */
1024, /* Ammo_SRM_NARC */
1024, /* Ammo_SSRM_NARC */
1024, /* Ammo_LRM_Artemis */
1024, /* Ammo_SRM_Artemis */
1024, /* Ammo_SSRM_Artemis */
102, /* Petroleum */
102, /* Phosphorus */
102, /* Hydrogen */
204, /* Gold */
51, /* Natural_Extracts */
10, /* Marijuana */
10, /* Sulfur */
10, /* Sodium */
306, /* Plutonium */
51, /* Ore */
204, /* Steel */
51, /* Plastics */
8, /* Medical_Supplies */
306, /* Computers */
204, /* Explosives */
5, /* ES_Internal */
2, /* FF_Armor */
512, /* XL_Engine */
342, /* Double_Heatsink */
512, /* ICE_Engine */
51, /* Electric */
5, /* Internal */
3, /* Armor */
102, /* Actuator */
10, /* Aero_Fuel */
20, /* DS_Fuel */
2, /* VTOL_Fuel */
1024, /* Ammo_LRM_Swarm */
1024, /* Ammo_LRM_Swarm1 */
1024, /* Ammo_SRM_Inferno */
1024, /* XXL_Engine */
2048, /* Compact_Engine */
6, /* HD_Armor */
4, /* RE_Internals */
2, /* CO_Internals */
1024, /* Ammo_MRM */
512, /* Light_Engine */
62, /* CaseII */
3, /* STH_Armor */
1024, /* NullSigSys */
80, /* Silicon */
7, /* HVY_FF_Armor */
1, /* LT_FF_Armor */
1024, /* Ammo_iNARC_Explosive */
1024, /* Ammo_iNARC_Haywire */
1024, /* Ammo_iNARC_ECM */
1024, /* Ammo_iNARC_Nemesis */
1024, /* Ammo_AC2_AP */
1024, /* Ammo_AC5_AP */
1024, /* Ammo_AC10_AP */
1024, /* Ammo_AC20_AP */
1024, /* Ammo_LAC2_AP */
1024, /* Ammo_LAC5_AP */
1024, /* Ammo_AC2_Flechette */
1024, /* Ammo_AC5_Flechette */
1024, /* Ammo_AC10_Flechette */
1024, /* Ammo_AC20_Flechette */
1024, /* Ammo_LAC2_Flechette */
1024, /* Ammo_LAC5_Flechette */
1024, /* Ammo_AC2_Incendiary */
1024, /* Ammo_AC5_Incendiary */
1024, /* Ammo_AC10_Incendiary */
1024, /* Ammo_AC20_Incendiary */
1024, /* Ammo_LAC2_Incendiary */
1024, /* Ammo_LAC5_Incendiary */
1024, /* Ammo_AC2_Precision */
1024, /* Ammo_AC5_Precision */
1024, /* Ammo_AC10_Precision */
1024, /* Ammo_AC20_Precision */
1024, /* Ammo_LAC2_Precision */
1024, /* Ammo_LAC5_Precision */
1024, /* Ammo_LR_DFM */
1024, /* Ammo_SR_DFM */
1024, /* Ammo_SLRM */
1024, /* Ammo_ELRM */
102, /* BSuit_Sensor */
61, /* BSuit_LifeSupport */
10, /* BSuit_Electronic */
306, /* Oil */
102, /* Water */
204, /* Earth */
21, /* Oxygen */
102, /* Nitrogen */
102, /* Nickel */
204, /* Steel */
204, /* Iron */
204, /* Brass */
204, /* Platinum */
204, /* Copper */
204, /* Aluminum */
61, /* Consumer_Good */
312, /* Machinery */
102, /* Slaves*/
21, /* Timbiqui_Dark */
10, /* Cocaine */
10, /* Heroine */
424, /* Marble */
408, /* Glass */
204, /* Diamond */
306, /* Coal */
204, /* Food */
102, /* Zinc */
204, /* Fabric */
204, /* Clothing */
408, /* Wood */
204, /* Pulp */
520, /* Lumber */
204, /* Rubber */
102, /* Seeds */
102, /* Fertilizer */
102, /* Salt */
204, /* Lithium */
102, /* Helium */
306, /* Larium */
306, /* Uranium */
306, /* Iridium */
408, /* Titanium */
306, /* Concrete */
204, /* FerroCrete */
204, /* Building_Supplies */
204, /* Kevlar */
204, /* Waste */
308, /* Livestock */
102, /* Paper */
1024, /* XL_Gyro */
2048, /* HeavyDuty_Gyro */
2048, /* Compact_Gyro */
2048, /* Compact_HeatSink */
204, /* SearchLight */
#ifdef BT_COMPLEXREPAIRS
102, /* Sensors_10 */
204, /* Sensors_20 */
306, /* Sensors_30 */
408, /* Sensors_40 */
510, /* Sensors_50 */
612, /* Sensors_60 */
714, /* Sensors_70 */
816, /* Sensors_80 */
918, /* Sensors_90 */
1020, /* Sensors_100 */
102, /* Myomer_10 */
102, /* Myomer_20 */
102, /* Myomer_30 */
102, /* Myomer_40 */
102, /* Myomer_50 */
102, /* Myomer_60 */
102, /* Myomer_70 */
102, /* Myomer_80 */
102, /* Myomer_90 */
102, /* Myomer_100 */
102, /* TripleMyomer_10 */
102, /* TripleMyomer_20 */
102, /* TripleMyomer_30 */
102, /* TripleMyomer_40 */
102, /* TripleMyomer_50 */
102, /* TripleMyomer_60 */
102, /* TripleMyomer_70 */
102, /* TripleMyomer_80 */
102, /* TripleMyomer_90 */
102, /* TripleMyomer_100 */
128, /* Internal_10 */
128, /* Internal_20 */
128, /* Internal_30 */
128, /* Internal_40 */
128, /* Internal_50 */
128, /* Internal_60 */
128, /* Internal_70 */
128, /* Internal_80 */
128, /* Internal_90 */
128, /* Internal_100 */
128, /* ES_Internal_10 */
128, /* ES_Internal_20 */
128, /* ES_Internal_30 */
128, /* ES_Internal_40 */
128, /* ES_Internal_50 */
128, /* ES_Internal_60 */
128, /* ES_Internal_70 */
128, /* ES_Internal_80 */
128, /* ES_Internal_90 */
128, /* ES_Internal_100 */
102, /* JumpJet_10 */
204, /* JumpJet_20 */
306, /* JumpJet_30 */
408, /* JumpJet_40 */
510, /* JumpJet_50 */
612, /* JumpJet_60 */
714, /* JumpJet_70 */
816, /* JumpJet_80 */
918, /* JumpJet_90 */
1020, /* JumpJet_100 */
8, /* UpperArmActuator_10 */
8, /* UpperArmActuator_20 */
8, /* UpperArmActuator_30 */
8, /* UpperArmActuator_40 */
8, /* UpperArmActuator_50 */
8, /* UpperArmActuator_60 */
8, /* UpperArmActuator_70 */
8, /* UpperArmActuator_80 */
8, /* UpperArmActuator_90 */
8, /* UpperArmActuator_100 */
8, /* LowerArmActuator_10 */
8, /* LowerArmActuator_20 */
8, /* LowerArmActuator_30 */
8, /* LowerArmActuator_40 */
8, /* LowerArmActuator_50 */
8, /* LowerArmActuator_60 */
8, /* LowerArmActuator_70 */
8, /* LowerArmActuator_80 */
8, /* LowerArmActuator_90 */
8, /* LowerArmActuator_100 */
8, /* HandActuator_10 */
8, /* HandActuator_20 */
8, /* HandActuator_30 */
8, /* HandActuator_40 */
8, /* HandActuator_50 */
8, /* HandActuator_60 */
8, /* HandActuator_70 */
8, /* HandActuator_80 */
8, /* HandActuator_90 */
8, /* HandActuator_100 */
8, /* UpperLegActuator_10 */
8, /* UpperLegActuator_20 */
8, /* UpperLegActuator_30 */
8, /* UpperLegActuator_40 */
8, /* UpperLegActuator_50 */
8, /* UpperLegActuator_60 */
8, /* UpperLegActuator_70 */
8, /* UpperLegActuator_80 */
8, /* UpperLegActuator_90 */
8, /* UpperLegActuator_100 */
8, /* LowerLegActuator_10 */
8, /* LowerLegActuator_20 */
8, /* LowerLegActuator_30 */
8, /* LowerLegActuator_40 */
8, /* LowerLegActuator_50 */
8, /* LowerLegActuator_60 */
8, /* LowerLegActuator_70 */
8, /* LowerLegActuator_80 */
8, /* LowerLegActuator_90 */
8, /* LowerLegActuator_100 */
8, /* FootActuator_10 */
8, /* FootActuator_20 */
8, /* FootActuator_30 */
8, /* FootActuator_40 */
8, /* FootActuator_50 */
8, /* FootActuator_60 */
8, /* FootActuator_70 */
8, /* FootActuator_80 */
8, /* FootActuator_90 */
8, /* FootActuator_100 */
51, /* Engine_20 */
102, /* Engine_40 */
153, /* Engine_60 */
204, /* Engine_80 */
255, /* Engine_100 */
306, /* Engine_120 */
357, /* Engine_140 */
408, /* Engine_160 */
459, /* Engine_180 */
510, /* Engine_200 */
561, /* Engine_220 */
612, /* Engine_240 */
763, /* Engine_260 */
814, /* Engine_280 */
865, /* Engine_300 */
916, /* Engine_320 */
967, /* Engine_340 */
1018, /* Engine_360 */
1070, /* Engine_380 */
1020, /* Engine_400 */
51, /* XL_Engine_20 */
102, /* XL_Engine_40 */
153, /* XL_Engine_60 */
204, /* XL_Engine_80 */
255, /* XL_Engine_100 */
306, /* XL_Engine_120 */
357, /* XL_Engine_140 */
408, /* XL_Engine_160 */
459, /* XL_Engine_180 */
510, /* XL_Engine_200 */
561, /* XL_Engine_220 */
612, /* XL_Engine_240 */
763, /* XL_Engine_260 */
814, /* XL_Engine_280 */
865, /* XL_Engine_300 */
916, /* XL_Engine_320 */
967, /* XL_Engine_340 */
1018, /* XL_Engine_360 */
1070, /* XL_Engine_380 */
1020, /* XL_Engine_400 */
51, /* ICE_Engine_20 */
102, /* ICE_Engine_40 */
153, /* ICE_Engine_60 */
204, /* ICE_Engine_80 */
255, /* ICE_Engine_100 */
306, /* ICE_Engine_120 */
357, /* ICE_Engine_140 */
408, /* ICE_Engine_160 */
459, /* ICE_Engine_180 */
510, /* ICE_Engine_200 */
561, /* ICE_Engine_220 */
612, /* ICE_Engine_240 */
763, /* ICE_Engine_260 */
814, /* ICE_Engine_280 */
865, /* ICE_Engine_300 */
916, /* ICE_Engine_320 */
967, /* ICE_Engine_340 */
1018, /* ICE_Engine_360 */
1070, /* ICE_Engine_380 */
1020, /* ICE_Engine_400 */
51, /* Light_Engine_20 */
102, /* Light_Engine_40 */
153, /* Light_Engine_60 */
204, /* Light_Engine_80 */
255, /* Light_Engine_100 */
306, /* Light_Engine_120 */
357, /* Light_Engine_140 */
408, /* Light_Engine_160 */
459, /* Light_Engine_180 */
510, /* Light_Engine_200 */
561, /* Light_Engine_220 */
612, /* Light_Engine_240 */
763, /* Light_Engine_260 */
814, /* Light_Engine_280 */
865, /* Light_Engine_300 */
916, /* Light_Engine_320 */
967, /* Light_Engine_340 */
1018, /* Light_Engine_360 */
1070, /* Light_Engine_380 */
1020, /* Light_Engine_400 */
128, /* CO_Internal_10 */
128, /* CO_Internal_20 */
128, /* CO_Internal_30 */
128, /* CO_Internal_40 */
128, /* CO_Internal_50 */
128, /* CO_Internal_60 */
128, /* CO_Internal_70 */
128, /* CO_Internal_80 */
128, /* CO_Internal_90 */
128, /* CO_Internal_100 */
128, /* RE_Internal_10 */
128, /* RE_Internal_20 */
128, /* RE_Internal_30 */
128, /* RE_Internal_40 */
128, /* RE_Internal_50 */
128, /* RE_Internal_60 */
128, /* RE_Internal_70 */
128, /* RE_Internal_80 */
128, /* RE_Internal_90 */
128, /* RE_Internal_100 */
1024, /* Gyro_1 */
2048, /* Gyro_2 */
3072, /* Gyro_3 */
4096, /* Gyro_4 */
1024, /* XL_Gyro_1 */
2048, /* XL_Gyro_2 */
3072, /* XL_Gyro_3 */
4096, /* XL_Gyro_4 */
1024, /* HD_Gyro_1 */
2048, /* HD_Gyro_2 */
3072, /* HD_Gyro_3 */
4096, /* HD_Gyro_4 */
1024, /* Compact_Gyro_1 */
2048, /* Compact_Gyro_2 */
3072, /* Compact_Gyro_3 */
4096, /* Compact_Gyro_4 */
51, /* XXL_Engine_20 */
102, /* XXL_Engine_40 */
153, /* XXL_Engine_60 */
204, /* XXL_Engine_80 */
255, /* XXL_Engine_100 */
306, /* XXL_Engine_120 */
357, /* XXL_Engine_140 */
408, /* XXL_Engine_160 */
459, /* XXL_Engine_180 */
510, /* XXL_Engine_200 */
561, /* XXL_Engine_220 */
612, /* XXL_Engine_240 */
763, /* XXL_Engine_260 */
814, /* XXL_Engine_280 */
865, /* XXL_Engine_300 */
916, /* XXL_Engine_320 */
967, /* XXL_Engine_340 */
1018, /* XXL_Engine_360 */
1070, /* XXL_Engine_380 */
1020, /* XXL_Engine_400 */
51, /* Compact_Engine_20 */
102, /* Compact_Engine_40 */
153, /* Compact_Engine_60 */
204, /* Compact_Engine_80 */
255, /* Compact_Engine_100 */
306, /* Compact_Engine_120 */
357, /* Compact_Engine_140 */
408, /* Compact_Engine_160 */
459, /* Compact_Engine_180 */
510, /* Compact_Engine_200 */
561, /* Compact_Engine_220 */
612, /* Compact_Engine_240 */
763, /* Compact_Engine_260 */
814, /* Compact_Engine_280 */
865, /* Compact_Engine_300 */
916, /* Compact_Engine_320 */
967, /* Compact_Engine_340 */
1018, /* Compact_Engine_360 */
1070, /* Compact_Engine_380 */
1020, /* Compact_Engine_400 */
#endif
};
#endif /* BT_PART_WEIGHTS */
#ifdef BT_ADVANCED_ECON
unsigned long long int specialcost[SPECIALCOST_SIZE] = { 0 };
unsigned long long int ammocost[AMMOCOST_SIZE] = { 0 };
unsigned long long int weapcost[WEAPCOST_SIZE] = { 0 };
unsigned long long int cargocost[CARGOCOST_SIZE] = { 0 };
unsigned long long int bombcost[BOMBCOST_SIZE] = { 0 };
#endif
int count_special_items()
{
int i = 0;
while (internals[i])
i++;
return i;
}
char *section_configs[] = {
"Case", "Destroyed",
NULL
};
char *move_types[] = {
"Biped", "Track", "Wheel", "Hover", "VTOL", "Hull", "Foil", "Fly",
"Quad",
"Sub", "None",
NULL
};
char *mech_types[] = {
"Mech", "Vehicle", "VTOL", "Naval", "Spheroid_DropShip", "AeroFighter",
"Mechwarrior", "Aerodyne_DropShip", "Battlesuit", NULL
};
char *crit_fire_modes[] = {
"Destroyed",
"Disabled",
"Broken",
"Damaged",
"OnTC",
"RearMount",
"Hotload",
"Halfton",
"OneShot",
"OneShot_Used",
"UltraMode",
"RapidFire",
"Gattling",
"Rotary_TwoShot",
"Rotary_FourShot",
"Rotary_SixShot",
"Heat",
"BackPack",
"Jettisoned",
"OmniBase",
NULL
};
char *crit_ammo_modes[] = {
"LBX/Cluster",
"Artemis/Mine",
"Narc/Smoke",
"Cluster",
"Mine",
"Smoke",
"Inferno",
"Swarm",
"Swarm1",
"iNarc_Explosive",
"iNarc_Haywire",
"iNarc_ECM",
"iNarc_Nemesis",
"AP",
"Flechette",
"Incendiary",
"Precision",
"Stinger",
NULL
};
/* 'specials' is *full* */
char *specials[] = {
"TripleMyomerTech",
"CL_AMS",
"IS_AMS",
"DoubleHS",
"Masc",
"Clan",
"FlipArms",
"C3MasterTech",
"C3SlaveTech",
"ArtemisIV",
"ECM",
"BeagleProbe",
"SalvageTech",
"CargoTech",
"SearchLight",
"LoaderTech",
"AntiAircraft",
"NoSensors",
"SS_Ability",
"FerroFibrous_Tech",
"EndoSteel_Tech",
"XLEngine_Tech",
"ICEEngine_Tech",
"LifterTech",
"LightEngine_Tech",
"XXL_Tech",
"CompactEngine_Tech",
"ReinforcedInternal_Tech",
"CompositeInternal_Tech",
"HardenedArmor_Tech",
"CritProof_Tech",
NULL
};
char *specialsabrev[] = {
"TSM", "CLAMS", "ISAMS", "DHS", "MASC", "CLTECH", "FA", "C3M", "C3S",
"AIV", "ECM", "BAP", "SAL", "CAR", "SL", "LOAD", "AA", "NOSEN", "SS",
"FF", "ES", "XL", "ICE", "LIFT", "LENG", "XXL", "CENG", "RINT", "CINT",
"HARM", "CP",
NULL
};
/* 'specials' is *full* */
char *specials2[] = {
"StealthArmor_Tech",
"HvyFerroFibrous_Tech",
"LaserRefArmor_Tech",
"ReactiveArmor_Tech",
"NullSigSys_Tech",
"C3I_Tech",
"SuperCharger_Tech",
"ImprovedJJ_Tech",
"MechanicalJJ_Tech",
"CompactHS",
"LaserHS_Tech",
"BloodhoundProbe_Tech",
"AngelECM_Tech",
"WatchDog_Tech",
"LtFerroFibrous_Tech",
"TAG_Tech",
"OmniMech_Tech",
"ArtemisV_Tech",
"Camo_Tech",
"Carrier_Tech",
"Waterproof_Tech",
"XLGyro_Tech",
"HDGyro_Tech",
"CompactGyro_Tech",
NULL
};
char *specialsabrev2[] = {
"STHA", "HFF", "LRARM", "REACTARM", "NULL", "C3I","SCHARGE",
"IJJ", "MJJ", "CHS", "LHS", "BLP", "AECM", "WDOG", "LFF",
"TAG", "OMNI", "AV",
"CAMO",
"CART",
"WPRF",
"XLGRYO", "HDGYRO", "CGYRO",
NULL
};
char *infantry_specials[] = {
"Swarm_Attack_Tech",
"Mount_Friends_Tech",
"AntiLeg_Attack_Tech",
"CS_Purifier_Stealth_Tech",
"DC_Kage_Stealth_Tech",
"FWL_Achileus_Stealth_Tech",
"FC_Infiltrator_Stealth_Tech",
"FC_InfiltratorII_Stealth_Tech",
"Must_Jettison_Pack_Tech",
"Can_Jettison_Pack_Tech",
NULL
};
int compare_array(char *list[], char *command)
{
int x;
if (!list)
return -1;
for (x = 0; list[x]; x++)
if (!strcasecmp(list[x], command))
return x;
return -1;
}
char *one_arg(char *argument, char *first_arg)
{
if (isspace(*argument))
for (argument++; isspace(*argument); argument++);
while (*argument && !isspace(*argument))
*(first_arg++) = *(argument++);
*first_arg = '\0';
return argument;
}
char *one_arg_delim(char *argument, char *first_arg)
{
if (isspace(*argument) || (*argument == '|'))
for (argument++; (isspace(*argument) || (*argument == '|'));
argument++);
while (*argument && (!(*argument == '|')))
*(first_arg++) = *(argument++);
*first_arg = '\0';
return argument;
}
char *BuildBitString(char *bitdescs[], int data)
{
static char crit[MAX_STRING_LENGTH];
int bv;
int x;
crit[0] = 0;
for (x = 0; bitdescs[x]; x++) {
bv = 1U << x;
if (data & bv) {
strcat(crit, bitdescs[x]);
strcat(crit, " ");
}
}
if ((x = strlen(crit)) > 0 && crit[x - 1] == ' ')
crit[x - 1] = '\0';
return crit;
}
char *BuildBitString2(char *bitdescs[], char *bitdescs2[], int data,
int data2)
{
static char crit[MAX_STRING_LENGTH];
int bv;
int x;
crit[0] = 0;
for (x = 0; bitdescs[x]; x++) {
bv = 1U << x;
if (data & bv) {
strcat(crit, bitdescs[x]);
strcat(crit, " ");
}
}
for (x = 0; bitdescs2[x]; x++) {
bv = 1U << x;
if (data2 & bv) {
strcat(crit, bitdescs2[x]);
strcat(crit, " ");
}
}
if ((x = strlen(crit)) > 0 && crit[x - 1] == ' ')
crit[x - 1] = '\0';
return crit;
}
char *BuildBitString3(char *bitdescs[], char *bitdescs2[],
char *bitdescs3[], int data, int data2, int data3)
{
static char crit[MAX_STRING_LENGTH];
int bv;
int x;
crit[0] = 0;
for (x = 0; bitdescs[x]; x++) {
bv = 1U << x;
if (data & bv) {
strcat(crit, bitdescs[x]);
strcat(crit, " ");
}
}
for (x = 0; bitdescs2[x]; x++) {
bv = 1U << x;
if (data2 & bv) {
strcat(crit, bitdescs2[x]);
strcat(crit, " ");
}
}
for (x = 0; bitdescs3[x]; x++) {
bv = 1U << x;
if (data3 & bv) {
strcat(crit, bitdescs3[x]);
strcat(crit, " ");
}
}
if ((x = strlen(crit)) > 0 && crit[x - 1] == ' ')
crit[x - 1] = '\0';
return crit;
}
#define QDM(a) case I2Special(a): return 1
static int InvalidVehicleItem(MECH * mech, int x, int y)
{
int t;
t = GetPartType(mech, x, y);
switch (t) {
QDM(SHOULDER_OR_HIP);
QDM(UPPER_ACTUATOR);
QDM(LOWER_ACTUATOR);
QDM(HAND_OR_FOOT_ACTUATOR);
QDM(ENGINE);
QDM(GYRO);
QDM(JUMP_JET);
}
return 0;
}
extern int num_def_weapons;
int internal_count = sizeof(internals) / sizeof(char *) - 1;
int cargo_count = sizeof(cargo) / sizeof(char *) - 1;
#ifndef CLAN_SUPPORT
#define CLCH(a) do { if (MechWeapons[a].special & (CLAT)) return NULL; } while (0)
#else
#define CLCH(a) \
do { if (temp_brand_flag) { if ((!mudconf.btech_parts) || (MechWeapons[a].special & CLAT)) return NULL; else if (MechWeapons[a].special & CLAT) isclan=1; }} while (0)
#endif
extern int temp_brand_flag;
static char *part_figure_out_name_sub(int i, int j)
{
static char buf[MBUF_SIZE];
int isclan = 0;
if (!i)
return NULL;
if (IsWeapon(i) && i < I2Weapon(num_def_weapons)) {
CLCH(Weapon2I(i));
return &MechWeapons[Weapon2I(i)].name[(j && !isclan) ? 3 : 0];
} else if (IsAmmo(i) && i < I2Ammo(num_def_weapons)) {
CLCH(Ammo2WeaponI(i));
if (MechWeapons[Ammo2WeaponI(i)].type != TBEAM &&
MechWeapons[Ammo2WeaponI(i)].type != THAND &&
!(MechWeapons[Ammo2WeaponI(i)].special & PCOMBAT)) {
sprintf(buf, "Ammo_%s", &MechWeapons[Ammo2WeaponI(i)].name[(j
&& !isclan) ? 3 : 0]);
return buf;
}
} else if (!temp_brand_flag) {
if (IsBomb(i)) {
sprintf(buf, "Bomb_%s", bomb_name(Bomb2I(i)));
return buf;
} else if (IsSpecial(i) && i < I2Special(internal_count))
return internals[Special2I(i)];
else if (IsCargo(i) && i < I2Cargo(cargo_count))
return cargo[Cargo2I(i)];
}
return NULL;
}
char *my_shortform(char *buf)
{
static char buf2[MBUF_SIZE];
char *c, *d;
if (!buf)
return NULL;
if (strlen(buf) <= 4 && !strchr(buf, '/'))
strcpy(buf2, buf);
else {
for (c = buf, d = buf2; *c; c++)
if (isdigit(*c) || isupper(*c) || *c == '_')
*d++ = *c;
*d = 0;
if (strlen(buf2) == 1)
strcat(d, tprintf("%c", buf[1]));
}
return buf2;
}
#undef CLCH
#ifdef CLAN_SUPPORT
#define CLCH(a) ((!strncasecmp(MechWeapons[a].name, "CL.", 2)) ? 0 : 3)
#else
#define CLCH(a) 3
#endif
char *part_figure_out_shname(int i)
{
char buf[MBUF_SIZE];
if (!i)
return NULL;
buf[0] = 0;
if (IsWeapon(i) && i < I2Weapon(num_def_weapons)) {
strcpy(buf, &MechWeapons[Weapon2I(i)].name[CLCH(Weapon2I(i))]);
} else if (IsAmmo(i) && i < I2Ammo(num_def_weapons)) {
sprintf(buf, "Ammo_%s",
&MechWeapons[Ammo2WeaponI(i)].name[CLCH(Ammo2WeaponI(i))]);
} else if (IsBomb(i))
sprintf(buf, "Bomb_%s", bomb_name(Bomb2I(i)));
else if (IsSpecial(i) && i < I2Special(internal_count))
strcpy(buf, internals[Special2I(i)]);
if (IsCargo(i) && i < I2Cargo(cargo_count))
strcpy(buf, cargo[Cargo2I(i)]);
if (!buf[0])
return NULL;
return my_shortform(buf);
}
char *part_figure_out_name(int i)
{
return part_figure_out_name_sub(i, 0);
}
char *part_figure_out_sname(int i)
{
return part_figure_out_name_sub(i, 1);
}
#define TCAble(t) \
((MechWeapons[Weapon2I(t)].type == TBEAM || MechWeapons[Weapon2I(t)].type == TAMMO) && \
strcmp(&MechWeapons[Weapon2I(t)].name[3], "Flamer") && \
strcmp(&MechWeapons[Weapon2I(t)].name[3], "MachineGun") && \
strcmp(&MechWeapons[Weapon2I(t)].name[3], "HeavyMachineGun") && \
!(MechWeapons[Weapon2I(t)].special & PCOMBAT))
static int dump_item(FILE * fp, MECH * mech, int x, int y)
{
char crit[32];
int y1;
int flaggo = 0;
int z;
int wFireModes, wAmmoModes;
if (!GetPartType(mech, x, y))
return 1;
if (MechType(mech) != CLASS_MECH && InvalidVehicleItem(mech, x, y))
return 1;
for (y1 = y + 1; y1 < 12; y1++) {
if (GetPartType(mech, x, y1) != GetPartType(mech, x, y))
break;
if (GetPartData(mech, x, y1) != GetPartData(mech, x, y))
break;
if (GetPartFireMode(mech, x, y1) != GetPartFireMode(mech, x, y))
break;
if (GetPartAmmoMode(mech, x, y1) != GetPartAmmoMode(mech, x, y))
break;
if (mudconf.btech_parts)
if (GetPartBrand(mech, x, y1) != GetPartBrand(mech, x, y))
break;
}
y1--;
if (IsWeapon(GetPartType(mech, x, y))) {
/* Nonbeams, or flamers don't have TC */
if (!TCAble(GetPartType(mech, x, y)))
flaggo = ON_TC;
if (((y1 - y) + 1) > (z =
GetWeaponCrits(mech, Weapon2I(GetPartType(mech, x, y)))))
y1 = y + z - 1;
}
if (y != y1)
snprintf(crit, 32, "CRIT_%d-%d", y + 1, y1 + 1);
else
snprintf(crit, 32, "CRIT_%d", y + 1);
wFireModes = GetPartFireMode(mech, x, y);
wFireModes &= ~flaggo;
wAmmoModes = GetPartAmmoMode(mech, x, y);
if (IsWeapon(GetPartType(mech, x, y)))
fprintf(fp, " %s { %s - %s %s}\n", crit,
get_parts_vlong_name(GetPartType(mech, x, y), 0),
(wFireModes ||
wAmmoModes) ? BuildBitString2(crit_fire_modes,
crit_ammo_modes, wFireModes, wAmmoModes) : "-",
!mudconf.btech_parts ? "" : tprintf("%d ",
GetPartBrand(mech, x, y)));
else if (IsAmmo(MechSections(mech)[x].criticals[y].type))
fprintf(fp, " %s { %s %d %s - }\n", crit,
get_parts_vlong_name(GetPartType(mech, x, y), 0),
FullAmmo(mech, x, y),
(MechSections(mech)[x].criticals[y].firemode ||
MechSections(mech)[x].criticals[y].
ammomode) ? BuildBitString2(crit_fire_modes,
crit_ammo_modes,
MechSections(mech)[x].criticals[y].firemode,
MechSections(mech)[x].criticals[y].ammomode) : "-");
else if (IsBomb(MechSections(mech)[x].criticals[y].type))
fprintf(fp, " %s { %s - - - }\n", crit,
get_parts_vlong_name(GetPartType(mech, x, y), 0));
else {
fprintf(fp, " %s { %s - - %s}\n", crit,
get_parts_vlong_name(GetPartType(mech, x, y), 0),
!mudconf.btech_parts ? "" : tprintf("%d ",
GetPartBrand(mech, x, y)));
}
return (y1 - y + 1);
}
void dump_locations(FILE * fp, MECH * mech, const char *locdesc[])
{
int x, y, l;
char buf[512];
char *ch;
for (x = 0; locdesc[x]; x++) {
if (!GetSectOInt(mech, x))
continue;
strcpy(buf, locdesc[x]);
for (ch = buf; *ch; ch++)
if (*ch == ' ')
*ch = '_';
fprintf(fp, "%s\n", buf);
if (GetSectOArmor(mech, x))
fprintf(fp, " Armor { %d }\n", GetSectOArmor(mech,
x));
if (GetSectOInt(mech, x))
fprintf(fp, " Internals { %d }\n", GetSectOInt(mech,
x));
if (GetSectORArmor(mech, x))
fprintf(fp, " Rear { %d }\n", GetSectORArmor(mech,
x));
#if 0 /* Shouldn't be neccessary to save at all */
fprintf(fp, " Recycle { %d }\n",
MechSections(mech)[x].recycle);
#endif
y = MechSections(mech)[x].config;
y &= ~CASE_TECH;
if (y)
fprintf(fp, " Config { %s }\n",
BuildBitString(section_configs, y));
l = CritsInLoc(mech, x);
for (y = 0; y < l;)
y += dump_item(fp, mech, x, y);
}
}
float generic_computer_multiplier(MECH * mech)
{
switch (MechComputer(mech)) {
case 1:
return 0.8;
case 2:
return 1;
case 3:
return 1.25;
case 4:
return 1.5;
case 5:
return 1.75;
}
return 0;
}
int generic_radio_type(int i, int isClan)
{
int f = DEFAULT_FREQS;
if (isClan || i >= 4)
f += FREQS * RADIO_RELAY;
if (i < 3)
f -= (3 - i) * 2 - 1; /* 2 or 4 */
else
f += (i - 3) * 3; /* 5 / 8 / 11 */
return f;
}
float generic_radio_multiplier(MECH * mech)
{
switch (MechRadio(mech)) {
case 1:
return 0.8;
case 2:
return 1;
case 3:
return 1.25;
case 4:
return 1.5;
case 5:
return 1.75;
}
return 0.0;
}
#define MechComputersScanRange(mech) \
(generic_computer_multiplier(mech) * DEFAULT_SCANRANGE)
#define MechComputersLRSRange(mech) \
(generic_computer_multiplier(mech) * DEFAULT_LRSRANGE)
#define MechComputersTacRange(mech) \
(generic_computer_multiplier(mech) * DEFAULT_TACRANGE)
#define MechComputersRadioRange(mech) \
(DEFAULT_RADIORANGE * generic_radio_multiplier(mech))
void computer_conversion(MECH * mech)
{
int l = 0;
switch (MechScanRange(mech)) {
case 20:
l = 2;
break;
case 25:
l = 3;
break;
case 30:
l = 4;
break;
}
if (l) {
MechComputer(mech) = l;
MechScanRange(mech) = MechComputersScanRange(mech);
MechTacRange(mech) = MechComputersTacRange(mech);
MechLRSRange(mech) = MechComputersLRSRange(mech);
MechRadioRange(mech) = MechComputersRadioRange(mech);
}
}
void try_to_find_name(char *mechref, MECH * mech)
{
const char *c;
if ((c = find_mechname_by_mechref(mechref)))
strcpy(MechType_Name(mech), c);
}
int DefaultFuelByType(MECH * mech)
{
int mod = 2;
switch (MechType(mech)) {
case CLASS_VTOL:
return 2000 * mod;
case CLASS_AERO:
return 1200 * mod;
case CLASS_DS:
case CLASS_SPHEROID_DS:
return 3600 * mod;
}
return 0;
}
int save_template(dbref player, MECH * mech, char *reference,
char *filename)
{
FILE *fp;
int x, x2, inf_x;
const char **locs;
char *d, *c = ctime(&mudstate.now);
if (!MechComputer(mech))
computer_conversion(mech);
if (!MechType_Name(mech)[0])
try_to_find_name(reference, mech);
if (!(fp = fopen(filename, "w")))
return -1;
if (MechType_Name(mech)[0])
fprintf(fp, "Name { %s }\n", MechType_Name(mech));
fprintf(fp, "Reference { %s }\n", reference);
fprintf(fp, "Type { %s }\n",
mech_types[(short) MechType(mech)]);
fprintf(fp, "Move_Type { %s }\n",
move_types[(short) MechMove(mech)]);
fprintf(fp, "Tons { %d }\n", MechTons(mech));
if ((d = strrchr(c, '\n')))
*d = 0;
fprintf(fp, "Comment { Saved by: %s(#%d) at %s }\n",
Name(player), player, c);
#define SILLY_UTTERANCE(ran,cran,dran,name) \
if ((!MechComputer(mech) && ran != dran) || \
(MechComputer(mech) && ran != cran)) \
fprintf(fp, "%-16s { %d }\n", name, ran)
SILLY_UTTERANCE(MechTacRange(mech), MechComputersTacRange(mech),
DEFAULT_TACRANGE, "Tac_Range");
SILLY_UTTERANCE(MechLRSRange(mech), MechComputersLRSRange(mech),
DEFAULT_LRSRANGE, "LRS_Range");
SILLY_UTTERANCE(MechScanRange(mech), MechComputersScanRange(mech),
DEFAULT_SCANRANGE, "Scan_Range");
SILLY_UTTERANCE(MechRadioRange(mech), MechComputersRadioRange(mech),
DEFAULT_RADIORANGE, "Radio_Range");
#define SILLY_OUTPUT(def,now,name) \
if ((def) != (now)) \
fprintf(fp, "%-16s { %d }\n", name, now)
SILLY_OUTPUT(DEFAULT_COMPUTER, MechComputer(mech), "Computer");
SILLY_OUTPUT(DEFAULT_RADIO, MechRadio(mech), "Radio");
SILLY_OUTPUT((MechSpecials(mech) & ICE_TECH) ? 0 : DEFAULT_HEATSINKS,
MechRealNumsinks(mech), "Heat_Sinks");
SILLY_OUTPUT(generic_radio_type(MechRadio(mech),
MechSpecials(mech) & CLAN_TECH), MechRadioType(mech),
"RadioType");
SILLY_OUTPUT(2000, MechBV(mech), "Mech_BV");
SILLY_OUTPUT(2000, CargoSpace(mech), "Cargo_Space");
SILLY_OUTPUT(0, CarMaxTon(mech), "Max_Ton");
SILLY_OUTPUT(2000, MechMaxSuits(mech), "Max_Suits");
SILLY_OUTPUT(0, AeroSIOrig(mech), "SI");
SILLY_OUTPUT(DefaultFuelByType(mech), AeroFuelOrig(mech), "Fuel");
fprintf(fp, "Max_Speed { %.2f }\n", MechMaxSpeed(mech));
if (MechJumpSpeed(mech) > 0.0)
fprintf(fp, "Jump_Speed { %.2f }\n", MechJumpSpeed(mech));
x = MechSpecials(mech);
x2 = MechSpecials2(mech);
/* Remove AMS'es, they're re-generated back on loadtime */
x &= ~(CL_ANTI_MISSILE_TECH | IS_ANTI_MISSILE_TECH | SS_ABILITY);
x &= /* Calculated at load-time */
~(BEAGLE_PROBE_TECH | TRIPLE_MYOMER_TECH | MASC_TECH | ECM_TECH |
C3_SLAVE_TECH | C3_MASTER_TECH | ARTEMIS_IV_TECH | ES_TECH |
FF_TECH);
if (MechType(mech) == CLASS_MECH)
x &= ~(XL_TECH | XXL_TECH | CE_TECH | LE_TECH);
/* Get rid of our specials2 */
x2 &=
~(STEALTH_ARMOR_TECH | NULLSIGSYS_TECH | ANGEL_ECM_TECH |
HVY_FF_ARMOR_TECH | LT_FF_ARMOR_TECH | TAG_TECH | C3I_TECH |
BLOODHOUND_PROBE_TECH);
if (x || x2)
fprintf(fp, "Specials { %s }\n", BuildBitString2(specials,
specials2, x, x2));
inf_x = MechInfantrySpecials(mech);
if (inf_x)
fprintf(fp, "InfantrySpecials { %s }\n",
BuildBitString(infantry_specials, inf_x));
if ((locs =
ProperSectionStringFromType(MechType(mech), MechMove(mech)))) {
dump_locations(fp, mech, locs);
fclose(fp);
return 0;
}
fclose(fp);
return -1;
}
char *read_desc(FILE * fp, char *data)
{
char keep[MAX_STRING_LENGTH + 500];
char *t, *tmp;
char *point;
int length = 0;
static char buf[MAX_STRING_LENGTH];
keep[0] = '\0';
if ((tmp = strchr(data, '{'))) {
fscanf(fp, "\n");
while (isspace(*(++tmp)));
if ((t = strchr(tmp, '}'))) {
while (isspace(*(t--)));
*(t++) = '\0';
length = strlen(tmp);
strcpy(buf, tmp);
return buf;
} else {
strcpy(keep, tmp);
strcat(keep, "\r\n");
t = tmp + strlen(tmp) - 1;
length = strlen(t);
while (fgets(data, 512, fp)) {
fscanf(fp, "\n");
if ((tmp = strchr(data, '}')) != NULL) {
*tmp = 0;
length += strlen(data);
strcat(keep, data);
break;
} else {
point = data + strlen(data) - 1;
*(point++) = '\r';
*(point++) = '\n';
*point = '\0';
strcat(keep, data);
length += strlen(data);
}
}
}
}
strcpy(buf, keep);
return buf;
}
int find_section(char *cmd, int type, int mtype)
{
char section[20];
char *ch;
const char **locs;
strcpy(section, cmd);
for (ch = section; *ch; ch++)
if (*ch == '_')
*ch = ' ';
locs = ProperSectionStringFromType(type, mtype);
return compare_array((char **) locs, section);
return -1;
}
long BuildBitVector(char **list, char *line)
{
long bv = 0;
int temp;
char buf[30];
if (!strcasecmp(line, "-"))
return 0;
while (*line) {
line = one_arg(line, buf);
if ((temp = compare_array(list, buf)) == -1)
return -1;
bv |= 1U << temp;
}
return bv;
}
long BuildBitVectorWithDelim(char **list, char *line)
{
long bv = 0;
int temp;
char buf[30];
if (!strcasecmp(line, "-"))
return 0;
while (*line) {
line = one_arg_delim(line, buf);
if ((temp = compare_array(list, buf)) == -1)
return -1;
bv |= 1U << temp;
}
return bv;
}
long BuildBitVectorNoErr(char **list, char *line)
{
long bv = 0;
int temp;
char buf[30];
if (!strcasecmp(line, "-"))
return 0;
while (*line) {
line = one_arg(line, buf);
if ((temp = compare_array(list, buf)) != -1)
bv |= 1U << temp;
}
return bv;
}
int CheckSpecialsList(char **specials, char **specials2, char *line)
{
int wSpecCheck = -1, wSpec2Check = -1;
char buf[30];
if (!strcasecmp(line, "-"))
return 0;
while (*line) {
line = one_arg(line, buf);
if (specials)
wSpecCheck = compare_array(specials, buf);
if (specials2)
wSpec2Check = compare_array(specials2, buf);
if ((wSpecCheck == -1) && (wSpec2Check == -1))
return 0;
}
return 1;
}
int WeaponIFromString(char *data)
{
int x = 0;;
while (MechWeapons[x].name) {
if (!strcasecmp(MechWeapons[x].name, data))
return x + 1; /* weapons start at 1 not 0 */
x++;
}
return -1;
}
int AmmoIFromString(char *data)
{
int x = 0;
char *ptr;
ptr = data;
while (*ptr != '_')
ptr++;
ptr++;
while (MechWeapons[x].name) {
if (!strcasecmp(MechWeapons[x].name, ptr))
return x + 101;
x++;
}
return -1;
}
void update_specials(MECH * mech)
{
int x, y, t;
int masc_count = 0;
int c3_master_count = 0;
int tsm_count = 0;
int ff_count = 0;
int es_count = 0;
int tc_count = 0;
int awcSthArmor[NUM_SECTIONS];
int awcNSS[NUM_SECTIONS];
int wcSthArmor = 0;
int wcNSS = 0;
int wcAngel = 0;
int cl = MechSpecials(mech) & CLAN_TECH;
int e_count = 0;
int tTechOK = 1;
int wcHvyFF = 0;
int wcLtFF = 0;
int wcC3i = 0;
int wcBloodhound = 0;
int awInfSpec[5];
int wcSuits = 0;
MechSpecials(mech) &=
~(BEAGLE_PROBE_TECH | TRIPLE_MYOMER_TECH | MASC_TECH | ECM_TECH |
C3_SLAVE_TECH | C3_MASTER_TECH | ARTEMIS_IV_TECH | ES_TECH |
FF_TECH | IS_ANTI_MISSILE_TECH | CL_ANTI_MISSILE_TECH);
if (MechType(mech) == CLASS_MECH)
MechSpecials(mech) &= ~(XL_TECH | XXL_TECH | CE_TECH | LE_TECH);
MechSpecials2(mech) &=
~(STEALTH_ARMOR_TECH | NULLSIGSYS_TECH | ANGEL_ECM_TECH |
HVY_FF_ARMOR_TECH | LT_FF_ARMOR_TECH | TAG_TECH | C3I_TECH |
BLOODHOUND_PROBE_TECH);
MechInfantrySpecials(mech) &=
~(CS_PURIFIER_STEALTH_TECH | DC_KAGE_STEALTH_TECH |
FWL_ACHILEUS_STEALTH_TECH | FC_INFILTRATOR_STEALTH_TECH |
FC_INFILTRATORII_STEALTH_TECH);
for (x = 0; x < 5; x++)
awInfSpec[x] = 0;
for (x = 0; x < NUM_SECTIONS; x++) {
e_count = 0;
MechSections(mech)[x].config &= ~CASE_TECH;
awcSthArmor[x] = 0;
awcNSS[x] = 0;
for (y = 0; y < CritsInLoc(mech, x); y++)
if ((t = GetPartType(mech, x, y))) {
switch (Special2I(t)) {
#define TECHC(item,name) case item: name++; break;
#define TECHCU(item,name) \
case item: if (!PartIsNonfunctional(mech, x, y)) name++; break;
#define TECH(item,name) case item: MechSpecials(mech) |= name; break
#define TECH2(item,name) case item: MechSpecials2(mech) |= name; break
#define TECHU(item, name) \
case item: if (!PartIsNonfunctional(mech, x, y)) MechSpecials(mech) |= name ; break
TECH(ARTEMIS_IV, ARTEMIS_IV_TECH);
TECHU(BEAGLE_PROBE, BEAGLE_PROBE_TECH);
TECH(ECM, ECM_TECH);
TECH2(TAG, TAG_TECH);
TECHU(C3_SLAVE, C3_SLAVE_TECH);
TECHCU(MASC, masc_count);
TECHC(C3_MASTER, c3_master_count);
TECHCU(C3I, wcC3i);
TECHCU(ANGELECM, wcAngel);
TECHC(TRIPLE_STRENGTH_MYOMER, tsm_count);
TECHC(FERRO_FIBROUS, ff_count);
TECHC(HVY_FERRO_FIBROUS, wcHvyFF);
TECHC(LT_FERRO_FIBROUS, wcLtFF);
TECHC(BLOODHOUND_PROBE, wcBloodhound);
TECHCU(TARGETING_COMPUTER, tc_count);
TECHC(ENDO_STEEL, es_count);
TECHC(PURIFIER_ARMOR, awInfSpec[0]);
TECHCU(KAGE_STEALTH_UNIT, awInfSpec[1]);
TECHCU(ACHILEUS_STEALTH_UNIT, awInfSpec[2]);
TECHCU(INFILTRATOR_STEALTH_UNIT, awInfSpec[3]);
TECHCU(INFILTRATORII_STEALTH_UNIT, awInfSpec[4]);
case ENGINE:
e_count++;
break;
case CASE:
MechSections(mech)[(MechType(mech) == CLASS_VEH_GROUND)
? BSIDE : x].config |= CASE_TECH;
break;
case STEALTH_ARMOR:
awcSthArmor[x]++;
wcSthArmor++;
break;
case NULL_SIGNATURE_SYSTEM:
awcNSS[x]++;
wcNSS++;
break;
}
if (IsWeapon(t) && IsAMS(Weapon2I(t))) {
if (MechWeapons[Weapon2I(t)].special & CLAT)
MechSpecials(mech) |= CL_ANTI_MISSILE_TECH;
else
MechSpecials(mech) |= IS_ANTI_MISSILE_TECH;
}
}
if (x != CTORSO && e_count) {
if (e_count > 3)
MechSpecials(mech) |= XXL_TECH;
else if (e_count == 2)
if (cl)
MechSpecials(mech) |= XL_TECH;
else
MechSpecials(mech) |= LE_TECH;
else
MechSpecials(mech) |= XL_TECH;
} else {
if (x == CTORSO && e_count < 4 && MechType(mech) == CLASS_MECH)
MechSpecials(mech) |= CE_TECH;
}
}
if ((MechSpecials(mech) & (XXL_TECH | XL_TECH | LE_TECH)) &&
(MechSpecials(mech) & CE_TECH))
SendError(tprintf
("#%d apparently is very weird: Compact engine AND XL/XXL?",
mech->mynum));
if (tc_count)
for (x = 0; x < NUM_SECTIONS; x++)
for (y = 0; y < CritsInLoc(mech, x); y++)
if (IsWeapon((t = GetPartType(mech, x, y))))
if (TCAble(t))
GetPartFireMode(mech, x, y) |= ON_TC;
if (masc_count >= MAX(1, (MechTons(mech) / (cl ? 25 : 20))))
MechSpecials(mech) |= MASC_TECH;
#define ITech(var,cnt,spec) \
if (((var)) >= ((cnt)) || (MechType(mech) != CLASS_MECH && ((var)>0))) \
MechSpecials(mech) |= spec
#define ITech2(var,cnt,spec) \
if (((var)) >= ((cnt)) || (MechType(mech) != CLASS_MECH && ((var)>0))) \
MechSpecials2(mech) |= spec
ITech(ff_count, (cl ? 7 : 14), FF_TECH);
ITech(es_count, (cl ? 7 : 14), ES_TECH);
ITech(tsm_count, 6, TRIPLE_MYOMER_TECH);
ITech2(wcAngel, 2, ANGEL_ECM_TECH);
ITech2(wcHvyFF, 21, HVY_FF_ARMOR_TECH);
ITech2(wcLtFF, 7, LT_FF_ARMOR_TECH);
ITech2(wcC3i, 2, C3I_TECH);
ITech2(wcBloodhound, 2, BLOODHOUND_PROBE_TECH);
/*
* Check our NSS. Need 1 crit in each loc except H
*/
tTechOK = 0;
if (wcNSS > 0) {
tTechOK = 1;
if (MechType(mech) != CLASS_MECH) {
if (wcNSS < 1)
tTechOK = 0;
} else {
for (x = 0; x < NUM_SECTIONS; x++) {
if (x != HEAD) {
if (awcNSS[x] < 1) {
tTechOK = 0;
break;
}
}
}
}
if (tTechOK)
MechSpecials2(mech) |= NULLSIGSYS_TECH;
}
/*
* Check our Stealth armor. Need 2 crits in each loc except H and CT
*/
tTechOK = 0;
if (wcSthArmor > 0) {
tTechOK = 1;
if (!(MechSpecials(mech) & ECM_TECH)) {
tTechOK = 0;
} else {
if (MechType(mech) != CLASS_MECH) {
if (wcSthArmor < 1)
tTechOK = 0;
} else {
for (x = 0; x < NUM_SECTIONS; x++) {
if ((x != HEAD) && (x != CTORSO)) {
if (awcSthArmor[x] < 2) {
tTechOK = 0;
break;
}
}
}
}
}
if (tTechOK)
MechSpecials2(mech) |= STEALTH_ARMOR_TECH;
}
/* Let's do our suit checks */
if (MechType(mech) == CLASS_BSUIT) {
wcSuits = CountBSuitMembers(mech);
if (awInfSpec[0] >= wcSuits)
MechInfantrySpecials(mech) |= CS_PURIFIER_STEALTH_TECH;
if (awInfSpec[1] >= wcSuits)
MechInfantrySpecials(mech) |= DC_KAGE_STEALTH_TECH;
if (awInfSpec[2] >= wcSuits)
MechInfantrySpecials(mech) |= FWL_ACHILEUS_STEALTH_TECH;
if (awInfSpec[3] >= wcSuits)
MechInfantrySpecials(mech) |= FC_INFILTRATOR_STEALTH_TECH;
if (awInfSpec[4] >= wcSuits)
MechInfantrySpecials(mech) |= FC_INFILTRATORII_STEALTH_TECH;
}
/* New C3 Master code */
if (c3_master_count > 0) {
MechTotalC3Masters(mech) = countTotalC3MastersOnMech(mech);
MechWorkingC3Masters(mech) = countWorkingC3MastersOnMech(mech);
if (MechTotalC3Masters(mech) > 0)
MechSpecials(mech) |= C3_MASTER_TECH;
if (MechWorkingC3Masters(mech) == 0)
MechCritStatus(mech) |= C3_DESTROYED;
else
MechCritStatus(mech) &= ~C3_DESTROYED;
}
}
int update_oweight(MECH * mech, int value)
{
MechCritStatus(mech) |= OWEIGHT_OK;
/* Check to prevent silliness */
if (!mudconf.btech_dynspeed || (value == 1 && !Destroyed(mech)))
value = MechTons(mech) * 1024;
MechRTonsV(mech) = value;
return value;
}
int get_weight(MECH * mech)
{
if (MechCritStatus(mech) & OWEIGHT_OK)
return MechRTonsV(mech);
return update_oweight(mech, mech_weight_sub(GOD, mech, -1));
}
int load_template(dbref player, MECH * mech, char *filename)
{
char line[MAX_STRING_LENGTH], buf[MAX_STRING_LENGTH];
int x, y, value, i;
char cmd[MAX_STRING_LENGTH];
char *ptr, *j, *k, *line2;
int section = 0, critical, selection, type, brand;
FILE *fp = fopen(filename, "r");
char *tmpc;
int lpos, hpos;
int ok_count = 0;
int isClan = 0;
int t;
int wFireModes, wAmmoModes;
MAP *map;
if (!fp)
return -1;
ptr = strrchr(filename, '/');
if (ptr == NULL) {
ptr = filename;
} else {
ptr++;
}
strncpy(MechType_Ref(mech), ptr, 15);
MechType_Ref(mech)[14] = '\0';
silly_atr_set(mech->mynum, A_MECHREF, MechType_Ref(mech));
MechRadioType(mech) = 0;
while (fgets(line, 512, fp)) {
line[strlen(line) - 1] = '\0';
j = line;
while (isspace(*j))
j++;
if (j != line)
memmove(line, j, strlen(j) + 1);
if ((ptr = strchr(line, ' '))) {
if ((tmpc = strchr(line, '\t')) < ptr)
if (tmpc)
ptr = tmpc;
j = line;
k = cmd;
while (j != ptr)
*(k++) = *(j++);
*k = 0;
for (ptr++; isspace(*ptr); ptr++);
} else {
strcpy(cmd, line);
strcpy(line, "");
ptr = NULL;
}
if (!strncasecmp(cmd, "CRIT_", 5))
selection = 9999;
else if ((selection = compare_array(load_cmds, cmd)) == -1) {
/* Initial premise: we will have a mech type before we get to this */
section = find_section(cmd, MechType(mech), MechMove(mech));
TEMPLATE_ERR(section == -1 &&
!ok_count,
"New template loading system: %s is invalid template file.",
filename);
TEMPLATE_GERR(section == -1,
"Error while loading: Section %s not found.", cmd);
MechSections(mech)[section].recycle = 0;
ok_count++;
continue;
}
ok_count++;
switch (selection) {
case 0: /* Reference */
tmpc = read_desc(fp, ptr);
if (strcmp(tmpc, MechType_Ref(mech))) {
SendError(tprintf
("Template %s has Reference <-> Filename mismatch : %s <-> %s - It is automatically fixed by saving again.",
filename, tmpc, MechType_Ref(mech)));
tmpc = MechType_Ref(mech);
}
silly_atr_set(mech->mynum, A_MECHREF, tmpc);
strcpy(MechType_Ref(mech), tmpc);
break;
case 1: /* Type */
tmpc = read_desc(fp, ptr);
MechType(mech) = compare_array(mech_types, tmpc);
TEMPLATE_GERR(MechType(mech) == -1,
"Error while loading: Type %s not found.", tmpc);
AeroFuel(mech) = AeroFuelOrig(mech) = DefaultFuelByType(mech);
break;
case 2: /* Movement Type */
tmpc = read_desc(fp, ptr);
MechMove(mech) = compare_array(move_types, tmpc);
TEMPLATE_GERR(MechMove(mech) == -1,
"Error while loading: Type %s not found.", tmpc);
break;
case 3: /* Tons */
MechTons(mech) = atoi(read_desc(fp, ptr));
break;
case 4: /* Tac_Range */
MechTacRange(mech) = atoi(read_desc(fp, ptr));
break;
case 5: /* LRS_Range */
MechLRSRange(mech) = atoi(read_desc(fp, ptr));
break;
case 6: /* Radio Range */
MechRadioRange(mech) = atoi(read_desc(fp, ptr));
break;
case 7: /* Scan Range */
MechScanRange(mech) = atoi(read_desc(fp, ptr));
break;
case 8: /* Heat Sinks */
MechRealNumsinks(mech) = atoi(read_desc(fp, ptr));
break;
case 9: /* Max Speed */
SetMaxSpeed(mech, atof(read_desc(fp, ptr)));
break;
case 10: /* Specials */
tmpc = read_desc(fp, ptr);
if (CheckSpecialsList(specials, specials2, tmpc)) {
MechSpecials(mech) |= BuildBitVectorNoErr(specials, tmpc);
MechSpecials2(mech) |=
BuildBitVectorNoErr(specials2, tmpc);
} else
TEMPLATE_GERR(MechSpecials(mech) == -1,
"Error while loading: Invalid specials - %s.", tmpc);
break;
case 11: /* Armor */
SetSectOArmor(mech, section, atoi(read_desc(fp, ptr)));
SetSectArmor(mech, section, GetSectOArmor(mech, section));
break;
case 12: /* Internals */
SetSectOInt(mech, section, atoi(read_desc(fp, ptr)));
SetSectInt(mech, section, GetSectOInt(mech, section));
break;
case 13: /* Rear */
SetSectORArmor(mech, section, atoi(read_desc(fp, ptr)));
SetSectRArmor(mech, section, GetSectORArmor(mech, section));
break;
case 14: /* Config */
tmpc = read_desc(fp, ptr);
MechSections(mech)[section].config =
BuildBitVector(section_configs,
tmpc) & ~(CASE_TECH | SECTION_DESTROYED);
TEMPLATE_GERR(MechSections(mech)[section].config == -1,
"Error while loading: Invalid location config: %s.", tmpc);
break;
case 9999:
if ((sscanf(cmd, "CRIT_%d-%d", &x, &y)) == 2) {
lpos = x - 1;
hpos = y - 1;
} else if ((sscanf(cmd, "CRIT_%d", &x)) == 1) {
lpos = x - 1;
hpos = x - 1;
} else
break;
critical = lpos;
line2 = read_desc(fp, ptr);
line2 = one_arg(line2, buf);
if (!strncasecmp(buf, "CL.", 3))
isClan = 1;
TEMPLATE_GERR(!(find_matching_vlong_part(buf, NULL, &type,
&brand)), "Unable to find %s", buf);
SetPartType(mech, section, critical, type);
if (!mudconf.btech_parts)
brand = 0;
SetPartBrand(mech, section, critical, brand);
SetPartDesiredAmmoLoc(mech, section, critical, -1);
if (IsWeapon(type)) {
/* Thanks to legacy of past, we _do_ have to do this.. sniff */
if (IsAMS(Weapon2I(type))) {
if (MechWeapons[Weapon2I(type)].special & CLAT)
MechSpecials(mech) |= CL_ANTI_MISSILE_TECH;
else
MechSpecials(mech) |= IS_ANTI_MISSILE_TECH;
}
SetPartData(mech, section, critical, 0);
line2 = one_arg(line2, buf); /* Don't need the '-' */
line2 = one_arg(line2, buf);
/* wFireModes = BuildBitVector(crit_fire_modes, buf); */
/* wAmmoModes = BuildBitVector(crit_ammo_modes, buf); */
wFireModes = BuildBitVectorWithDelim(crit_fire_modes, buf);
wAmmoModes = BuildBitVectorWithDelim(crit_ammo_modes, buf);
TEMPLATE_GERR(((wFireModes < 0) && (wAmmoModes < 0)),
"Error while loading: Invalid crit modes for weapon: %s.",
buf);
if (wFireModes < 0)
wFireModes = 0;
if (wAmmoModes < 0)
wAmmoModes = 0;
GetPartFireMode(mech, section, critical) = wFireModes;
GetPartAmmoMode(mech, section, critical) = wAmmoModes;
line2 = one_arg(line2, buf);
if (mudconf.btech_parts)
if (atoi(buf)) {
SetPartBrand(mech, section, critical, atoi(buf));
}
} else if (IsAmmo(type)) {
line2 = one_arg(line2, buf);
GetPartData(mech, section, critical) = atoi(buf);
line2 = one_arg(line2, buf);
/* wFireModes = BuildBitVector(crit_fire_modes, buf); */
/* wAmmoModes = BuildBitVector(crit_ammo_modes, buf); */
wFireModes = BuildBitVectorWithDelim(crit_fire_modes, buf);
wAmmoModes = BuildBitVectorWithDelim(crit_ammo_modes, buf);
TEMPLATE_GERR(((wFireModes < 0) && (wAmmoModes < 0)),
"Error while loading: Invalid crit modes for ammo: %s.",
buf);
if (wFireModes < 0)
wFireModes = 0;
if (wAmmoModes < 0)
wAmmoModes = 0;
GetPartFireMode(mech, section, critical) = wFireModes;
GetPartAmmoMode(mech, section, critical) = wAmmoModes;
if (GetPartData(mech, section, critical) < FullAmmo(mech,
section, critical)) {
GetPartFireMode(mech, section, critical) |=
HALFTON_MODE;
if (GetPartData(mech, section,
critical) > FullAmmo(mech, section, critical))
GetPartFireMode(mech, section, critical) &=
~HALFTON_MODE;
}
if (GetPartData(mech, section, critical) != FullAmmo(mech,
section, critical) && MechType(mech) != CLASS_MW &&
MechType(mech) != CLASS_BSUIT) {
SendError(tprintf
("Invalid ammo crit for %s in #%d %s (%d/%d)",
MechWeapons[Ammo2I(type)].name, mech->mynum,
filename, GetPartData(mech, section, critical),
FullAmmo(mech, section, critical))
);
SetPartData(mech, section, critical, FullAmmo(mech,
section, critical));
}
} else {
GetPartData(mech, section, critical) = 0;
GetPartFireMode(mech, section, critical) = 0;
GetPartAmmoMode(mech, section, critical) = 0;
if ((line2 = one_arg(line2, buf)))
if ((line2 = one_arg(line2, buf))) {
line2 = one_arg(line2, buf);
if (mudconf.btech_parts)
if (atoi(buf)) {
SetPartBrand(mech, section, critical,
atoi(buf));
}
}
}
for (x = (lpos + 1); x <= hpos; x++) {
SetPartType(mech, section, x, GetPartType(mech, section,
lpos));
SetPartData(mech, section, x, GetPartData(mech, section,
lpos));
SetPartFireMode(mech, section, x, GetPartFireMode(mech,
section, lpos));
SetPartAmmoMode(mech, section, x, GetPartAmmoMode(mech,
section, lpos));
SetPartBrand(mech, section, x, GetPartBrand(mech, section,
lpos));
}
break;
case 15: /* Mech's Computer level */
MechComputer(mech) = atoi(read_desc(fp, ptr));
break;
case 16: /* Name of the mech */
strcpy(MechType_Name(mech), read_desc(fp, ptr));
break;
case 17: /* Jj's */
MechJumpSpeed(mech) = atof(read_desc(fp, ptr));
break;
case 18: /* Radio */
MechRadio(mech) = atoi(read_desc(fp, ptr));
break;
case 19: /* SI */
AeroSI(mech) = AeroSIOrig(mech) = atoi(read_desc(fp, ptr));
break;
case 20: /* Fuel */
AeroFuel(mech) = AeroFuelOrig(mech) = atoi(read_desc(fp, ptr));
break;
case 21: /* Comment */
break;
case 22: /* Radio_freqs */
MechRadioType(mech) = atoi(read_desc(fp, ptr));
break;
case 23: /* Mech battle value */
MechBV(mech) = atoi(read_desc(fp, ptr));
break;
case 24: /* Cargospace */
CargoSpace(mech) = atoi(read_desc(fp, ptr));
break;
case 25: /* Maxsuits */
MechMaxSuits(mech) = atoi(read_desc(fp, ptr));
break;
case 26: /* Specials */
tmpc = read_desc(fp, ptr);
if (CheckSpecialsList(infantry_specials, 0, tmpc))
MechInfantrySpecials(mech) |=
BuildBitVectorNoErr(infantry_specials, tmpc);
break;
case 27: /* Carmaxton */
CarMaxTon(mech) = atoi(read_desc(fp, ptr));
break;
}
}
fclose(fp);
MechEngineSizeV(mech) = MechEngineSizeC(mech);
#define Set(a,b) \
if (!(a)) a = b
if (!(MechSpecials(mech) & ICE_TECH))
Set(MechRealNumsinks(mech), DEFAULT_HEATSINKS);
if (MechType(mech) == CLASS_MECH)
do_sub_magic(mech, 1);
if (MechType(mech) == CLASS_MW)
Startup(mech);
if (MechType(mech) == CLASS_MECH)
value = 8;
else
value = 6;
if (mudconf.btech_parts)
for (x = 0; x < value; x++)
for (y = 0; y < CritsInLoc(mech, x); y++)
if ((t = GetPartType(mech, x, y))) {
if (GetPartBrand(mech, x, y))
continue;
if (IsAmmo(t))
continue;
if (IsBomb(t))
continue;
SetPartBrand(mech, x, y,
isClan ? DEFAULT_CLPART_LEVEL :
DEFAULT_PART_LEVEL);
}
if (isClan) {
Set(MechComputer(mech), DEFAULT_CLCOMPUTER);
Set(MechRadio(mech), DEFAULT_CLRADIO);
} else {
Set(MechComputer(mech), DEFAULT_COMPUTER);
Set(MechRadio(mech), DEFAULT_RADIO);
}
if (!MechRadioType(mech))
MechRadioType(mech) = generic_radio_type(MechRadio(mech), isClan);
if (!MechComputer(mech)) {
Set(MechScanRange(mech), DEFAULT_SCANRANGE);
Set(MechLRSRange(mech), DEFAULT_LRSRANGE);
Set(MechRadioRange(mech), DEFAULT_RADIORANGE);
Set(MechTacRange(mech), DEFAULT_TACRANGE);
} else {
Set(MechScanRange(mech), MechComputersScanRange(mech));
Set(MechLRSRange(mech), MechComputersLRSRange(mech));
Set(MechRadioRange(mech), MechComputersRadioRange(mech));
Set(MechTacRange(mech), MechComputersTacRange(mech));
}
#if 1 /* Don't know if we're ready for this yet - aw, what the hell :) */
if (MechType(mech) == CLASS_MECH)
if ((GetPartType(mech, LARM, 2) != Special(LOWER_ACTUATOR)) &&
(GetPartType(mech, RARM, 2) != Special(LOWER_ACTUATOR)) &&
(GetPartType(mech, LARM, 3) != Special(HAND_OR_FOOT_ACTUATOR))
&& (GetPartType(mech, RARM,
3) != Special(HAND_OR_FOOT_ACTUATOR)))
MechSpecials(mech) |= FLIPABLE_ARMS;
#endif
update_specials(mech);
mech_int_check(mech, 1);
x = mech_weight_sub(GOD, mech, 0);
y = MechTons(mech) * 1024;
if (abs(x - y) > 40)
SendError(tprintf
("Error in %s template: %.1f tons of 'stuff', yet %d ton frame.",
MechType_Ref(mech), x / 1024.0, y / 1024));
update_oweight(mech, x);
if ((map = FindObjectsData(mech->mapindex)))
UpdateConditions(mech, map);
/* To prevent certain funny occurences.. */
for (i = 0; i < NUM_SECTIONS; i++)
if (!(GetSectOInt(mech, i)))
SetSectDestroyed(mech, i);
return 0;
}
void DumpMechSpecialObjects(dbref player)
{
coolmenu *c;
c = AutoCol_StringMenu("MechSpecials available", internals);
ShowCoolMenu(player, c);
KillCoolMenu(c);
}
static char *dumpweapon_fun(int i)
{
static char buf[256];
buf[0] = 0;
if (!i)
sprintf(buf, WDUMP_MASKS);
else {
i--;
sprintf(buf, WDUMP_MASK, MechWeapons[i].name, MechWeapons[i].heat,
MechWeapons[i].damage, MechWeapons[i].min,
MechWeapons[i].shortrange, MechWeapons[i].medrange,
GunRange(i), MechWeapons[i].vrt, MechWeapons[i].criticals,
MechWeapons[i].ammoperton);
}
return buf;
}
void DumpWeapons(dbref player)
{
coolmenu *c;
c = SelCol_FunStringMenuK(1, "MechWeapons available", dumpweapon_fun,
num_def_weapons + 1);
ShowCoolMenu(player, c);
KillCoolMenu(c);
}
char *techlist_func(MECH * mech)
{
static char buffer[MBUF_SIZE];
char bufa[SBUF_SIZE], bufb[SBUF_SIZE];
int i, ii, part = 0, axe = 0, mace = 0, sword = 0, hascase = 0;
snprintf(bufa, SBUF_SIZE, "%s", BuildBitString(specialsabrev, MechSpecials(mech)));
snprintf(bufb, SBUF_SIZE, "%s", BuildBitString(specialsabrev2, MechSpecials2(mech)));
snprintf(buffer, MBUF_SIZE, "%s %s", bufa, bufb);
if (!(strstr(buffer, "XL") || strstr(buffer, "XXL") || strstr(buffer, "LENG") || strstr(buffer, "ICE") || strstr(buffer, "CENG")))
strcat(buffer, " FUS ");
for (i = 0 ; i < NUM_SECTIONS; i++)
for (ii = 0; ii < NUM_CRITICALS; ii++) {
part = GetPartType(mech, i, ii);
if (part == I2Special(AXE) && !axe) {
axe = 1;
strcat(buffer, " AXE");
}
if (part == I2Special(MACE) && !mace) {
mace = 1;
strcat(buffer, " MACE");
}
if (part == I2Special(SWORD) && !sword) {
sword = 1;
strcat(buffer, " SWORD");
}
if ((MechSections(mech)[i].config & CASE_TECH) && !hascase) {
hascase = 1;
strcat(buffer, " CASE");
}
}
if (CargoSpace(mech))
strcat(buffer, " INFC");
if (MechType(mech) == CLASS_VTOL)
strcat(buffer, " VTOL");
if (MechType(mech) == CLASS_MECH && MechMove(mech) != MOVE_QUAD) {
if ((OkayCritSectS(RARM, 3, HAND_OR_FOOT_ACTUATOR) && OkayCritSectS(RARM, 0, SHOULDER_OR_HIP)) ||
(OkayCritSectS(LARM, 3, HAND_OR_FOOT_ACTUATOR) && OkayCritSectS(LARM, 0, SHOULDER_OR_HIP)) ||
MechSpecials(mech) & SALVAGE_TECH)
strcat(buffer, " MTOW");
} else {
if (MechSpecials(mech) & SALVAGE_TECH)
strcat(buffer, " MTOW");
}
return buffer;
}
/* Function to return the payload of a unit
* Used by the btpayload_ref() scode function
* Dany - 06/2005 */
char *payloadlist_func(MECH * mech)
{
static char buffer[MBUF_SIZE];
unsigned char weaparray[MAX_WEAPS_SECTION];
unsigned char weapdata[MAX_WEAPS_SECTION];
int critical[MAX_WEAPS_SECTION];
short ammomode;
int temp_crit;
int count, weap_count, ammo_count, section_loop, weap_loop, put_loop;
char payloadbuff[120];
unsigned short payload_items[8 * MAX_WEAPS_SECTION];
unsigned short payload_items_count[8 * MAX_WEAPS_SECTION];
/* Clear the buffer */
snprintf(buffer, MBUF_SIZE, "%s", "");
/* Count each 'unique' item */
weap_count = 0;
ammo_count = 0;
/* Initialize array */
for (put_loop = 0; put_loop < 8 * MAX_WEAPS_SECTION; put_loop++) {
payload_items[put_loop] = 0;
payload_items_count[put_loop] = 0;
}
/* Get the weapons for each sections */
for (section_loop = 0; section_loop < NUM_SECTIONS; section_loop++) {
/* Get all the weapons for that section */
count = FindWeapons(mech, section_loop, weaparray, weapdata, critical);
/* Check if any weapons in that section */
if (count <= 0)
continue;
/* Loop through all the weapons found and store their values */
for (weap_loop = 0; weap_loop < count; weap_loop++) {
/* Loop to put weapons in the temp array and keep count */
for (put_loop = 0; put_loop < 8 * MAX_WEAPS_SECTION; put_loop++) {
/* Check to see if there is already an entry */
if (payload_items[put_loop] == weaparray[weap_loop]) {
payload_items_count[put_loop]++;
break;
/* Ok, see if there is no entry */
} else if (payload_items[put_loop] == 0) {
payload_items[put_loop] = weaparray[weap_loop];
payload_items_count[put_loop]++;
weap_count++;
break;
}
} /* End of put loop */
} /* End of weap count loop */
} /* End of section loop */
/* Loop through all the sections */
for (section_loop = 0; section_loop < NUM_SECTIONS; section_loop++) {
/* Loop through all the crits in a section */
for (count = 0; count < MAX_WEAPS_SECTION; count++) {
/* Get the Part at that spot */
temp_crit = GetPartType(mech, section_loop, count);
/* Is it Ammo? */
if (IsAmmo(temp_crit)) {
/* Loop to put weapons in the temp array and keep count */
for (put_loop = weap_count; put_loop < 8 * MAX_WEAPS_SECTION; put_loop++) {
/* Check to see if there is already an entry */
if (payload_items[put_loop] == temp_crit) {
payload_items_count[put_loop]++;
break;
/* Ok, see if there is no entry */
} else if (payload_items[put_loop] == 0) {
payload_items[put_loop] = temp_crit;
payload_items_count[put_loop]++;
ammo_count++;
break;
}
} /* End of put loop */
} /* End of is it Ammo if Statement */
} /* End of Crit Slot Loop */
} /* End of Section Loop */
/* Final loop to print out the full payload to the buffer and return it */
for (put_loop = 0; put_loop < (weap_count + ammo_count); put_loop++) {
/* If its a weapon use this method of printing it out
* Else use the part method */
if (put_loop < weap_count ) {
sprintf(payloadbuff, "%s:%d",
&MechWeapons[payload_items[put_loop]].name[0],
payload_items_count[put_loop]);
} else {
sprintf(payloadbuff, "%s:%d", partname_func(payload_items[put_loop], 'V'),
payload_items_count[put_loop]);
}
/* If we are not at the end, then put a | as a spacer */
if (put_loop < (weap_count + ammo_count - 1)) {
strncat(payloadbuff, "|", sizeof(buffer) - strlen(buffer) - 1);
}
/* Adding it to the main buffer */
strncat(buffer, payloadbuff, sizeof(buffer) - strlen(buffer) - 1);
} /* End of printing loop */
return buffer;
}