1 #ifndef SPACESHIP_H 2 #define SPACESHIP_H 3 #include <i18n.h> 4 5 #include <array> 6 #include <optional> 7 8 #include "shipTemplateBasedObject.h" 9 #include "spaceStation.h" 10 #include "spaceshipParts/beamWeapon.h" 11 #include "spaceshipParts/weaponTube.h" 12 13 enum EMainScreenSetting 14 { 15 MSS_Front = 0, 16 MSS_Back, 17 MSS_Left, 18 MSS_Right, 19 MSS_Target, 20 MSS_Tactical, 21 MSS_LongRange 22 }; 23 template<> void convert<EMainScreenSetting>::param(lua_State* L, int& idx, EMainScreenSetting& mss); 24 25 enum EMainScreenOverlay 26 { 27 MSO_HideComms = 0, 28 MSO_ShowComms 29 }; 30 template<> void convert<EMainScreenOverlay>::param(lua_State* L, int& idx, EMainScreenOverlay& mso); 31 32 enum EDockingState 33 { 34 DS_NotDocking = 0, 35 DS_Docking, 36 DS_Docked 37 }; 38 39 struct Speeds 40 { 41 float forward; 42 float reverse; 43 }; 44 template<> int convert<Speeds>::returnType(lua_State* L, const Speeds &speeds); 45 46 47 class ShipSystem 48 { 49 public: 50 static constexpr float power_factor_rate = 0.08f; 51 static constexpr float default_heat_rate_per_second = 0.05f; 52 static constexpr float default_power_rate_per_second = 0.3f; 53 static constexpr float default_coolant_rate_per_second = 1.2f; 54 float health; //1.0-0.0, where 0.0 is fully broken. 55 float health_max; //1.0-0.0, where 0.0 is fully broken. 56 float power_level; //0.0-3.0, default 1.0 57 float power_request; 58 float heat_level; //0.0-1.0, system will damage at 1.0 59 float coolant_level; //0.0-10.0 60 float coolant_request; 61 float hacked_level; //0.0-1.0 62 float power_factor; 63 float coolant_rate_per_second{}; 64 float heat_rate_per_second{}; 65 float power_rate_per_second{}; 66 getHeatingDelta()67 float getHeatingDelta() const 68 { 69 return powf(1.7, power_level - 1.0) - (1.01 + coolant_level * 0.1); 70 } 71 getPowerUserFactor()72 float getPowerUserFactor() const 73 { 74 return power_factor * power_factor_rate; 75 } 76 }; 77 78 class SpaceShip : public ShipTemplateBasedObject 79 { 80 public: 81 constexpr static int max_frequency = 20; 82 constexpr static float combat_maneuver_charge_time = 20.0f; /*< Amount of time it takes to fully charge the combat maneuver system */ 83 constexpr static float combat_maneuver_boost_max_time = 3.0f; /*< Amount of time we can boost with a fully charged combat maneuver system */ 84 constexpr static float combat_maneuver_strafe_max_time = 3.0f; /*< Amount of time we can strafe with a fully charged combat maneuver system */ 85 constexpr static float warp_charge_time = 4.0f; 86 constexpr static float warp_decharge_time = 2.0f; 87 constexpr static float jump_drive_charge_time = 90.0; /*<Total charge time for the jump drive after a max range jump */ 88 constexpr static float jump_drive_energy_per_km_charge = 4.0f; 89 constexpr static float jump_drive_heat_per_jump = 0.35; 90 constexpr static float heat_per_combat_maneuver_boost = 0.2; 91 constexpr static float heat_per_combat_maneuver_strafe = 0.2; 92 constexpr static float heat_per_warp = 0.02; 93 constexpr static float unhack_time = 180.0f; //It takes this amount of time to go from 100% hacked to 0% hacked for systems. 94 95 float energy_level; 96 float max_energy_level; 97 ShipSystem systems[SYS_COUNT]; 98 static std::array<float, SYS_COUNT> default_system_power_factors; 99 /*! 100 *[input] Ship will try to aim to this rotation. (degrees) 101 */ 102 float target_rotation; 103 104 /*! 105 *[input] Ship will rotate in this velocity. ([-1,1], overrides target_rotation) 106 */ 107 float turnSpeed; 108 109 /*! 110 * [input] Amount of impulse requested from the user (-1.0 to 1.0) 111 */ 112 float impulse_request; 113 114 /*! 115 * [output] Amount of actual impulse from the engines (-1.0 to 1.0) 116 */ 117 float current_impulse; 118 119 /*! 120 * [config] Speed of rotation, in deg/second 121 */ 122 float turn_speed; 123 124 /*! 125 * [config] Max speed of the impulse engines, in m/s 126 */ 127 float impulse_max_speed; 128 129 /*! 130 * [config] Max speed of the reverse impulse engines, in m/s 131 */ 132 float impulse_max_reverse_speed; 133 134 /*! 135 * [config] Impulse engine acceleration, in (m/s)/s 136 */ 137 float impulse_acceleration; 138 139 /*! 140 * [config] Impulse engine acceleration in reverse, in (m/s)/s 141 */ 142 float impulse_reverse_acceleration; 143 144 /*! 145 * [config] True if we have a warpdrive. 146 */ 147 bool has_warp_drive; 148 149 /*! 150 * [input] Level of warp requested, from 0 to 4 151 */ 152 int8_t warp_request; 153 154 /*! 155 * [output] Current active warp amount, from 0.0 to 4.0 156 */ 157 float current_warp; 158 159 /*! 160 * [config] Amount of speed per warp level, in m/s 161 */ 162 float warp_speed_per_warp_level; 163 164 /*! 165 * [output] How much charge there is in the combat maneuvering system (0.0-1.0) 166 */ 167 float combat_maneuver_charge; 168 /*! 169 * [input] How much boost we want at this moment (0.0-1.0) 170 */ 171 float combat_maneuver_boost_request; 172 float combat_maneuver_boost_active; 173 174 float combat_maneuver_strafe_request; 175 float combat_maneuver_strafe_active; 176 177 float combat_maneuver_boost_speed; /*< [config] Speed to indicate how fast we will fly forwards with a full boost */ 178 float combat_maneuver_strafe_speed; /*< [config] Speed to indicate how fast we will fly sideways with a full strafe */ 179 180 bool has_jump_drive; //[config] 181 float jump_drive_charge; //[output] 182 float jump_distance; //[output] 183 float jump_delay; //[output] 184 float jump_drive_min_distance; //[config] 185 float jump_drive_max_distance; //[config] 186 float wormhole_alpha; //Used for displaying the Warp-postprocessor 187 188 int weapon_storage[MW_Count]; 189 int weapon_storage_max[MW_Count]; 190 int8_t weapon_tube_count; 191 WeaponTube weapon_tube[max_weapon_tubes]; 192 193 /*! 194 * [output] Frequency of beam weapons 195 */ 196 int beam_frequency; 197 ESystem beam_system_target; 198 BeamWeapon beam_weapons[max_beam_weapons]; 199 200 /** 201 * Frequency setting of the shields. 202 */ 203 int shield_frequency; 204 205 /// MultiplayerObjectID of the targeted object, or -1 when no target is selected. 206 int32_t target_id; 207 208 EDockingState docking_state; 209 P<SpaceObject> docking_target; //Server only 210 sf::Vector2f docking_offset; //Server only 211 212 SpaceShip(string multiplayerClassName, float multiplayer_significant_range=-1); 213 virtual ~SpaceShip(); 214 215 #if FEATURE_3D_RENDERING 216 virtual void draw3DTransparent() override; 217 #endif 218 /*! 219 * Get this ship's radar signature dynamically modified by the state of its 220 * systems and current activity. 221 */ 222 virtual RawRadarSignatureInfo getDynamicRadarSignatureInfo(); getDynamicRadarSignatureGravity()223 float getDynamicRadarSignatureGravity() { return getDynamicRadarSignatureInfo().gravity; } getDynamicRadarSignatureElectrical()224 float getDynamicRadarSignatureElectrical() { return getDynamicRadarSignatureInfo().electrical; } getDynamicRadarSignatureBiological()225 float getDynamicRadarSignatureBiological() { return getDynamicRadarSignatureInfo().biological; } 226 227 /*! 228 * Draw this ship on the radar. 229 */ 230 virtual void drawOnRadar(sf::RenderTarget& window, sf::Vector2f position, float scale, float rotation, bool long_range) override; 231 virtual void drawOnGMRadar(sf::RenderTarget& window, sf::Vector2f position, float scale, float rotation, bool long_range) override; 232 233 virtual void update(float delta) override; 234 virtual float getShieldRechargeRate(int shield_index) override; 235 virtual float getShieldDamageFactor(DamageInfo& info, int shield_index) override; getJumpDriveRechargeRate()236 float getJumpDriveRechargeRate() { return Tween<float>::linear(getSystemEffectiveness(SYS_JumpDrive), 0.0, 1.0, -0.25, 1.0); } 237 238 /*! 239 * Check if the ship can be targeted. 240 */ canBeTargetedBy(P<SpaceObject> other)241 virtual bool canBeTargetedBy(P<SpaceObject> other) override { return true; } 242 243 /*! 244 * didAnOffensiveAction is called whenever this ship does something offesive towards an other object 245 * this can identify the ship as friend or foe. 246 */ 247 void didAnOffensiveAction(); 248 249 /*! 250 * Spaceship takes damage directly on hull. 251 * This is used when shields are down or by weapons that ignore shields. 252 * \param damage_amount Damage to be delt. 253 * \param info Information about damage type (usefull for damage reduction, etc) 254 */ 255 virtual void takeHullDamage(float damage_amount, DamageInfo& info) override; 256 257 /*! 258 * Spaceship is destroyed by damage. 259 * \param info Information about damage type 260 */ 261 virtual void destroyedByDamage(DamageInfo& info) override; 262 263 /*! 264 * Jump in current direction 265 * \param distance Distance to jump in meters) 266 */ 267 virtual void executeJump(float distance); 268 269 /*! 270 * Check if object can dock with this ship. 271 * \param object Object that wants to dock. 272 */ 273 virtual bool canBeDockedBy(P<SpaceObject> obj) override; 274 275 virtual void collide(Collisionable* other, float force) override; 276 277 /*! 278 * Start the jumping procedure. 279 */ 280 void initializeJump(float distance); 281 282 /*! 283 * Request to dock with target. 284 */ 285 void requestDock(P<SpaceObject> target); 286 287 /*! 288 * Request undock with current docked object 289 */ 290 void requestUndock(); 291 292 /*! 293 * Abort the current dock request 294 */ 295 void abortDock(); 296 297 /// Dummy virtual function to use energy. Only player ships currently model energy use. useEnergy(float amount)298 virtual bool useEnergy(float amount) { return true; } 299 300 /// Dummy virtual function to add heat on a system. The player ship class has an actual implementation of this as only player ships model heat right now. addHeat(ESystem system,float amount)301 virtual void addHeat(ESystem system, float amount) {} 302 canBeScannedBy(P<SpaceObject> other)303 virtual bool canBeScannedBy(P<SpaceObject> other) override { return getScannedStateFor(other) != SS_FullScan; } 304 virtual int scanningComplexity(P<SpaceObject> other) override; 305 virtual int scanningChannelDepth(P<SpaceObject> other) override; 306 virtual void scannedBy(P<SpaceObject> other) override; 307 void setScanState(EScannedState scanned); 308 void setScanStateByFaction(string faction_name, EScannedState scanned); 309 310 bool isFriendOrFoeIdentified();//[DEPRICATED] 311 bool isFullyScanned();//[DEPRICATED] 312 bool isFriendOrFoeIdentifiedBy(P<SpaceObject> other); 313 bool isFullyScannedBy(P<SpaceObject> other); 314 bool isFriendOrFoeIdentifiedByFaction(int faction_id); 315 bool isFullyScannedByFaction(int faction_id); 316 317 virtual bool canBeHackedBy(P<SpaceObject> other) override; 318 virtual std::vector<std::pair<ESystem, float> > getHackingTargets() override; 319 virtual void hackFinished(P<SpaceObject> source, string target) override; 320 321 /*! 322 * Check if ship has certain system 323 */ 324 bool hasSystem(ESystem system); 325 326 /*! 327 * Check effectiveness of system. 328 * If system has more / less power or is damages, this can influence the effectiveness. 329 * \return float 0. to 1. 330 */ 331 float getSystemEffectiveness(ESystem system); 332 333 virtual void applyTemplateValues() override; 334 335 P<SpaceObject> getTarget(); 336 337 virtual std::unordered_map<string, string> getGMInfo() override; 338 isDocked(P<SpaceObject> target)339 bool isDocked(P<SpaceObject> target) { return docking_state == DS_Docked && docking_target == target; } getDockedWith()340 P<SpaceObject> getDockedWith() { if (docking_state == DS_Docked) return docking_target; return NULL; } canStartDocking()341 bool canStartDocking() { return current_warp <= 0.0 && (!has_jump_drive || jump_delay <= 0.0); } getDockingState()342 EDockingState getDockingState() { return docking_state; } getWeaponStorage(EMissileWeapons weapon)343 int getWeaponStorage(EMissileWeapons weapon) { if (weapon == MW_None) return 0; return weapon_storage[weapon]; } getWeaponStorageMax(EMissileWeapons weapon)344 int getWeaponStorageMax(EMissileWeapons weapon) { if (weapon == MW_None) return 0; return weapon_storage_max[weapon]; } setWeaponStorage(EMissileWeapons weapon,int amount)345 void setWeaponStorage(EMissileWeapons weapon, int amount) { if (weapon == MW_None) return; weapon_storage[weapon] = amount; } setWeaponStorageMax(EMissileWeapons weapon,int amount)346 void setWeaponStorageMax(EMissileWeapons weapon, int amount) { if (weapon == MW_None) return; weapon_storage_max[weapon] = amount; weapon_storage[weapon] = std::min(int(weapon_storage[weapon]), amount); } getMaxEnergy()347 float getMaxEnergy() { return max_energy_level; } setMaxEnergy(float amount)348 void setMaxEnergy(float amount) { if (amount > 0.0) { max_energy_level = amount;} } getEnergy()349 float getEnergy() { return energy_level; } setEnergy(float amount)350 void setEnergy(float amount) { if ( (amount > 0.0) && (amount <= max_energy_level)) { energy_level = amount; } } getSystemHackedLevel(ESystem system)351 float getSystemHackedLevel(ESystem system) { if (system >= SYS_COUNT) return 0.0; if (system <= SYS_None) return 0.0; return systems[system].hacked_level; } setSystemHackedLevel(ESystem system,float hacked_level)352 void setSystemHackedLevel(ESystem system, float hacked_level) { if (system >= SYS_COUNT) return; if (system <= SYS_None) return; systems[system].hacked_level = std::min(1.0f, std::max(0.0f, hacked_level)); } getSystemHealth(ESystem system)353 float getSystemHealth(ESystem system) { if (system >= SYS_COUNT) return 0.0; if (system <= SYS_None) return 0.0; return systems[system].health; } setSystemHealth(ESystem system,float health)354 void setSystemHealth(ESystem system, float health) { if (system >= SYS_COUNT) return; if (system <= SYS_None) return; systems[system].health = std::min(1.0f, std::max(-1.0f, health)); } getSystemHealthMax(ESystem system)355 float getSystemHealthMax(ESystem system) { if (system >= SYS_COUNT) return 0.0; if (system <= SYS_None) return 0.0; return systems[system].health_max; } setSystemHealthMax(ESystem system,float health_max)356 void setSystemHealthMax(ESystem system, float health_max) { if (system >= SYS_COUNT) return; if (system <= SYS_None) return; systems[system].health_max = std::min(1.0f, std::max(-1.0f, health_max)); } getSystemHeat(ESystem system)357 float getSystemHeat(ESystem system) { if (system >= SYS_COUNT) return 0.0; if (system <= SYS_None) return 0.0; return systems[system].heat_level; } setSystemHeat(ESystem system,float heat)358 void setSystemHeat(ESystem system, float heat) { if (system >= SYS_COUNT) return; if (system <= SYS_None) return; systems[system].heat_level = std::min(1.0f, std::max(0.0f, heat)); } getSystemHeatRate(ESystem system)359 float getSystemHeatRate(ESystem system) const { if (system >= SYS_COUNT) return 0.f; if (system <= SYS_None) return 0.f; return systems[system].heat_rate_per_second; } setSystemHeatRate(ESystem system,float rate)360 void setSystemHeatRate(ESystem system, float rate) { if (system >= SYS_COUNT) return; if (system <= SYS_None) return; systems[system].heat_rate_per_second = rate; } 361 getSystemPower(ESystem system)362 float getSystemPower(ESystem system) { if (system >= SYS_COUNT) return 0.0; if (system <= SYS_None) return 0.0; return systems[system].power_level; } setSystemPower(ESystem system,float power)363 void setSystemPower(ESystem system, float power) { if (system >= SYS_COUNT) return; if (system <= SYS_None) return; systems[system].power_level = std::min(3.0f, std::max(0.0f, power)); } getSystemPowerRate(ESystem system)364 float getSystemPowerRate(ESystem system) const { if (system >= SYS_COUNT) return 0.f; if (system <= SYS_None) return 0.f; return systems[system].power_rate_per_second; } setSystemPowerRate(ESystem system,float rate)365 void setSystemPowerRate(ESystem system, float rate) { if (system >= SYS_COUNT) return; if (system <= SYS_None) return; systems[system].power_rate_per_second = rate; } getSystemPowerUserFactor(ESystem system)366 float getSystemPowerUserFactor(ESystem system) { if (system >= SYS_COUNT) return 0.f; if (system <= SYS_None) return 0.f; return systems[system].getPowerUserFactor(); } getSystemPowerFactor(ESystem system)367 float getSystemPowerFactor(ESystem system) { if (system >= SYS_COUNT) return 0.f; if (system <= SYS_None) return 0.f; return systems[system].power_factor; } setSystemPowerFactor(ESystem system,float factor)368 void setSystemPowerFactor(ESystem system, float factor) { if (system >= SYS_COUNT) return; if (system <= SYS_None) return; systems[system].power_factor = factor; } getSystemCoolant(ESystem system)369 float getSystemCoolant(ESystem system) { if (system >= SYS_COUNT) return 0.0; if (system <= SYS_None) return 0.0; return systems[system].coolant_level; } setSystemCoolant(ESystem system,float coolant)370 void setSystemCoolant(ESystem system, float coolant) { if (system >= SYS_COUNT) return; if (system <= SYS_None) return; systems[system].coolant_level = std::min(1.0f, std::max(0.0f, coolant)); } getImpulseMaxSpeed()371 Speeds getImpulseMaxSpeed() {return {impulse_max_speed, impulse_max_reverse_speed};} setImpulseMaxSpeed(float forward_speed,std::optional<float> reverse_speed)372 void setImpulseMaxSpeed(float forward_speed, std::optional<float> reverse_speed) 373 { 374 impulse_max_speed = forward_speed; 375 impulse_max_reverse_speed = reverse_speed.value_or(forward_speed); 376 } getSystemCoolantRate(ESystem system)377 float getSystemCoolantRate(ESystem system) const { if (system >= SYS_COUNT) return 0.f; if (system <= SYS_None) return 0.f; return systems[system].coolant_rate_per_second; } setSystemCoolantRate(ESystem system,float rate)378 void setSystemCoolantRate(ESystem system, float rate) { if (system >= SYS_COUNT) return; if (system <= SYS_None) return; systems[system].coolant_rate_per_second = rate; } getRotationMaxSpeed()379 float getRotationMaxSpeed() { return turn_speed; } setRotationMaxSpeed(float speed)380 void setRotationMaxSpeed(float speed) { turn_speed = speed; } getAcceleration()381 Speeds getAcceleration() { return {impulse_acceleration, impulse_reverse_acceleration};} setAcceleration(float acceleration,std::optional<float> reverse_acceleration)382 void setAcceleration(float acceleration, std::optional<float> reverse_acceleration) 383 { 384 impulse_acceleration = acceleration; 385 impulse_reverse_acceleration = reverse_acceleration.value_or(acceleration); 386 } setCombatManeuver(float boost,float strafe)387 void setCombatManeuver(float boost, float strafe) { combat_maneuver_boost_speed = boost; combat_maneuver_strafe_speed = strafe; } hasJumpDrive()388 bool hasJumpDrive() { return has_jump_drive; } setJumpDrive(bool has_jump)389 void setJumpDrive(bool has_jump) { has_jump_drive = has_jump; } setJumpDriveRange(float min,float max)390 void setJumpDriveRange(float min, float max) { jump_drive_min_distance = min; jump_drive_max_distance = max; } hasWarpDrive()391 bool hasWarpDrive() { return has_warp_drive; } setWarpDrive(bool has_warp)392 void setWarpDrive(bool has_warp) 393 { 394 has_warp_drive = has_warp; 395 if (has_warp_drive) 396 { 397 if (warp_speed_per_warp_level < 100) 398 warp_speed_per_warp_level = 1000; 399 }else{ 400 warp_request = 0.0; 401 warp_speed_per_warp_level = 0; 402 } 403 } setWarpSpeed(float speed)404 void setWarpSpeed(float speed) { warp_speed_per_warp_level = std::max(0.0f, speed); } getWarpSpeed()405 float getWarpSpeed() { 406 if (has_warp_drive) { 407 return warp_speed_per_warp_level; 408 } else { 409 return 0.0f; 410 } 411 } getJumpDriveCharge()412 float getJumpDriveCharge() { return jump_drive_charge; } setJumpDriveCharge(float charge)413 void setJumpDriveCharge(float charge) { jump_drive_charge = charge; } getJumpDelay()414 float getJumpDelay() { return jump_delay; } 415 getBeamWeaponArc(int index)416 float getBeamWeaponArc(int index) { if (index < 0 || index >= max_beam_weapons) return 0.0; return beam_weapons[index].getArc(); } getBeamWeaponDirection(int index)417 float getBeamWeaponDirection(int index) { if (index < 0 || index >= max_beam_weapons) return 0.0; return beam_weapons[index].getDirection(); } getBeamWeaponRange(int index)418 float getBeamWeaponRange(int index) { if (index < 0 || index >= max_beam_weapons) return 0.0; return beam_weapons[index].getRange(); } 419 getBeamWeaponTurretArc(int index)420 float getBeamWeaponTurretArc(int index) 421 { 422 if (index < 0 || index >= max_beam_weapons) 423 return 0.0; 424 return beam_weapons[index].getTurretArc(); 425 } 426 getBeamWeaponTurretDirection(int index)427 float getBeamWeaponTurretDirection(int index) 428 { 429 if (index < 0 || index >= max_beam_weapons) 430 return 0.0; 431 return beam_weapons[index].getTurretDirection(); 432 } 433 getBeamWeaponTurretRotationRate(int index)434 float getBeamWeaponTurretRotationRate(int index) 435 { 436 if (index < 0 || index >= max_beam_weapons) 437 return 0.0; 438 return beam_weapons[index].getTurretRotationRate(); 439 } 440 getBeamWeaponCycleTime(int index)441 float getBeamWeaponCycleTime(int index) { if (index < 0 || index >= max_beam_weapons) return 0.0; return beam_weapons[index].getCycleTime(); } getBeamWeaponDamage(int index)442 float getBeamWeaponDamage(int index) { if (index < 0 || index >= max_beam_weapons) return 0.0; return beam_weapons[index].getDamage(); } getBeamWeaponEnergyPerFire(int index)443 float getBeamWeaponEnergyPerFire(int index) { if (index < 0 || index >= max_beam_weapons) return 0.0; return beam_weapons[index].getEnergyPerFire(); } getBeamWeaponHeatPerFire(int index)444 float getBeamWeaponHeatPerFire(int index) { if (index < 0 || index >= max_beam_weapons) return 0.0; return beam_weapons[index].getHeatPerFire(); } 445 getShieldsFrequency(void)446 int getShieldsFrequency(void){ return shield_frequency; } setShieldsFrequency(float freq)447 void setShieldsFrequency(float freq) { if ((freq > SpaceShip::max_frequency) || (freq < 0)) return; shield_frequency = freq;} 448 getBeamFrequency()449 int getBeamFrequency(){ return beam_frequency; } 450 setBeamWeapon(int index,float arc,float direction,float range,float cycle_time,float damage)451 void setBeamWeapon(int index, float arc, float direction, float range, float cycle_time, float damage) 452 { 453 if (index < 0 || index >= max_beam_weapons) 454 return; 455 beam_weapons[index].setArc(arc); 456 beam_weapons[index].setDirection(direction); 457 beam_weapons[index].setRange(range); 458 beam_weapons[index].setCycleTime(cycle_time); 459 beam_weapons[index].setDamage(damage); 460 } 461 setBeamWeaponTurret(int index,float arc,float direction,float rotation_rate)462 void setBeamWeaponTurret(int index, float arc, float direction, float rotation_rate) 463 { 464 if (index < 0 || index >= max_beam_weapons) 465 return; 466 beam_weapons[index].setTurretArc(arc); 467 beam_weapons[index].setTurretDirection(direction); 468 beam_weapons[index].setTurretRotationRate(rotation_rate); 469 } 470 setBeamWeaponTexture(int index,string texture)471 void setBeamWeaponTexture(int index, string texture) 472 { 473 if (index < 0 || index >= max_beam_weapons) 474 return; 475 beam_weapons[index].setBeamTexture(texture); 476 } 477 setBeamWeaponEnergyPerFire(int index,float energy)478 void setBeamWeaponEnergyPerFire(int index, float energy) { if (index < 0 || index >= max_beam_weapons) return; return beam_weapons[index].setEnergyPerFire(energy); } setBeamWeaponHeatPerFire(int index,float heat)479 void setBeamWeaponHeatPerFire(int index, float heat) { if (index < 0 || index >= max_beam_weapons) return; return beam_weapons[index].setHeatPerFire(heat); } 480 481 void setWeaponTubeCount(int amount); 482 int getWeaponTubeCount(); 483 EMissileWeapons getWeaponTubeLoadType(int index); 484 485 void weaponTubeAllowMissle(int index, EMissileWeapons type); 486 void weaponTubeDisallowMissle(int index, EMissileWeapons type); 487 void setWeaponTubeExclusiveFor(int index, EMissileWeapons type); 488 void setWeaponTubeDirection(int index, float direction); 489 void setTubeSize(int index, EMissileSizes size); 490 EMissileSizes getTubeSize(int index); 491 void setTubeLoadTime(int index, float time); 492 float getTubeLoadTime(int index); 493 setRadarTrace(string trace)494 void setRadarTrace(string trace) { radar_trace = trace; } 495 496 void addBroadcast(int threshold, string message); 497 498 // Return a string that can be appended to an object create function in the lua scripting. 499 // This function is used in getScriptExport calls to adjust for tweaks done in the GM screen. 500 string getScriptExportModificationsOnTemplate(); 501 502 }; 503 504 float frequencyVsFrequencyDamageFactor(int beam_frequency, int shield_frequency); 505 506 string getMissileWeaponName(EMissileWeapons missile); 507 string getLocaleMissileWeaponName(EMissileWeapons missile); 508 REGISTER_MULTIPLAYER_ENUM(EMissileWeapons); 509 REGISTER_MULTIPLAYER_ENUM(EWeaponTubeState); 510 REGISTER_MULTIPLAYER_ENUM(EMainScreenSetting); 511 REGISTER_MULTIPLAYER_ENUM(EMainScreenOverlay); 512 REGISTER_MULTIPLAYER_ENUM(EDockingState); 513 REGISTER_MULTIPLAYER_ENUM(EScannedState); 514 515 string frequencyToString(int frequency); 516 517 #endif//SPACESHIP_H 518