diff --git a/Utility Mods/Stable/GyroscopicGunsight/Data/Scripts/GyroscopicGunsight/API/CoreSystems/CoreSystemsApiBase.cs b/Utility Mods/Stable/GyroscopicGunsight/Data/Scripts/GyroscopicGunsight/API/CoreSystems/CoreSystemsApiBase.cs new file mode 100644 index 000000000..4606320c2 --- /dev/null +++ b/Utility Mods/Stable/GyroscopicGunsight/Data/Scripts/GyroscopicGunsight/API/CoreSystems/CoreSystemsApiBase.cs @@ -0,0 +1,864 @@ +using System; +using System.Collections.Generic; +using Sandbox.ModAPI; +using VRage; +using VRage.Collections; +using VRage.Game; +using VRage.Game.Entity; +using VRage.Game.ModAPI; +using VRageMath; + +namespace SC.GyroscopicGunsight.API.CoreSystems +{ + /// + /// https://github.com/sstixrud/CoreSystems/blob/master/BaseData/Scripts/CoreSystems/Api/CoreSystemsApiBase.cs + /// + public partial class WcApi + { + private bool _apiInit; + + private Action> _getAllWeaponDefinitions; + private Action> _getCoreWeapons; + private Action> _getNpcSafeWeapons; + private Action>>>> _getAllWeaponMagazines; + private Action>>>> _getAllNpcSafeWeaponMagazines; + + private Action> _getCoreStaticLaunchers; + private Action> _getCoreTurrets; + private Action> _getCorePhantoms; + private Action> _getCoreRifles; + private Action> _getCoreArmors; + + private Action>>>>> _registerDamageEvent; + private Func, bool> _targetFocusHandler; + private Func, bool> _hudHandler; + private Func, bool> _shootHandler; + private Action> _monitorEvents; + private Action> _unmonitorEvents; + private Action> _addProjectileMonitor; + private Action> _removeProjectileMonitor; + + private Func _shootRequest; + + private Func> _getProjectileState; + private Action> _setProjectileState; + + private Action>> _getSortedThreats; + private Action> _getObstructions; + private Func _getAiFocus; + private Func _setAiFocus; + private Func _releaseAiFocus; + private Func _hasAi; + private Func _hasCoreWeapon; + + private Func _toggoleInfiniteResources; + private Action _disableRequiredPower; + + private Func _getPlayerController; + private Func> _getProjectilesLockedOn; + private Action> _getProjectilesLockedOnPos; + private Func _getMaxPower; + + private Func _getOptimalDps; + private Func _getConstructEffectiveDps; + private Func> _isInRange; + + private Func> _getWeaponTarget; + private Action _setWeaponTarget; + private Action _fireWeaponOnce; + private Action _toggleWeaponFire; + private Func _isWeaponReadyToFire; + private Func _getMaxWeaponRange; + private Func, int, bool> _getTurretTargetTypes; + private Action, int> _setTurretTargetTypes; + private Action _setBlockTrackingRange; + private Func _isTargetAligned; + private Func> _isTargetAlignedExtended; + private Func _canShootTarget; + private Func _getPredictedTargetPos; + private Func _getHeatLevel; + private Func _currentPowerConsumption; + private Func _getActiveAmmo; + private Action _setActiveAmmo; + + private Func _getWeaponAzimuthMatrix; + private Func _getWeaponElevationMatrix; + private Func _isTargetValid; + private Func _isWeaponShooting; + private Func _getShotsFired; + private Action>> _getMuzzleInfo; + private Func> _getWeaponScope; + private Func> _getMagazineMap; + private Func _setMagazine; + private Func _forceReload; + + private Action _setRofMultiplier; + private Action _setBaseDmgMultiplier; + private Action _setAreaDmgMultiplier; + private Action _setAreaRadiusMultiplier; + private Action _setVelocityMultiplier; + private Action _setFiringAllowed; + private Action _registerTerminalControl; + + private Func _getRofMultiplier; + private Func _getBaseDmgMultiplier; + private Func _getAreaDmgMultiplier; + private Func _getAreaRadiusMultiplier; + private Func _getVelocityMultiplier; + private Func _getFiringAllowed; + + + /// + /// Multiplier for 's base Rate of Fire. + /// + /// + /// + public void SetRofMultiplier(MyEntity block, float rof) => + _setRofMultiplier?.Invoke(block, rof); + + /// + /// BaseDamage multiplier for all projectiles from . + /// + /// + /// + public void SetBaseDmgMultiplier(MyEntity block, float multiplier) => _setBaseDmgMultiplier?.Invoke(block, multiplier); + + /// + /// AreaDamage multiplier for all projectiles from . + /// + /// + /// + public void SetAreaDmgMultiplier(MyEntity block, float multiplier) => _setAreaDmgMultiplier?.Invoke(block, multiplier); + + /// + /// AreaRadius multiplier for all projectiles from . + /// + /// + /// + public void SetAreaRadiusMultiplier(MyEntity block, float multiplier) => _setAreaRadiusMultiplier?.Invoke(block, multiplier); + + /// + /// Velocity multiplier for all projectiles from . Avoid setting this to zero. + /// + /// + /// + public void SetVelocityMultiplier(MyEntity block, float multiplier) => _setVelocityMultiplier?.Invoke(block, multiplier); + + /// + /// Toggles whether is allowed to shoot. + /// + /// + /// + public void SetFiringAllowed(MyEntity block, bool isAllowed) => _setFiringAllowed?.Invoke(block, isAllowed); + + /// + /// Registers a terminal control to not be hidden by WeaponCore. + /// + /// + /// + public void RegisterTerminalControl(string controlId) => _registerTerminalControl?.Invoke(controlId); + + public void SetWeaponTarget(MyEntity weapon, MyEntity target, int weaponId = 0) => + _setWeaponTarget?.Invoke(weapon, target, weaponId); + + /// + /// Multiplier for 's base Rate of Fire. + /// + /// + public float GetRofMultiplier(MyEntity block) => _getRofMultiplier?.Invoke(block) ?? -2; + + /// + /// BaseDamage multiplier for all projectiles from . + /// + /// + /// + public float GetBaseDmgMultiplier(MyEntity block) => _getBaseDmgMultiplier?.Invoke(block) ?? -2; + + /// + /// AreaDamage multiplier for all projectiles from . + /// + /// + /// + public float GetAreaDmgMultiplier(MyEntity block) => _getAreaDmgMultiplier?.Invoke(block) ?? -2; + + /// + /// AreaDamage multiplier for all projectiles from . + /// + /// + /// + public float GetAreaRadiusMultiplier(MyEntity block) => _getAreaRadiusMultiplier?.Invoke(block) ?? -2; + + /// + /// Velocity multiplier for all projectiles from . Avoid setting this to zero. + /// + /// + /// + public float GetVelocityMultiplier(MyEntity block) => _getVelocityMultiplier?.Invoke(block) ?? -2; + + /// + /// Toggles whether is allowed to shoot. + /// + /// + /// + public bool GetFiringAllowed(MyEntity block) => _getFiringAllowed?.Invoke(block) ?? false; + + public void FireWeaponOnce(MyEntity weapon, bool allWeapons = true, int weaponId = 0) => + _fireWeaponOnce?.Invoke(weapon, allWeapons, weaponId); + + public void ToggleWeaponFire(MyEntity weapon, bool on, bool allWeapons, int weaponId = 0) => + _toggleWeaponFire?.Invoke(weapon, on, allWeapons, weaponId); + + public bool IsWeaponReadyToFire(MyEntity weapon, int weaponId = 0, bool anyWeaponReady = true, + bool shootReady = false) => + _isWeaponReadyToFire?.Invoke(weapon, weaponId, anyWeaponReady, shootReady) ?? false; + + public float GetMaxWeaponRange(MyEntity weapon, int weaponId) => + _getMaxWeaponRange?.Invoke(weapon, weaponId) ?? 0f; + + public bool GetTurretTargetTypes(MyEntity weapon, IList collection, int weaponId = 0) => + _getTurretTargetTypes?.Invoke(weapon, collection, weaponId) ?? false; + + public void SetTurretTargetTypes(MyEntity weapon, IList collection, int weaponId = 0) => + _setTurretTargetTypes?.Invoke(weapon, collection, weaponId); + + public void SetBlockTrackingRange(MyEntity weapon, float range) => + _setBlockTrackingRange?.Invoke(weapon, range); + + public bool IsTargetAligned(MyEntity weapon, MyEntity targetEnt, int weaponId) => + _isTargetAligned?.Invoke(weapon, targetEnt, weaponId) ?? false; + + public MyTuple IsTargetAlignedExtended(MyEntity weapon, MyEntity targetEnt, int weaponId) => + _isTargetAlignedExtended?.Invoke(weapon, targetEnt, weaponId) ?? new MyTuple(); + + public bool CanShootTarget(MyEntity weapon, MyEntity targetEnt, int weaponId) => + _canShootTarget?.Invoke(weapon, targetEnt, weaponId) ?? false; + + public Vector3D? GetPredictedTargetPosition(MyEntity weapon, MyEntity targetEnt, int weaponId) => + _getPredictedTargetPos?.Invoke(weapon, targetEnt, weaponId) ?? null; + + public float GetHeatLevel(MyEntity weapon) => _getHeatLevel?.Invoke(weapon) ?? 0f; + public float GetCurrentPower(MyEntity weapon) => _currentPowerConsumption?.Invoke(weapon) ?? 0f; + public void DisableRequiredPower(MyEntity weapon) => _disableRequiredPower?.Invoke(weapon); + public bool HasCoreWeapon(MyEntity weapon) => _hasCoreWeapon?.Invoke(weapon) ?? false; + + public string GetActiveAmmo(MyEntity weapon, int weaponId) => + _getActiveAmmo?.Invoke(weapon, weaponId) ?? null; + + public void SetActiveAmmo(MyEntity weapon, int weaponId, string ammoType) => + _setActiveAmmo?.Invoke(weapon, weaponId, ammoType); + + public long GetPlayerController(MyEntity weapon) => _getPlayerController?.Invoke(weapon) ?? -1; + + public Matrix GetWeaponAzimuthMatrix(MyEntity weapon, int weaponId) => + _getWeaponAzimuthMatrix?.Invoke(weapon, weaponId) ?? Matrix.Zero; + + public Matrix GetWeaponElevationMatrix(MyEntity weapon, int weaponId) => + _getWeaponElevationMatrix?.Invoke(weapon, weaponId) ?? Matrix.Zero; + + public bool IsTargetValid(MyEntity weapon, MyEntity target, bool onlyThreats, bool checkRelations) => + _isTargetValid?.Invoke(weapon, target, onlyThreats, checkRelations) ?? false; + + public void GetAllWeaponDefinitions(IList collection) => _getAllWeaponDefinitions?.Invoke(collection); + public void GetAllCoreWeapons(ICollection collection) => _getCoreWeapons?.Invoke(collection); + public void GetNpcSafeWeapons(ICollection collection) => _getNpcSafeWeapons?.Invoke(collection); + + public void GetAllCoreStaticLaunchers(ICollection collection) => _getCoreStaticLaunchers?.Invoke(collection); + public void GetAllWeaponMagazines(IDictionary>>> collection) => _getAllWeaponMagazines?.Invoke(collection); + public void GetAllNpcSafeWeaponMagazines(IDictionary>>> collection) => _getAllNpcSafeWeaponMagazines?.Invoke(collection); + + public void GetAllCoreTurrets(ICollection collection) => _getCoreTurrets?.Invoke(collection); + public void GetAllCorePhantoms(ICollection collection) => _getCorePhantoms?.Invoke(collection); + public void GetAllCoreRifles(ICollection collection) => _getCoreRifles?.Invoke(collection); + public void GetAllCoreArmors(IList collection) => _getCoreArmors?.Invoke(collection); + + /// + /// Gets count of all projectiles that are targeting the MyEntity + /// + public MyTuple GetProjectilesLockedOn(MyEntity victim) => + _getProjectilesLockedOn?.Invoke(victim) ?? new MyTuple(); + /// + /// Gets positional information on projectiles that are actively locked on to the MyEntity + /// + public void GetProjectilesLockedOnPos(MyEntity victim, ICollection collection) => + _getProjectilesLockedOnPos?.Invoke(victim, collection); + public void GetSortedThreats(MyEntity shooter, ICollection> collection) => + _getSortedThreats?.Invoke(shooter, collection); + public void GetObstructions(MyEntity shooter, ICollection collection) => + _getObstructions?.Invoke(shooter, collection); + public MyEntity GetAiFocus(MyEntity shooter, int priority = 0) => _getAiFocus?.Invoke(shooter, priority); + public bool SetAiFocus(MyEntity shooter, MyEntity target, int priority = 0) => + _setAiFocus?.Invoke(shooter, target, priority) ?? false; + public bool ReleaseAiFocus(MyEntity shooter, long playerId) => + _releaseAiFocus?.Invoke(shooter, playerId) ?? false; + public MyTuple GetWeaponTarget(MyEntity weapon, int weaponId = 0) => + _getWeaponTarget?.Invoke(weapon, weaponId) ?? new MyTuple(); + public float GetMaxPower(MyDefinitionId weaponDef) => _getMaxPower?.Invoke(weaponDef) ?? 0f; + public bool HasAi(MyEntity entity) => _hasAi?.Invoke(entity) ?? false; + public float GetOptimalDps(MyEntity entity) => _getOptimalDps?.Invoke(entity) ?? 0f; + public MyTuple GetProjectileState(ulong projectileId) => + _getProjectileState?.Invoke(projectileId) ?? new MyTuple(); + + public float GetConstructEffectiveDps(MyEntity entity) => _getConstructEffectiveDps?.Invoke(entity) ?? 0f; + public MyTuple GetWeaponScope(MyEntity weapon, int weaponId) => + _getWeaponScope?.Invoke(weapon, weaponId) ?? new MyTuple(); + + public void AddProjectileCallback(MyEntity entity, int weaponId, Action action) => + _addProjectileMonitor?.Invoke(entity, weaponId, action); + + public void RemoveProjectileCallback(MyEntity entity, int weaponId, Action action) => + _removeProjectileMonitor?.Invoke(entity, weaponId, action); + + + // block/grid/player, Threat, Other + public MyTuple IsInRange(MyEntity entity) => + _isInRange?.Invoke(entity) ?? new MyTuple(); + + /// + /// Set projectile values *Warning* be sure to pass in Vector3D.MinValue or float.MinValue to NOT set that value. + /// bool = EndNow + /// Vector3D Position + /// Vector3D Additive velocity + /// float BaseDamagePool + /// + /// + /// + public void SetProjectileState(ulong projectileId, MyTuple values) => + _setProjectileState?.Invoke(projectileId, values); + + /// + /// Gets whether the weapon is shooting, used by Hakerman's Beam Logic + /// Unexpected behavior may occur when using this method + /// + /// + /// + /// + internal bool IsWeaponShooting(MyEntity weaponBlock, int weaponId) => _isWeaponShooting?.Invoke(weaponBlock, weaponId) ?? false; + + /// + /// Gets how many shots the weapon fired, used by Hakerman's Beam Logic + /// Unexpected behavior may occur when using this method + /// + /// + /// + /// + internal int GetShotsFired(MyEntity weaponBlock, int weaponId) => _getShotsFired?.Invoke(weaponBlock, weaponId) ?? -1; + + /// + /// Gets the info of the weapon's all muzzles, used by Hakerman's Beam Logic + /// returns: A list that contains every muzzle's Position, LocalPosition, Direction, UpDirection, ParentMatrix, DummyMatrix + /// Unexpected behavior may occur when using this method + /// + /// + /// + /// + internal void GetMuzzleInfo(MyEntity weaponBlock, int weaponId, List> output) => + _getMuzzleInfo?.Invoke(weaponBlock, weaponId, output); + + /// + /// Entity can be a weapon or a grid/player (enables on all subgrids as well) + /// + /// + /// + public bool ToggleInfiniteResources(MyEntity entity) => + _toggoleInfiniteResources?.Invoke(entity) ?? false; + + /// + /// Monitor various kind of events, see WcApiDef.WeaponDefinition.AnimationDef.PartAnimationSetDef.EventTriggers for int mapping, bool is for active/inactive + /// + /// + /// + /// + /// + public void MonitorEvents(MyEntity entity, int partId, Action action) => + _monitorEvents?.Invoke(entity, partId, action); + + /// + /// Monitor various kind of events, see WcApiDef.WeaponDefinition.AnimationDef.PartAnimationSetDef.EventTriggers for int mapping, bool is for active/inactive + /// + /// + /// + /// + /// + public void UnMonitorEvents(MyEntity entity, int partId, Action action) => + _unmonitorEvents?.Invoke(entity, partId, action); + + /// + /// Monitor all weaponcore damage + /// + /// + /// 0 unregister, 1 register + /// object casts (ulong = projectileId, IMySlimBlock, MyFloatingObject, IMyCharacter, MyVoxelBase, MyPlanet, MyEntity Shield see next line) + /// You can detect the shield entity in a performant way by creating a hash check ShieldHash = MyStringHash.GetOrCompute("DefenseShield"); + /// then use it by Session.ShieldApiLoaded && Session.ShieldHash == ent.DefinitionId?.SubtypeId && ent.Render.Visible; Visible means shield online + public void RegisterDamageEvent(long modId, int type, Action>>>> callback) + { + _registerDamageEvent?.Invoke(modId, type, callback); + } + + /// + /// This allows you to determine when and if a player can modify the current target focus on a player/grid/phantonm. Use only on server + /// + /// is the player/grid/phantom you want to control the target focus for, applies to subgrids as well + /// be sure to unregister when you no longer want to receive callbacks + public void TargetFocushandler(long handledEntityId, bool unregister) + { + _targetFocusHandler(handledEntityId, unregister, TargetFocusCallback); + } + + /// + /// This callback fires whenever a player attempts to modify the target focus + /// + /// + /// + /// + /// + /// + private bool TargetFocusCallback(MyEntity target, IMyCharacter requestingCharacter, long handledEntityId, int modeCode) + { + var mode = (ChangeMode)modeCode; + + return true; + } + + public enum ChangeMode + { + Add, + Release, + Lock, + } + /// + /// Enables you to allow/deny hud draw requests. Do not use this on dedicated server. + /// + /// + /// + public void Hudhandler(long handledEntityId, bool unregister) + { + _hudHandler?.Invoke(handledEntityId, unregister, HudCallback); + } + + /// + /// This callback fires whenever the hud tries to update + /// + /// + /// + /// + /// + private bool HudCallback(IMyCharacter requestingCharacter, long handledEntityId, int modeCode) + { + var mode = (HudMode)modeCode; + + return true; + } + + internal enum HudMode + { + Selector, + Reload, + TargetInfo, + Lead, + Drone, + PainterMarks, + } + + /// + /// + /// + /// + /// MyEntity, ulong (projectile) or Vector3D + /// Most weapons have only id 0, but some are multi-weapon entities + /// + /// + public bool ShootRequest(MyEntity weaponEntity, object target, int weaponId = 0, double additionalDeviateShotAngle = 0) => _shootRequest?.Invoke(weaponEntity, target, weaponId, additionalDeviateShotAngle) ?? false; + + /// + /// Enables you to monitor and approve shoot requests for this weapon/construct/player/grid network + /// + /// + /// + /// + public void ShootRequestHandler(long handledEntityId, bool unregister, Func callback) + { + _shootHandler?.Invoke(handledEntityId, unregister, callback); // see example callback below + } + + /// + /// This callback fires whenever a shoot request is being evaluated for against a success criteria or is pending some action + /// + /// + /// + /// This is the state of your request, state 0 means proceeding as requested + /// This is false if wc thinks the target is occluded, you can choose to allow it to proceed anyway or not + /// valid objects to cast too are MyEntity, ulong (projectile ids) and target Vector3Ds + /// + /// + /// The number of times this callback will fire will depend on the relevant firing stages for this weapon/ammo and how far it gets + /// + private bool ShootCallBack(Vector3D scopePos, Vector3D scopeDirection, int requestState, bool hasLos, object target, int currentAmmo, int remainingMags, int requestStage) + { + var stage = (EventTriggers)requestStage; + var state = (ShootState)requestState; + var targetAsEntity = target as MyEntity; + var targetAsProjectileId = target as ulong? ?? 0; + var targetAsPosition = target as Vector3D? ?? Vector3D.Zero; + + return true; + } + + public enum ShootState + { + EventStart, + EventEnd, + Preceding, + Canceled, + } + + public enum EventTriggers + { + Reloading, + Firing, + Tracking, + Overheated, + TurnOn, + TurnOff, + BurstReload, + NoMagsToLoad, + PreFire, + EmptyOnGameLoad, + StopFiring, + StopTracking, + LockDelay, + Init, + Homing, + TargetAligned, + WhileOn, + TargetRanged100, + TargetRanged75, + TargetRanged50, + TargetRanged25, + } + + /// + /// Get active ammo Mag map from weapon + /// + /// + /// + /// Mag definitionId, mag name, ammoRound name, weapon must aim (not manual aim) true/false + public MyTuple GetMagazineMap(MyEntity weapon, int weaponId) + { + return _getMagazineMap?.Invoke(weapon, weaponId) ?? new MyTuple(); + } + + /// + /// Set the active ammo type via passing Mag DefinitionId + /// + /// + /// + /// + /// + /// + public bool SetMagazine(MyEntity weapon, int weaponId, MyDefinitionId id, bool forceReload) + { + return _setMagazine?.Invoke(weapon, weaponId, id, forceReload) ?? false; + + } + + /// + /// + /// + /// + /// + /// + public bool ForceReload(MyEntity weapon, int weaponId) + { + return _forceReload?.Invoke(weapon, weaponId) ?? false; + + } + + private const long Channel = 67549756549; + private bool _getWeaponDefinitions; + private bool _isRegistered; + private Action _readyCallback; + + /// + /// True if CoreSystems replied when got called. + /// + public bool IsReady { get; private set; } + + /// + /// Only filled if giving true to . + /// + public readonly List WeaponDefinitions = new List(); + + /// + /// Ask CoreSystems to send the API methods. + /// Throws an exception if it gets called more than once per session without . + /// + /// Method to be called when CoreSystems replies. + /// Set to true to fill . + public void Load(Action readyCallback = null, bool getWeaponDefinitions = false) + { + if (_isRegistered) + throw new Exception($"{GetType().Name}.Load() should not be called multiple times!"); + + _readyCallback = readyCallback; + _getWeaponDefinitions = getWeaponDefinitions; + _isRegistered = true; + MyAPIGateway.Utilities.RegisterMessageHandler(Channel, HandleMessage); + MyAPIGateway.Utilities.SendModMessage(Channel, "ApiEndpointRequest"); + } + + public void Unload() + { + MyAPIGateway.Utilities.UnregisterMessageHandler(Channel, HandleMessage); + + ApiAssign(null); + + _isRegistered = false; + _apiInit = false; + IsReady = false; + } + + private void HandleMessage(object obj) + { + if (_apiInit || obj is string + ) // the sent "ApiEndpointRequest" will also be received here, explicitly ignoring that + return; + + var dict = obj as IReadOnlyDictionary; + + if (dict == null) + return; + + ApiAssign(dict, _getWeaponDefinitions); + + IsReady = true; + _readyCallback?.Invoke(); + } + + public void ApiAssign(IReadOnlyDictionary delegates, bool getWeaponDefinitions = false) + { + _apiInit = (delegates != null); + /// base methods + + AssignMethod(delegates, "SetRofMultiplier", ref _setRofMultiplier); + AssignMethod(delegates, "SetBaseDmgMultiplier", ref _setBaseDmgMultiplier); + AssignMethod(delegates, "SetAreaDmgMultiplier", ref _setAreaDmgMultiplier); + AssignMethod(delegates, "SetAreaRadiusMultiplier", ref _setAreaRadiusMultiplier); + AssignMethod(delegates, "SetVelocityMultiplier", ref _setVelocityMultiplier); + AssignMethod(delegates, "SetFiringAllowed", ref _setFiringAllowed); + AssignMethod(delegates, "RegisterTerminalControl", ref _registerTerminalControl); + + AssignMethod(delegates, "GetRofMultiplier", ref _getRofMultiplier); + AssignMethod(delegates, "GetBaseDmgMultiplier", ref _getBaseDmgMultiplier); + AssignMethod(delegates, "GetAreaDmgMultiplier", ref _getAreaDmgMultiplier); + AssignMethod(delegates, "GetAreaRadiusMultiplier", ref _getAreaRadiusMultiplier); + AssignMethod(delegates, "GetVelocityMultiplier", ref _getVelocityMultiplier); + AssignMethod(delegates, "GetFiringAllowed", ref _getFiringAllowed); + + AssignMethod(delegates, "GetAllWeaponDefinitions", ref _getAllWeaponDefinitions); + AssignMethod(delegates, "GetCoreWeapons", ref _getCoreWeapons); + AssignMethod(delegates, "GetNpcSafeWeapons", ref _getNpcSafeWeapons); + + AssignMethod(delegates, "GetAllWeaponMagazines", ref _getAllWeaponMagazines); + AssignMethod(delegates, "GetAllNpcSafeWeaponMagazines", ref _getAllNpcSafeWeaponMagazines); + + AssignMethod(delegates, "GetCoreStaticLaunchers", ref _getCoreStaticLaunchers); + AssignMethod(delegates, "GetCoreTurrets", ref _getCoreTurrets); + AssignMethod(delegates, "GetCorePhantoms", ref _getCorePhantoms); + AssignMethod(delegates, "GetCoreRifles", ref _getCoreRifles); + AssignMethod(delegates, "GetCoreArmors", ref _getCoreArmors); + + AssignMethod(delegates, "GetBlockWeaponMap", ref _getBlockWeaponMap); + AssignMethod(delegates, "GetSortedThreatsBase", ref _getSortedThreats); + AssignMethod(delegates, "GetObstructionsBase", ref _getObstructions); + AssignMethod(delegates, "GetMaxPower", ref _getMaxPower); + AssignMethod(delegates, "GetProjectilesLockedOnBase", ref _getProjectilesLockedOn); + AssignMethod(delegates, "GetProjectilesLockedOnPos", ref _getProjectilesLockedOnPos); + AssignMethod(delegates, "GetAiFocusBase", ref _getAiFocus); + AssignMethod(delegates, "SetAiFocusBase", ref _setAiFocus); + AssignMethod(delegates, "ReleaseAiFocusBase", ref _releaseAiFocus); + AssignMethod(delegates, "HasGridAiBase", ref _hasAi); + AssignMethod(delegates, "GetOptimalDpsBase", ref _getOptimalDps); + AssignMethod(delegates, "GetConstructEffectiveDpsBase", ref _getConstructEffectiveDps); + AssignMethod(delegates, "IsInRangeBase", ref _isInRange); + AssignMethod(delegates, "GetProjectileState", ref _getProjectileState); + AssignMethod(delegates, "SetProjectileState", ref _setProjectileState); + + AssignMethod(delegates, "AddMonitorProjectile", ref _addProjectileMonitor); + AssignMethod(delegates, "RemoveMonitorProjectile", ref _removeProjectileMonitor); + + AssignMethod(delegates, "TargetFocusHandler", ref _targetFocusHandler); + AssignMethod(delegates, "HudHandler", ref _hudHandler); + AssignMethod(delegates, "ShootHandler", ref _shootHandler); + AssignMethod(delegates, "ShootRequest", ref _shootRequest); + + /// block methods + AssignMethod(delegates, "GetWeaponTargetBase", ref _getWeaponTarget); + AssignMethod(delegates, "SetWeaponTargetBase", ref _setWeaponTarget); + AssignMethod(delegates, "FireWeaponOnceBase", ref _fireWeaponOnce); + AssignMethod(delegates, "ToggleWeaponFireBase", ref _toggleWeaponFire); + AssignMethod(delegates, "IsWeaponReadyToFireBase", ref _isWeaponReadyToFire); + AssignMethod(delegates, "GetMaxWeaponRangeBase", ref _getMaxWeaponRange); + AssignMethod(delegates, "GetTurretTargetTypesBase", ref _getTurretTargetTypes); + AssignMethod(delegates, "SetTurretTargetTypesBase", ref _setTurretTargetTypes); + AssignMethod(delegates, "SetBlockTrackingRangeBase", ref _setBlockTrackingRange); + AssignMethod(delegates, "IsTargetAlignedBase", ref _isTargetAligned); + AssignMethod(delegates, "IsTargetAlignedExtendedBase", ref _isTargetAlignedExtended); + AssignMethod(delegates, "CanShootTargetBase", ref _canShootTarget); + AssignMethod(delegates, "GetPredictedTargetPositionBase", ref _getPredictedTargetPos); + AssignMethod(delegates, "GetHeatLevelBase", ref _getHeatLevel); + AssignMethod(delegates, "GetCurrentPowerBase", ref _currentPowerConsumption); + AssignMethod(delegates, "DisableRequiredPowerBase", ref _disableRequiredPower); + AssignMethod(delegates, "HasCoreWeaponBase", ref _hasCoreWeapon); + AssignMethod(delegates, "GetActiveAmmoBase", ref _getActiveAmmo); + AssignMethod(delegates, "SetActiveAmmoBase", ref _setActiveAmmo); + AssignMethod(delegates, "GetPlayerControllerBase", ref _getPlayerController); + AssignMethod(delegates, "GetWeaponAzimuthMatrixBase", ref _getWeaponAzimuthMatrix); + AssignMethod(delegates, "GetWeaponElevationMatrixBase", ref _getWeaponElevationMatrix); + AssignMethod(delegates, "IsTargetValidBase", ref _isTargetValid); + AssignMethod(delegates, "GetWeaponScopeBase", ref _getWeaponScope); + + //Phantom methods + AssignMethod(delegates, "GetTargetAssessment", ref _getTargetAssessment); + //AssignMethod(delegates, "GetPhantomInfo", ref _getPhantomInfo); + AssignMethod(delegates, "SetTriggerState", ref _setTriggerState); + AssignMethod(delegates, "AddMagazines", ref _addMagazines); + AssignMethod(delegates, "SetAmmo", ref _setAmmo); + AssignMethod(delegates, "ClosePhantom", ref _closePhantom); + AssignMethod(delegates, "SpawnPhantom", ref _spawnPhantom); + AssignMethod(delegates, "SetFocusTarget", ref _setPhantomFocusTarget); + + //Hakerman's Beam Logic + AssignMethod(delegates, "IsWeaponShootingBase", ref _isWeaponShooting); + AssignMethod(delegates, "GetShotsFiredBase", ref _getShotsFired); + AssignMethod(delegates, "GetMuzzleInfoBase", ref _getMuzzleInfo); + AssignMethod(delegates, "ToggleInfiniteAmmoBase", ref _toggoleInfiniteResources); + AssignMethod(delegates, "RegisterEventMonitor", ref _monitorEvents); + AssignMethod(delegates, "UnRegisterEventMonitor", ref _unmonitorEvents); + AssignMethod(delegates, "GetMagazineMap", ref _getMagazineMap); + + AssignMethod(delegates, "SetMagazine", ref _setMagazine); + AssignMethod(delegates, "ForceReload", ref _forceReload); + + // Damage handler + AssignMethod(delegates, "DamageHandler", ref _registerDamageEvent); + + if (getWeaponDefinitions) + { + var byteArrays = new List(); + GetAllWeaponDefinitions(byteArrays); + foreach (var byteArray in byteArrays) + WeaponDefinitions.Add(MyAPIGateway.Utilities.SerializeFromBinary(byteArray)); + } + } + + private void AssignMethod(IReadOnlyDictionary delegates, string name, ref T field) + where T : class + { + if (delegates == null) + { + field = null; + return; + } + + Delegate del; + if (!delegates.TryGetValue(name, out del)) + throw new Exception($"{GetType().Name} :: Couldn't find {name} delegate of type {typeof(T)}"); + + field = del as T; + + if (field == null) + throw new Exception( + $"{GetType().Name} :: Delegate {name} is not type {typeof(T)}, instead it's: {del.GetType()}"); + } + + public class DamageHandlerHelper + { + public void YourCallBackFunction(List list) + { + // Your code goes here + // + // Once this function completes the data in the list will be deleted... if you need to use the data in this list + // after this function completes make a copy of it. + // + // This is setup to be easy to use. If you need more performance modify the Default Callback for your purposes and avoid + // copying callbacks into new lists with ProjectileDamageEvent structs. Note that the ListReader will remain usable for only 1 tick, then it will be cleared by wc. + // + } + + + /// Don't touch anything below this line + public void RegisterForDamage(long modId, EventType type) + { + _wcApi.RegisterDamageEvent(modId, (int)type, DefaultCallBack); + } + + private void DefaultCallBack(ListReader>>> listReader) + { + YourCallBackFunction(ProcessEvents(listReader)); + CleanUpEvents(); + } + + private readonly List _convertedObjects = new List(); + private readonly Stack> _hitPool = new Stack>(256); + + private List ProcessEvents(ListReader>>> projectiles) + { + foreach (var p in projectiles) + { + var hits = _hitPool.Count > 0 ? _hitPool.Pop() : new List(); + + foreach (var hitObj in p.Item6) + { + hits.Add(new ProjectileDamageEvent.ProHit { HitPosition = hitObj.Item1, ObjectHit = hitObj.Item2, Damage = hitObj.Item3 }); + } + _convertedObjects.Add(new ProjectileDamageEvent { ProId = p.Item1, PlayerId = p.Item2, WeaponId = p.Item3, WeaponEntity = p.Item4, WeaponParent = p.Item5, ObjectsHit = hits }); + } + + return _convertedObjects; + } + + private void CleanUpEvents() + { + foreach (var p in _convertedObjects) + { + p.ObjectsHit.Clear(); + _hitPool.Push(p.ObjectsHit); + } + _convertedObjects.Clear(); + } + + public struct ProjectileDamageEvent + { + public ulong ProId; + public long PlayerId; + public int WeaponId; + public MyEntity WeaponEntity; + public MyEntity WeaponParent; + public List ObjectsHit; + + public struct ProHit + { + public Vector3D HitPosition; // To == first hit, From = projectile start position this frame + public object ObjectHit; // block, player, etc... + public float Damage; + } + } + + + private readonly WcApi _wcApi; + public DamageHandlerHelper(WcApi wcApi) + { + _wcApi = wcApi; + } + + public enum EventType + { + Unregister, + SystemWideDamageEvents, + } + } + + } + +} \ No newline at end of file diff --git a/Utility Mods/Stable/GyroscopicGunsight/Data/Scripts/GyroscopicGunsight/API/CoreSystems/CoreSystemsApiBlocks.cs b/Utility Mods/Stable/GyroscopicGunsight/Data/Scripts/GyroscopicGunsight/API/CoreSystems/CoreSystemsApiBlocks.cs new file mode 100644 index 000000000..5ddf1452a --- /dev/null +++ b/Utility Mods/Stable/GyroscopicGunsight/Data/Scripts/GyroscopicGunsight/API/CoreSystems/CoreSystemsApiBlocks.cs @@ -0,0 +1,17 @@ +using System; +using System.Collections.Generic; +using Sandbox.ModAPI; + +namespace SC.GyroscopicGunsight.API.CoreSystems +{ + /// + /// https://github.com/sstixrud/CoreSystems/blob/master/BaseData/Scripts/CoreSystems/Api/CoreSystemsApiBlocks.cs + /// + public partial class WcApi + { + private Func, bool> _getBlockWeaponMap; + + public bool GetBlockWeaponMap(IMyTerminalBlock weaponBlock, IDictionary collection) => + _getBlockWeaponMap?.Invoke(weaponBlock, collection) ?? false; + } +} diff --git a/Utility Mods/Stable/GyroscopicGunsight/Data/Scripts/GyroscopicGunsight/API/CoreSystems/CoreSystemsApiDefs.cs b/Utility Mods/Stable/GyroscopicGunsight/Data/Scripts/GyroscopicGunsight/API/CoreSystems/CoreSystemsApiDefs.cs new file mode 100644 index 000000000..931c59e32 --- /dev/null +++ b/Utility Mods/Stable/GyroscopicGunsight/Data/Scripts/GyroscopicGunsight/API/CoreSystems/CoreSystemsApiDefs.cs @@ -0,0 +1,1538 @@ +using System.Collections.Generic; +using ProtoBuf; +using VRageMath; + +namespace SC.GyroscopicGunsight.API.CoreSystems +{ + public static class WcApiDef + { + [ProtoContract] + public class ContainerDefinition + { + [ProtoMember(1)] internal WeaponDefinition[] WeaponDefs; + [ProtoMember(2)] internal ArmorDefinition[] ArmorDefs; + [ProtoMember(3)] internal UpgradeDefinition[] UpgradeDefs; + [ProtoMember(4)] internal SupportDefinition[] SupportDefs; + } + + [ProtoContract] + public class ConsumeableDef + { + [ProtoMember(1)] internal string ItemName; + [ProtoMember(2)] internal string InventoryItem; + [ProtoMember(3)] internal int ItemsNeeded; + [ProtoMember(4)] internal bool Hybrid; + [ProtoMember(5)] internal float EnergyCost; + [ProtoMember(6)] internal float Strength; + } + + [ProtoContract] + public class UpgradeDefinition + { + [ProtoMember(1)] internal ModelAssignmentsDef Assignments; + [ProtoMember(2)] internal HardPointDef HardPoint; + [ProtoMember(3)] internal WeaponDefinition.AnimationDef Animations; + [ProtoMember(4)] internal string ModPath; + [ProtoMember(5)] internal ConsumeableDef[] Consumable; + + [ProtoContract] + public struct ModelAssignmentsDef + { + [ProtoMember(1)] internal MountPointDef[] MountPoints; + + [ProtoContract] + public struct MountPointDef + { + [ProtoMember(1)] internal string SubtypeId; + [ProtoMember(2)] internal float DurabilityMod; + [ProtoMember(3)] internal string IconName; + } + } + + [ProtoContract] + public struct HardPointDef + { + [ProtoMember(1)] internal string PartName; + [ProtoMember(2)] internal HardwareDef HardWare; + [ProtoMember(3)] internal UiDef Ui; + [ProtoMember(4)] internal OtherDef Other; + + [ProtoContract] + public struct UiDef + { + [ProtoMember(1)] internal bool StrengthModifier; + } + + [ProtoContract] + public struct HardwareDef + { + public enum HardwareType + { + Default, + } + + [ProtoMember(1)] internal float InventorySize; + [ProtoMember(2)] internal HardwareType Type; + [ProtoMember(3)] internal int BlockDistance; + + } + + [ProtoContract] + public struct OtherDef + { + [ProtoMember(1)] internal int ConstructPartCap; + [ProtoMember(2)] internal int EnergyPriority; + [ProtoMember(3)] internal bool Debug; + [ProtoMember(4)] internal double RestrictionRadius; + [ProtoMember(5)] internal bool CheckInflatedBox; + [ProtoMember(6)] internal bool CheckForAnySupport; + [ProtoMember(7)] internal bool StayCharged; + } + } + } + + [ProtoContract] + public class SupportDefinition + { + [ProtoMember(1)] internal ModelAssignmentsDef Assignments; + [ProtoMember(2)] internal HardPointDef HardPoint; + [ProtoMember(3)] internal WeaponDefinition.AnimationDef Animations; + [ProtoMember(4)] internal string ModPath; + [ProtoMember(5)] internal ConsumeableDef[] Consumable; + [ProtoMember(6)] internal SupportEffect Effect; + + [ProtoContract] + public struct ModelAssignmentsDef + { + [ProtoMember(1)] internal MountPointDef[] MountPoints; + + [ProtoContract] + public struct MountPointDef + { + [ProtoMember(1)] internal string SubtypeId; + [ProtoMember(2)] internal float DurabilityMod; + [ProtoMember(3)] internal string IconName; + } + } + [ProtoContract] + public struct HardPointDef + { + [ProtoMember(1)] internal string PartName; + [ProtoMember(2)] internal HardwareDef HardWare; + [ProtoMember(3)] internal UiDef Ui; + [ProtoMember(4)] internal OtherDef Other; + + [ProtoContract] + public struct UiDef + { + [ProtoMember(1)] internal bool ProtectionControl; + } + + [ProtoContract] + public struct HardwareDef + { + [ProtoMember(1)] internal float InventorySize; + } + + [ProtoContract] + public struct OtherDef + { + [ProtoMember(1)] internal int ConstructPartCap; + [ProtoMember(2)] internal int EnergyPriority; + [ProtoMember(3)] internal bool Debug; + [ProtoMember(4)] internal double RestrictionRadius; + [ProtoMember(5)] internal bool CheckInflatedBox; + [ProtoMember(6)] internal bool CheckForAnySupport; + [ProtoMember(7)] internal bool StayCharged; + } + } + + [ProtoContract] + public struct SupportEffect + { + public enum AffectedBlocks + { + Armor, + ArmorPlus, + PlusFunctional, + All, + } + + public enum Protections + { + KineticProt, + EnergeticProt, + GenericProt, + Regenerate, + Structural, + } + + [ProtoMember(1)] internal Protections Protection; + [ProtoMember(2)] internal AffectedBlocks Affected; + [ProtoMember(3)] internal int BlockRange; + [ProtoMember(4)] internal int MaxPoints; + [ProtoMember(5)] internal int PointsPerCharge; + [ProtoMember(6)] internal int UsablePerSecond; + [ProtoMember(7)] internal int UsablePerMinute; + [ProtoMember(8)] internal float Overflow; + [ProtoMember(9)] internal float Effectiveness; + [ProtoMember(10)] internal float ProtectionMin; + [ProtoMember(11)] internal float ProtectionMax; + } + } + + [ProtoContract] + public class ArmorDefinition + { + internal enum ArmorType + { + Light, + Heavy, + NonArmor, + } + + [ProtoMember(1)] internal string[] SubtypeIds; + [ProtoMember(2)] internal ArmorType Kind; + [ProtoMember(3)] internal double KineticResistance; + [ProtoMember(4)] internal double EnergeticResistance; + } + + [ProtoContract] + public class WeaponDefinition + { + [ProtoMember(1)] internal ModelAssignmentsDef Assignments; + [ProtoMember(2)] internal TargetingDef Targeting; + [ProtoMember(3)] internal AnimationDef Animations; + [ProtoMember(4)] internal HardPointDef HardPoint; + [ProtoMember(5)] internal AmmoDef[] Ammos; + [ProtoMember(6)] internal string ModPath; + [ProtoMember(7)] internal Dictionary Upgrades; + + [ProtoContract] + public struct ModelAssignmentsDef + { + [ProtoMember(1)] internal MountPointDef[] MountPoints; + [ProtoMember(2)] internal string[] Muzzles; + [ProtoMember(3)] internal string Ejector; + [ProtoMember(4)] internal string Scope; + + [ProtoContract] + public struct MountPointDef + { + [ProtoMember(1)] internal string SubtypeId; + [ProtoMember(2)] internal string SpinPartId; + [ProtoMember(3)] internal string MuzzlePartId; + [ProtoMember(4)] internal string AzimuthPartId; + [ProtoMember(5)] internal string ElevationPartId; + [ProtoMember(6)] internal float DurabilityMod; + [ProtoMember(7)] internal string IconName; + } + } + + [ProtoContract] + public struct TargetingDef + { + public enum Threat + { + Projectiles, + Characters, + Grids, + Neutrals, + Meteors, + Other, + ScanNeutralGrid, + ScanFriendlyGrid, + ScanFriendlyCharacter, + ScanRoid, + ScanPlanet, + ScanEnemyCharacter, + ScanEnemyGrid, + ScanNeutralCharacter, + ScanUnOwnedGrid, + ScanOwnersGrid + } + + public enum BlockTypes + { + Any, + Offense, + Utility, + Power, + Production, + Thrust, + Jumping, + Steering + } + + [ProtoMember(1)] internal int TopTargets; + [ProtoMember(2)] internal int TopBlocks; + [ProtoMember(3)] internal double StopTrackingSpeed; + [ProtoMember(4)] internal float MinimumDiameter; + [ProtoMember(5)] internal float MaximumDiameter; + [ProtoMember(6)] internal bool ClosestFirst; + [ProtoMember(7)] internal BlockTypes[] SubSystems; + [ProtoMember(8)] internal Threat[] Threats; + [ProtoMember(9)] internal float MaxTargetDistance; + [ProtoMember(10)] internal float MinTargetDistance; + [ProtoMember(11)] internal bool IgnoreDumbProjectiles; + [ProtoMember(12)] internal bool LockedSmartOnly; + [ProtoMember(13)] internal bool UniqueTargetPerWeapon; + [ProtoMember(14)] internal int MaxTrackingTime; + [ProtoMember(15)] internal bool ShootBlanks; + [ProtoMember(19)] internal CommunicationDef Communications; + [ProtoMember(20)] internal bool FocusOnly; + [ProtoMember(21)] internal bool EvictUniqueTargets; + [ProtoMember(22)] internal int CycleTargets; + [ProtoMember(23)] internal int CycleBlocks; + + [ProtoContract] + public struct CommunicationDef + { + public enum Comms + { + NoComms, + BroadCast, + Relay, + Jamming, + RelayAndBroadCast, + } + + public enum SecurityMode + { + Public, + Private, + Secure, + } + + [ProtoMember(1)] internal bool StoreTargets; + [ProtoMember(2)] internal int StorageLimit; + [ProtoMember(3)] internal string StorageLocation; + [ProtoMember(4)] internal Comms Mode; + [ProtoMember(5)] internal SecurityMode Security; + [ProtoMember(6)] internal string BroadCastChannel; + [ProtoMember(7)] internal double BroadCastRange; + [ProtoMember(8)] internal double JammingStrength; + [ProtoMember(9)] internal string RelayChannel; + [ProtoMember(10)] internal double RelayRange; + [ProtoMember(11)] internal bool TargetPersists; + [ProtoMember(12)] internal bool StoreLimitPerBlock; + [ProtoMember(13)] internal int MaxConnections; + } + } + + + [ProtoContract] + public struct AnimationDef + { + [ProtoMember(1)] internal PartAnimationSetDef[] AnimationSets; + [ProtoMember(2)] internal PartEmissive[] Emissives; + [ProtoMember(3)] internal string[] HeatingEmissiveParts; + [ProtoMember(4)] internal Dictionary EventParticles; + + [ProtoContract(IgnoreListHandling = true)] + public struct PartAnimationSetDef + { + public enum EventTriggers + { + Reloading, + Firing, + Tracking, + Overheated, + TurnOn, + TurnOff, + BurstReload, + NoMagsToLoad, + PreFire, + EmptyOnGameLoad, + StopFiring, + StopTracking, + LockDelay, + } + + public enum ResetConditions + { + None, + Home, + Off, + On, + Reloaded + } + + [ProtoMember(1)] internal string[] SubpartId; + [ProtoMember(2)] internal string BarrelId; + [ProtoMember(3)] internal uint StartupFireDelay; + [ProtoMember(4)] internal Dictionary AnimationDelays; + [ProtoMember(5)] internal EventTriggers[] Reverse; + [ProtoMember(6)] internal EventTriggers[] Loop; + [ProtoMember(7)] internal Dictionary EventMoveSets; + [ProtoMember(8)] internal EventTriggers[] TriggerOnce; + [ProtoMember(9)] internal EventTriggers[] ResetEmissives; + [ProtoMember(10)] internal ResetConditions Resets; + + } + + [ProtoContract] + public struct PartEmissive + { + [ProtoMember(1)] internal string EmissiveName; + [ProtoMember(2)] internal string[] EmissivePartNames; + [ProtoMember(3)] internal bool CycleEmissivesParts; + [ProtoMember(4)] internal bool LeavePreviousOn; + [ProtoMember(5)] internal Vector4[] Colors; + [ProtoMember(6)] internal float[] IntensityRange; + } + [ProtoContract] + public struct EventParticle + { + [ProtoMember(1)] internal string[] EmptyNames; + [ProtoMember(2)] internal string[] MuzzleNames; + [ProtoMember(3)] internal ParticleDef Particle; + [ProtoMember(4)] internal uint StartDelay; + [ProtoMember(5)] internal uint LoopDelay; + [ProtoMember(6)] internal bool ForceStop; + } + [ProtoContract] + internal struct RelMove + { + public enum MoveType + { + Linear, + ExpoDecay, + ExpoGrowth, + Delay, + Show, //instant or fade + Hide, //instant or fade + } + + [ProtoMember(1)] internal MoveType MovementType; + [ProtoMember(2)] internal XYZ[] LinearPoints; + [ProtoMember(3)] internal XYZ Rotation; + [ProtoMember(4)] internal XYZ RotAroundCenter; + [ProtoMember(5)] internal uint TicksToMove; + [ProtoMember(6)] internal string CenterEmpty; + [ProtoMember(7)] internal bool Fade; + [ProtoMember(8)] internal string EmissiveName; + + [ProtoContract] + internal struct XYZ + { + [ProtoMember(1)] internal double x; + [ProtoMember(2)] internal double y; + [ProtoMember(3)] internal double z; + } + } + } + + [ProtoContract] + public struct UpgradeValues + { + [ProtoMember(1)] internal string[] Ammo; + [ProtoMember(2)] internal Dependency[] Dependencies; + [ProtoMember(3)] internal int RateOfFireMod; + [ProtoMember(4)] internal int BarrelsPerShotMod; + [ProtoMember(5)] internal int ReloadMod; + [ProtoMember(6)] internal int MaxHeatMod; + [ProtoMember(7)] internal int HeatSinkRateMod; + [ProtoMember(8)] internal int ShotsInBurstMod; + [ProtoMember(9)] internal int DelayAfterBurstMod; + [ProtoMember(10)] internal int AmmoPriority; + + [ProtoContract] + public struct Dependency + { + internal string SubtypeId; + internal int Quanity; + } + } + + [ProtoContract] + public struct HardPointDef + { + public enum Prediction + { + Off, + Basic, + Accurate, + Advanced, + } + + [ProtoMember(1)] internal string PartName; + [ProtoMember(2)] internal int DelayCeaseFire; + [ProtoMember(3)] internal float DeviateShotAngle; + [ProtoMember(4)] internal double AimingTolerance; + [ProtoMember(5)] internal Prediction AimLeadingPrediction; + [ProtoMember(6)] internal LoadingDef Loading; + [ProtoMember(7)] internal AiDef Ai; + [ProtoMember(8)] internal HardwareDef HardWare; + [ProtoMember(9)] internal UiDef Ui; + [ProtoMember(10)] internal HardPointAudioDef Audio; + [ProtoMember(11)] internal HardPointParticleDef Graphics; + [ProtoMember(12)] internal OtherDef Other; + [ProtoMember(13)] internal bool AddToleranceToTracking; + [ProtoMember(14)] internal bool CanShootSubmerged; + [ProtoMember(15)] internal bool NpcSafe; + [ProtoMember(16)] internal bool ScanTrackOnly; + + [ProtoContract] + public struct LoadingDef + { + [ProtoMember(1)] internal int ReloadTime; + [ProtoMember(2)] internal int RateOfFire; + [ProtoMember(3)] internal int BarrelsPerShot; + [ProtoMember(4)] internal int SkipBarrels; + [ProtoMember(5)] internal int TrajectilesPerBarrel; + [ProtoMember(6)] internal int HeatPerShot; + [ProtoMember(7)] internal int MaxHeat; + [ProtoMember(8)] internal int HeatSinkRate; + [ProtoMember(9)] internal float Cooldown; + [ProtoMember(10)] internal int DelayUntilFire; + [ProtoMember(11)] internal int ShotsInBurst; + [ProtoMember(12)] internal int DelayAfterBurst; + [ProtoMember(13)] internal bool DegradeRof; + [ProtoMember(14)] internal int BarrelSpinRate; + [ProtoMember(15)] internal bool FireFull; + [ProtoMember(16)] internal bool GiveUpAfter; + [ProtoMember(17)] internal bool DeterministicSpin; + [ProtoMember(18)] internal bool SpinFree; + [ProtoMember(19)] internal bool StayCharged; + [ProtoMember(20)] internal int MagsToLoad; + [ProtoMember(21)] internal int MaxActiveProjectiles; + [ProtoMember(22)] internal int MaxReloads; + [ProtoMember(23)] internal bool GoHomeToReload; + [ProtoMember(24)] internal bool DropTargetUntilLoaded; + } + + + [ProtoContract] + public struct UiDef + { + [ProtoMember(1)] internal bool RateOfFire; + [ProtoMember(2)] internal bool DamageModifier; + [ProtoMember(3)] internal bool ToggleGuidance; + [ProtoMember(4)] internal bool EnableOverload; + [ProtoMember(5)] internal bool AlternateUi; + [ProtoMember(6)] internal bool DisableStatus; + } + + + [ProtoContract] + public struct AiDef + { + [ProtoMember(1)] internal bool TrackTargets; + [ProtoMember(2)] internal bool TurretAttached; + [ProtoMember(3)] internal bool TurretController; + [ProtoMember(4)] internal bool PrimaryTracking; + [ProtoMember(5)] internal bool LockOnFocus; + [ProtoMember(6)] internal bool SuppressFire; + [ProtoMember(7)] internal bool OverrideLeads; + [ProtoMember(8)] internal int DefaultLeadGroup; + [ProtoMember(9)] internal bool TargetGridCenter; + } + + [ProtoContract] + public struct HardwareDef + { + public enum HardwareType + { + BlockWeapon = 0, + HandWeapon = 1, + Phantom = 6, + } + + [ProtoMember(1)] internal float RotateRate; + [ProtoMember(2)] internal float ElevateRate; + [ProtoMember(3)] internal Vector3D Offset; + [ProtoMember(4)] internal bool FixedOffset; + [ProtoMember(5)] internal int MaxAzimuth; + [ProtoMember(6)] internal int MinAzimuth; + [ProtoMember(7)] internal int MaxElevation; + [ProtoMember(8)] internal int MinElevation; + [ProtoMember(9)] internal float InventorySize; + [ProtoMember(10)] internal HardwareType Type; + [ProtoMember(11)] internal int HomeAzimuth; + [ProtoMember(12)] internal int HomeElevation; + [ProtoMember(13)] internal CriticalDef CriticalReaction; + [ProtoMember(14)] internal float IdlePower; + + [ProtoContract] + public struct CriticalDef + { + [ProtoMember(1)] internal bool Enable; + [ProtoMember(2)] internal int DefaultArmedTimer; + [ProtoMember(3)] internal bool PreArmed; + [ProtoMember(4)] internal bool TerminalControls; + [ProtoMember(5)] internal string AmmoRound; + } + } + + [ProtoContract] + public struct HardPointAudioDef + { + [ProtoMember(1)] internal string ReloadSound; + [ProtoMember(2)] internal string NoAmmoSound; + [ProtoMember(3)] internal string HardPointRotationSound; + [ProtoMember(4)] internal string BarrelRotationSound; + [ProtoMember(5)] internal string FiringSound; + [ProtoMember(6)] internal bool FiringSoundPerShot; + [ProtoMember(7)] internal string PreFiringSound; + [ProtoMember(8)] internal uint FireSoundEndDelay; + [ProtoMember(9)] internal bool FireSoundNoBurst; + } + + [ProtoContract] + public struct OtherDef + { + [ProtoMember(1)] internal int ConstructPartCap; + [ProtoMember(2)] internal int EnergyPriority; + [ProtoMember(3)] internal int RotateBarrelAxis; + [ProtoMember(4)] internal bool MuzzleCheck; + [ProtoMember(5)] internal bool Debug; + [ProtoMember(6)] internal double RestrictionRadius; + [ProtoMember(7)] internal bool CheckInflatedBox; + [ProtoMember(8)] internal bool CheckForAnyWeapon; + [ProtoMember(9)] internal bool DisableLosCheck; + [ProtoMember(10)] internal bool NoVoxelLosCheck; + } + + [ProtoContract] + public struct HardPointParticleDef + { + [ProtoMember(1)] internal ParticleDef Effect1; + [ProtoMember(2)] internal ParticleDef Effect2; + } + } + + [ProtoContract] + public class AmmoDef + { + [ProtoMember(1)] internal string AmmoMagazine; + [ProtoMember(2)] internal string AmmoRound; + [ProtoMember(3)] internal bool HybridRound; + [ProtoMember(4)] internal float EnergyCost; + [ProtoMember(5)] internal float BaseDamage; + [ProtoMember(6)] internal float Mass; + [ProtoMember(7)] internal float Health; + [ProtoMember(8)] internal float BackKickForce; + [ProtoMember(9)] internal DamageScaleDef DamageScales; + [ProtoMember(10)] internal ShapeDef Shape; + [ProtoMember(11)] internal ObjectsHitDef ObjectsHit; + [ProtoMember(12)] internal TrajectoryDef Trajectory; + [ProtoMember(13)] internal AreaDamageDef AreaEffect; + [ProtoMember(14)] internal BeamDef Beams; + [ProtoMember(15)] internal FragmentDef Fragment; + [ProtoMember(16)] internal GraphicDef AmmoGraphics; + [ProtoMember(17)] internal AmmoAudioDef AmmoAudio; + [ProtoMember(18)] internal bool HardPointUsable; + [ProtoMember(19)] internal PatternDef Pattern; + [ProtoMember(20)] internal int EnergyMagazineSize; + [ProtoMember(21)] internal float DecayPerShot; + [ProtoMember(22)] internal EjectionDef Ejection; + [ProtoMember(23)] internal bool IgnoreWater; + [ProtoMember(24)] internal AreaOfDamageDef AreaOfDamage; + [ProtoMember(25)] internal EwarDef Ewar; + [ProtoMember(26)] internal bool IgnoreVoxels; + [ProtoMember(27)] internal bool Synchronize; + [ProtoMember(28)] internal double HeatModifier; + [ProtoMember(29)] internal bool NpcSafe; + [ProtoMember(30)] internal SynchronizeDef Sync; + [ProtoMember(31)] internal bool NoGridOrArmorScaling; + + [ProtoContract] + public struct SynchronizeDef + { + [ProtoMember(1)] internal bool Full; + [ProtoMember(2)] internal bool PointDefense; + [ProtoMember(3)] internal bool OnHitDeath; + } + + [ProtoContract] + public struct DamageScaleDef + { + + [ProtoMember(1)] internal float MaxIntegrity; + [ProtoMember(2)] internal bool DamageVoxels; + [ProtoMember(3)] internal float Characters; + [ProtoMember(4)] internal bool SelfDamage; + [ProtoMember(5)] internal GridSizeDef Grids; + [ProtoMember(6)] internal ArmorDef Armor; + [ProtoMember(7)] internal CustomScalesDef Custom; + [ProtoMember(8)] internal ShieldDef Shields; + [ProtoMember(9)] internal FallOffDef FallOff; + [ProtoMember(10)] internal double HealthHitModifier; + [ProtoMember(11)] internal double VoxelHitModifier; + [ProtoMember(12)] internal DamageTypes DamageType; + [ProtoMember(13)] internal DeformDef Deform; + + [ProtoContract] + public struct FallOffDef + { + [ProtoMember(1)] internal float Distance; + [ProtoMember(2)] internal float MinMultipler; + } + + [ProtoContract] + public struct GridSizeDef + { + [ProtoMember(1)] internal float Large; + [ProtoMember(2)] internal float Small; + } + + [ProtoContract] + public struct ArmorDef + { + [ProtoMember(1)] internal float Armor; + [ProtoMember(2)] internal float Heavy; + [ProtoMember(3)] internal float Light; + [ProtoMember(4)] internal float NonArmor; + } + + [ProtoContract] + public struct CustomScalesDef + { + internal enum SkipMode + { + NoSkip, + Inclusive, + Exclusive, + } + + [ProtoMember(1)] internal CustomBlocksDef[] Types; + [ProtoMember(2)] internal bool IgnoreAllOthers; + [ProtoMember(3)] internal SkipMode SkipOthers; + } + + [ProtoContract] + public struct DamageTypes + { + internal enum Damage + { + Energy, + Kinetic, + } + + [ProtoMember(1)] internal Damage Base; + [ProtoMember(2)] internal Damage AreaEffect; + [ProtoMember(3)] internal Damage Detonation; + [ProtoMember(4)] internal Damage Shield; + } + + [ProtoContract] + public struct ShieldDef + { + internal enum ShieldType + { + Default, + Heal, + Bypass, + EmpRetired, + } + + [ProtoMember(1)] internal float Modifier; + [ProtoMember(2)] internal ShieldType Type; + [ProtoMember(3)] internal float BypassModifier; + [ProtoMember(4)] internal double HeatModifier; + } + + [ProtoContract] + public struct DeformDef + { + internal enum DeformTypes + { + HitBlock, + AllDamagedBlocks, + NoDeform, + } + + [ProtoMember(1)] internal DeformTypes DeformType; + [ProtoMember(2)] internal int DeformDelay; + } + } + + [ProtoContract] + public struct ShapeDef + { + public enum Shapes + { + LineShape, + SphereShape, + } + + [ProtoMember(1)] internal Shapes Shape; + [ProtoMember(2)] internal double Diameter; + } + + [ProtoContract] + public struct ObjectsHitDef + { + [ProtoMember(1)] internal int MaxObjectsHit; + [ProtoMember(2)] internal bool CountBlocks; + } + + + [ProtoContract] + public struct CustomBlocksDef + { + [ProtoMember(1)] internal string SubTypeId; + [ProtoMember(2)] internal float Modifier; + } + + [ProtoContract] + public struct GraphicDef + { + [ProtoMember(1)] internal bool ShieldHitDraw; + [ProtoMember(2)] internal float VisualProbability; + [ProtoMember(3)] internal string ModelName; + [ProtoMember(4)] internal AmmoParticleDef Particles; + [ProtoMember(5)] internal LineDef Lines; + [ProtoMember(6)] internal DecalDef Decals; + + [ProtoContract] + public struct AmmoParticleDef + { + [ProtoMember(1)] internal ParticleDef Ammo; + [ProtoMember(2)] internal ParticleDef Hit; + [ProtoMember(3)] internal ParticleDef Eject; + } + + [ProtoContract] + public struct LineDef + { + internal enum Texture + { + Normal, + Cycle, + Chaos, + Wave, + } + public enum FactionColor + { + DontUse, + Foreground, + Background, + } + + [ProtoMember(1)] internal TracerBaseDef Tracer; + [ProtoMember(2)] internal string TracerMaterial; + [ProtoMember(3)] internal Randomize ColorVariance; + [ProtoMember(4)] internal Randomize WidthVariance; + [ProtoMember(5)] internal TrailDef Trail; + [ProtoMember(6)] internal OffsetEffectDef OffsetEffect; + [ProtoMember(7)] internal bool DropParentVelocity; + + [ProtoContract] + public struct OffsetEffectDef + { + [ProtoMember(1)] internal double MaxOffset; + [ProtoMember(2)] internal double MinLength; + [ProtoMember(3)] internal double MaxLength; + } + + [ProtoContract] + public struct TracerBaseDef + { + [ProtoMember(1)] internal bool Enable; + [ProtoMember(2)] internal float Length; + [ProtoMember(3)] internal float Width; + [ProtoMember(4)] internal Vector4 Color; + [ProtoMember(5)] internal uint VisualFadeStart; + [ProtoMember(6)] internal uint VisualFadeEnd; + [ProtoMember(7)] internal SegmentDef Segmentation; + [ProtoMember(8)] internal string[] Textures; + [ProtoMember(9)] internal Texture TextureMode; + [ProtoMember(10)] internal bool AlwaysDraw; + [ProtoMember(11)] internal FactionColor FactionColor; + + [ProtoContract] + public struct SegmentDef + { + [ProtoMember(1)] internal string Material; //retired + [ProtoMember(2)] internal double SegmentLength; + [ProtoMember(3)] internal double SegmentGap; + [ProtoMember(4)] internal double Speed; + [ProtoMember(5)] internal Vector4 Color; + [ProtoMember(6)] internal double WidthMultiplier; + [ProtoMember(7)] internal bool Reverse; + [ProtoMember(8)] internal bool UseLineVariance; + [ProtoMember(9)] internal Randomize ColorVariance; + [ProtoMember(10)] internal Randomize WidthVariance; + [ProtoMember(11)] internal string[] Textures; + [ProtoMember(12)] internal bool Enable; + [ProtoMember(13)] internal FactionColor FactionColor; + } + } + + [ProtoContract] + public struct TrailDef + { + [ProtoMember(1)] internal bool Enable; + [ProtoMember(2)] internal string Material; + [ProtoMember(3)] internal int DecayTime; + [ProtoMember(4)] internal Vector4 Color; + [ProtoMember(5)] internal bool Back; + [ProtoMember(6)] internal float CustomWidth; + [ProtoMember(7)] internal bool UseWidthVariance; + [ProtoMember(8)] internal bool UseColorFade; + [ProtoMember(9)] internal string[] Textures; + [ProtoMember(10)] internal Texture TextureMode; + [ProtoMember(11)] internal bool AlwaysDraw; + [ProtoMember(12)] internal FactionColor FactionColor; + } + } + + [ProtoContract] + public struct DecalDef + { + + [ProtoMember(1)] internal int MaxAge; + [ProtoMember(2)] internal TextureMapDef[] Map; + + [ProtoContract] + public struct TextureMapDef + { + [ProtoMember(1)] internal string HitMaterial; + [ProtoMember(2)] internal string DecalMaterial; + } + } + } + + [ProtoContract] + public struct BeamDef + { + [ProtoMember(1)] internal bool Enable; + [ProtoMember(2)] internal bool ConvergeBeams; + [ProtoMember(3)] internal bool VirtualBeams; + [ProtoMember(4)] internal bool RotateRealBeam; + [ProtoMember(5)] internal bool OneParticle; + [ProtoMember(6)] internal bool FakeVoxelHits; + } + + [ProtoContract] + public struct FragmentDef + { + [ProtoMember(1)] internal string AmmoRound; + [ProtoMember(2)] internal int Fragments; + [ProtoMember(3)] internal float Radial; + [ProtoMember(4)] internal float BackwardDegrees; + [ProtoMember(5)] internal float Degrees; + [ProtoMember(6)] internal bool Reverse; + [ProtoMember(7)] internal bool IgnoreArming; + [ProtoMember(8)] internal bool DropVelocity; + [ProtoMember(9)] internal float Offset; + [ProtoMember(10)] internal int MaxChildren; + [ProtoMember(11)] internal TimedSpawnDef TimedSpawns; + [ProtoMember(12)] internal bool FireSound; + [ProtoMember(13)] internal Vector3D AdvOffset; + [ProtoMember(14)] internal bool ArmWhenHit; + + [ProtoContract] + public struct TimedSpawnDef + { + public enum PointTypes + { + Direct, + Lead, + Predict, + } + + [ProtoMember(1)] internal bool Enable; + [ProtoMember(2)] internal int Interval; + [ProtoMember(3)] internal int StartTime; + [ProtoMember(4)] internal int MaxSpawns; + [ProtoMember(5)] internal double Proximity; + [ProtoMember(6)] internal bool ParentDies; + [ProtoMember(7)] internal bool PointAtTarget; + [ProtoMember(8)] internal int GroupSize; + [ProtoMember(9)] internal int GroupDelay; + [ProtoMember(10)] internal PointTypes PointType; + } + } + + [ProtoContract] + public struct PatternDef + { + public enum PatternModes + { + Never, + Weapon, + Fragment, + Both, + } + + + [ProtoMember(1)] internal string[] Patterns; + [ProtoMember(2)] internal bool Enable; + [ProtoMember(3)] internal float TriggerChance; + [ProtoMember(4)] internal bool SkipParent; + [ProtoMember(5)] internal bool Random; + [ProtoMember(6)] internal int RandomMin; + [ProtoMember(7)] internal int RandomMax; + [ProtoMember(8)] internal int PatternSteps; + [ProtoMember(9)] internal PatternModes Mode; + } + + [ProtoContract] + public struct EjectionDef + { + public enum SpawnType + { + Item, + Particle, + } + [ProtoMember(1)] internal float Speed; + [ProtoMember(2)] internal float SpawnChance; + [ProtoMember(3)] internal SpawnType Type; + [ProtoMember(4)] internal ComponentDef CompDef; + + [ProtoContract] + public struct ComponentDef + { + [ProtoMember(1)] internal string ItemName; + [ProtoMember(2)] internal int ItemLifeTime; + [ProtoMember(3)] internal int Delay; + } + } + + [ProtoContract] + public struct AreaOfDamageDef + { + public enum Falloff + { + Legacy, + NoFalloff, + Linear, + Curve, + InvCurve, + Squeeze, + Pooled, + Exponential, + } + + public enum AoeShape + { + Round, + Diamond, + } + + [ProtoMember(1)] internal ByBlockHitDef ByBlockHit; + [ProtoMember(2)] internal EndOfLifeDef EndOfLife; + + [ProtoContract] + public struct ByBlockHitDef + { + [ProtoMember(1)] internal bool Enable; + [ProtoMember(2)] internal double Radius; + [ProtoMember(3)] internal float Damage; + [ProtoMember(4)] internal float Depth; + [ProtoMember(5)] internal float MaxAbsorb; + [ProtoMember(6)] internal Falloff Falloff; + [ProtoMember(7)] internal AoeShape Shape; + } + + [ProtoContract] + public struct EndOfLifeDef + { + [ProtoMember(1)] internal bool Enable; + [ProtoMember(2)] internal double Radius; + [ProtoMember(3)] internal float Damage; + [ProtoMember(4)] internal float Depth; + [ProtoMember(5)] internal float MaxAbsorb; + [ProtoMember(6)] internal Falloff Falloff; + [ProtoMember(7)] internal bool ArmOnlyOnHit; + [ProtoMember(8)] internal int MinArmingTime; + [ProtoMember(9)] internal bool NoVisuals; + [ProtoMember(10)] internal bool NoSound; + [ProtoMember(11)] internal float ParticleScale; + [ProtoMember(12)] internal string CustomParticle; + [ProtoMember(13)] internal string CustomSound; + [ProtoMember(14)] internal AoeShape Shape; + } + } + + [ProtoContract] + public struct EwarDef + { + public enum EwarType + { + AntiSmart, + JumpNull, + EnergySink, + Anchor, + Emp, + Offense, + Nav, + Dot, + Push, + Pull, + Tractor, + } + + public enum EwarMode + { + Effect, + Field, + } + + [ProtoMember(1)] internal bool Enable; + [ProtoMember(2)] internal EwarType Type; + [ProtoMember(3)] internal EwarMode Mode; + [ProtoMember(4)] internal float Strength; + [ProtoMember(5)] internal double Radius; + [ProtoMember(6)] internal int Duration; + [ProtoMember(7)] internal bool StackDuration; + [ProtoMember(8)] internal bool Depletable; + [ProtoMember(9)] internal int MaxStacks; + [ProtoMember(10)] internal bool NoHitParticle; + [ProtoMember(11)] internal PushPullDef Force; + [ProtoMember(12)] internal FieldDef Field; + + + [ProtoContract] + public struct FieldDef + { + [ProtoMember(1)] internal int Interval; + [ProtoMember(2)] internal int PulseChance; + [ProtoMember(3)] internal int GrowTime; + [ProtoMember(4)] internal bool HideModel; + [ProtoMember(5)] internal bool ShowParticle; + [ProtoMember(6)] internal double TriggerRange; + [ProtoMember(7)] internal ParticleDef Particle; + } + + [ProtoContract] + public struct PushPullDef + { + public enum Force + { + ProjectileLastPosition, + ProjectileOrigin, + HitPosition, + TargetCenter, + TargetCenterOfMass, + } + + [ProtoMember(1)] internal Force ForceFrom; + [ProtoMember(2)] internal Force ForceTo; + [ProtoMember(3)] internal Force Position; + [ProtoMember(4)] internal bool DisableRelativeMass; + [ProtoMember(5)] internal double TractorRange; + [ProtoMember(6)] internal bool ShooterFeelsForce; + } + } + + + [ProtoContract] + public struct AreaDamageDef + { + public enum AreaEffectType + { + Disabled, + Explosive, + Radiant, + AntiSmart, + JumpNullField, + EnergySinkField, + AnchorField, + EmpField, + OffenseField, + NavField, + DotField, + PushField, + PullField, + TractorField, + } + + [ProtoMember(1)] internal double AreaEffectRadius; + [ProtoMember(2)] internal float AreaEffectDamage; + [ProtoMember(3)] internal AreaEffectType AreaEffect; + [ProtoMember(4)] internal PulseDef Pulse; + [ProtoMember(5)] internal DetonateDef Detonation; + [ProtoMember(6)] internal ExplosionDef Explosions; + [ProtoMember(7)] internal EwarFieldsDef EwarFields; + [ProtoMember(8)] internal AreaInfluence Base; + + [ProtoContract] + public struct AreaInfluence + { + [ProtoMember(1)] internal double Radius; + [ProtoMember(2)] internal float EffectStrength; + } + + + [ProtoContract] + public struct PulseDef + { + [ProtoMember(1)] internal int Interval; + [ProtoMember(2)] internal int PulseChance; + [ProtoMember(3)] internal int GrowTime; + [ProtoMember(4)] internal bool HideModel; + [ProtoMember(5)] internal bool ShowParticle; + [ProtoMember(6)] internal ParticleDef Particle; + } + + [ProtoContract] + public struct EwarFieldsDef + { + [ProtoMember(1)] internal int Duration; + [ProtoMember(2)] internal bool StackDuration; + [ProtoMember(3)] internal bool Depletable; + [ProtoMember(4)] internal double TriggerRange; + [ProtoMember(5)] internal int MaxStacks; + [ProtoMember(6)] internal PushPullDef Force; + [ProtoMember(7)] internal bool DisableParticleEffect; + + [ProtoContract] + public struct PushPullDef + { + public enum Force + { + ProjectileLastPosition, + ProjectileOrigin, + HitPosition, + TargetCenter, + TargetCenterOfMass, + } + + [ProtoMember(1)] internal Force ForceFrom; + [ProtoMember(2)] internal Force ForceTo; + [ProtoMember(3)] internal Force Position; + [ProtoMember(4)] internal bool DisableRelativeMass; + [ProtoMember(5)] internal double TractorRange; + [ProtoMember(6)] internal bool ShooterFeelsForce; + } + } + + [ProtoContract] + public struct DetonateDef + { + [ProtoMember(1)] internal bool DetonateOnEnd; + [ProtoMember(2)] internal bool ArmOnlyOnHit; + [ProtoMember(3)] internal float DetonationRadius; + [ProtoMember(4)] internal float DetonationDamage; + [ProtoMember(5)] internal int MinArmingTime; + } + + [ProtoContract] + public struct ExplosionDef + { + [ProtoMember(1)] internal bool NoVisuals; + [ProtoMember(2)] internal bool NoSound; + [ProtoMember(3)] internal float Scale; + [ProtoMember(4)] internal string CustomParticle; + [ProtoMember(5)] internal string CustomSound; + [ProtoMember(6)] internal bool NoShrapnel; + [ProtoMember(7)] internal bool NoDeformation; + } + } + + [ProtoContract] + public struct AmmoAudioDef + { + [ProtoMember(1)] internal string TravelSound; + [ProtoMember(2)] internal string HitSound; + [ProtoMember(3)] internal float HitPlayChance; + [ProtoMember(4)] internal bool HitPlayShield; + [ProtoMember(5)] internal string VoxelHitSound; + [ProtoMember(6)] internal string PlayerHitSound; + [ProtoMember(7)] internal string FloatingHitSound; + [ProtoMember(8)] internal string ShieldHitSound; + [ProtoMember(9)] internal string ShotSound; + } + + [ProtoContract] + public struct TrajectoryDef + { + internal enum GuidanceType + { + None, + Remote, + TravelTo, + Smart, + DetectTravelTo, + DetectSmart, + DetectFixed, + DroneAdvanced, + } + + [ProtoMember(1)] internal float MaxTrajectory; + [ProtoMember(2)] internal float AccelPerSec; + [ProtoMember(3)] internal float DesiredSpeed; + [ProtoMember(4)] internal float TargetLossDegree; + [ProtoMember(5)] internal int TargetLossTime; + [ProtoMember(6)] internal int MaxLifeTime; + [ProtoMember(7)] internal int DeaccelTime; + [ProtoMember(8)] internal Randomize SpeedVariance; + [ProtoMember(9)] internal Randomize RangeVariance; + [ProtoMember(10)] internal GuidanceType Guidance; + [ProtoMember(11)] internal SmartsDef Smarts; + [ProtoMember(12)] internal MinesDef Mines; + [ProtoMember(13)] internal float GravityMultiplier; + [ProtoMember(14)] internal uint MaxTrajectoryTime; + [ProtoMember(15)] internal ApproachDef[] Approaches; + [ProtoMember(16)] internal double TotalAcceleration; + + [ProtoContract] + public struct SmartsDef + { + [ProtoMember(1)] internal double Inaccuracy; + [ProtoMember(2)] internal double Aggressiveness; + [ProtoMember(3)] internal double MaxLateralThrust; + [ProtoMember(4)] internal double TrackingDelay; + [ProtoMember(5)] internal int MaxChaseTime; + [ProtoMember(6)] internal bool OverideTarget; + [ProtoMember(7)] internal int MaxTargets; + [ProtoMember(8)] internal bool NoTargetExpire; + [ProtoMember(9)] internal bool Roam; + [ProtoMember(10)] internal bool KeepAliveAfterTargetLoss; + [ProtoMember(11)] internal float OffsetRatio; + [ProtoMember(12)] internal int OffsetTime; + [ProtoMember(13)] internal bool CheckFutureIntersection; + [ProtoMember(14)] internal double NavAcceleration; + [ProtoMember(15)] internal bool AccelClearance; + [ProtoMember(16)] internal double SteeringLimit; + [ProtoMember(17)] internal bool FocusOnly; + [ProtoMember(18)] internal double OffsetMinRange; + [ProtoMember(19)] internal bool FocusEviction; + [ProtoMember(20)] internal double ScanRange; + [ProtoMember(21)] internal bool NoSteering; + [ProtoMember(22)] internal double FutureIntersectionRange; + [ProtoMember(23)] internal double MinTurnSpeed; + [ProtoMember(24)] internal bool NoTargetApproach; + [ProtoMember(25)] internal bool AltNavigation; + } + + [ProtoContract] + public struct ApproachDef + { + public enum ReInitCondition + { + Wait, + MoveToPrevious, + MoveToNext, + ForceRestart, + } + + public enum Conditions + { + Ignore, + Spawn, + DistanceFromPositionC, + Lifetime, + DesiredElevation, + MinTravelRequired, + MaxTravelRequired, + Deadtime, + DistanceToPositionC, + NextTimedSpawn, + RelativeLifetime, + RelativeDeadtime, + SinceTimedSpawn, + RelativeSpawns, + EnemyTargetLoss, + RelativeHealthLost, + HealthRemaining, + DistanceFromPositionB, + DistanceToPositionB, + DistanceFromTarget, + DistanceToTarget, + DistanceFromEndTrajectory, + DistanceToEndTrajectory, + } + + public enum UpRelativeTo + { + UpRelativeToBlock, + UpRelativeToGravity, + UpTargetDirection, + UpTargetVelocity, + UpStoredStartDontUse, + UpStoredEndDontUse, + UpStoredStartPosition, + UpStoredEndPosition, + UpStoredStartLocalPosition, + UpStoredEndLocalPosition, + UpRelativeToShooter, + UpOriginDirection, + UpElevationDirection, + } + + public enum FwdRelativeTo + { + ForwardElevationDirection, + ForwardRelativeToBlock, + ForwardRelativeToGravity, + ForwardTargetDirection, + ForwardTargetVelocity, + ForwardStoredStartDontUse, + ForwardStoredEndDontUse, + ForwardStoredStartPosition, + ForwardStoredEndPosition, + ForwardStoredStartLocalPosition, + ForwardStoredEndLocalPosition, + ForwardRelativeToShooter, + ForwardOriginDirection, + } + + public enum RelativeTo + { + Origin, + Shooter, + Target, + Surface, + MidPoint, + PositionA, + Nothing, + StoredStartDontUse, + StoredEndDontUse, + StoredStartPosition, + StoredEndPosition, + StoredStartLocalPosition, + StoredEndLocalPosition, + } + + public enum ConditionOperators + { + StartEnd_And, + StartEnd_Or, + StartAnd_EndOr, + StartOr_EndAnd, + } + + public enum StageEvents + { + DoNothing, + EndProjectile, + EndProjectileOnRestart, + StoreDontUse, + StorePositionDontUse, + Refund, + StorePositionA, + StorePositionB, + StorePositionC, + } + + [ProtoContract] + public struct WeightedIdListDef + { + + [ProtoMember(1)] public int ApproachId; + [ProtoMember(2)] public Randomize Weight; + [ProtoMember(3)] public double End1WeightMod; + [ProtoMember(4)] public double End2WeightMod; + [ProtoMember(5)] public int MaxRuns; + [ProtoMember(6)] public double End3WeightMod; + } + + [ProtoMember(1)] internal ReInitCondition RestartCondition; + [ProtoMember(2)] internal Conditions StartCondition1; + [ProtoMember(3)] internal Conditions EndCondition1; + [ProtoMember(4)] internal UpRelativeTo Up; + [ProtoMember(5)] internal RelativeTo PositionB; + [ProtoMember(6)] internal double AngleOffset; + [ProtoMember(7)] internal double Start1Value; + [ProtoMember(8)] internal double End1Value; + [ProtoMember(9)] internal double LeadDistance; + [ProtoMember(10)] internal double DesiredElevation; + [ProtoMember(11)] internal double AccelMulti; + [ProtoMember(12)] internal double SpeedCapMulti; + [ProtoMember(13)] internal bool AdjustPositionC; + [ProtoMember(14)] internal bool CanExpireOnceStarted; + [ProtoMember(15)] internal ParticleDef AlternateParticle; + [ProtoMember(16)] internal string AlternateSound; + [ProtoMember(17)] internal string AlternateModel; + [ProtoMember(18)] internal int OnRestartRevertTo; + [ProtoMember(19)] internal ParticleDef StartParticle; + [ProtoMember(20)] internal bool AdjustPositionB; + [ProtoMember(21)] internal bool AdjustUp; + [ProtoMember(22)] internal bool PushLeadByTravelDistance; + [ProtoMember(23)] internal double TrackingDistance; + [ProtoMember(24)] internal Conditions StartCondition2; + [ProtoMember(25)] internal double Start2Value; + [ProtoMember(26)] internal Conditions EndCondition2; + [ProtoMember(27)] internal double End2Value; + [ProtoMember(28)] internal RelativeTo Elevation; + [ProtoMember(29)] internal double ElevationTolerance; + [ProtoMember(30)] internal ConditionOperators Operators; + [ProtoMember(31)] internal StageEvents StartEvent; + [ProtoMember(32)] internal StageEvents EndEvent; + [ProtoMember(33)] internal double TotalAccelMulti; + [ProtoMember(34)] internal double DeAccelMulti; + [ProtoMember(35)] internal bool Orbit; + [ProtoMember(36)] internal double OrbitRadius; + [ProtoMember(37)] internal int OffsetTime; + [ProtoMember(38)] internal double OffsetMinRadius; + [ProtoMember(39)] internal bool NoTimedSpawns; + [ProtoMember(40)] internal double OffsetMaxRadius; + [ProtoMember(41)] internal bool ForceRestart; + [ProtoMember(42)] internal RelativeTo PositionC; + [ProtoMember(43)] internal bool DisableAvoidance; + [ProtoMember(44)] internal int StoredStartId; + [ProtoMember(45)] internal int StoredEndId; + [ProtoMember(46)] internal WeightedIdListDef[] RestartList; + [ProtoMember(47)] internal RelativeTo StoredStartType; + [ProtoMember(48)] internal RelativeTo StoredEndType; + [ProtoMember(49)] internal bool LeadRotateElevatePositionB; + [ProtoMember(50)] internal bool LeadRotateElevatePositionC; + [ProtoMember(51)] internal bool NoElevationLead; + [ProtoMember(52)] internal bool IgnoreAntiSmart; + [ProtoMember(53)] internal double HeatRefund; + [ProtoMember(54)] internal Randomize AngleVariance; + [ProtoMember(55)] internal bool ReloadRefund; + [ProtoMember(56)] internal int ModelRotateTime; + [ProtoMember(57)] internal FwdRelativeTo Forward; + [ProtoMember(58)] internal bool AdjustForward; + [ProtoMember(59)] internal bool ToggleIngoreVoxels; + [ProtoMember(60)] internal bool SelfAvoidance; + [ProtoMember(61)] internal bool TargetAvoidance; + [ProtoMember(62)] internal bool SelfPhasing; + [ProtoMember(63)] internal bool TrajectoryRelativeToB; + [ProtoMember(64)] internal Conditions EndCondition3; + [ProtoMember(65)] internal double End3Value; + [ProtoMember(66)] internal bool SwapNavigationType; + [ProtoMember(67)] internal bool ElevationRelativeToC; + } + + [ProtoContract] + public struct MinesDef + { + [ProtoMember(1)] internal double DetectRadius; + [ProtoMember(2)] internal double DeCloakRadius; + [ProtoMember(3)] internal int FieldTime; + [ProtoMember(4)] internal bool Cloak; + [ProtoMember(5)] internal bool Persist; + } + } + + [ProtoContract] + public struct Randomize + { + [ProtoMember(1)] internal float Start; + [ProtoMember(2)] internal float End; + } + } + + [ProtoContract] + public struct ParticleOptionDef + { + [ProtoMember(1)] internal float Scale; + [ProtoMember(2)] internal float MaxDistance; + [ProtoMember(3)] internal float MaxDuration; + [ProtoMember(4)] internal bool Loop; + [ProtoMember(5)] internal bool Restart; + [ProtoMember(6)] internal float HitPlayChance; + } + + + [ProtoContract] + public struct ParticleDef + { + [ProtoMember(1)] internal string Name; + [ProtoMember(2)] internal Vector4 Color; + [ProtoMember(3)] internal Vector3D Offset; + [ProtoMember(4)] internal ParticleOptionDef Extras; + [ProtoMember(5)] internal bool ApplyToShield; + [ProtoMember(6)] internal bool DisableCameraCulling; + } + } + } + +} \ No newline at end of file diff --git a/Utility Mods/Stable/GyroscopicGunsight/Data/Scripts/GyroscopicGunsight/API/CoreSystems/CoreSystemsApiPhantoms.cs b/Utility Mods/Stable/GyroscopicGunsight/Data/Scripts/GyroscopicGunsight/API/CoreSystems/CoreSystemsApiPhantoms.cs new file mode 100644 index 000000000..5eddcfaa0 --- /dev/null +++ b/Utility Mods/Stable/GyroscopicGunsight/Data/Scripts/GyroscopicGunsight/API/CoreSystems/CoreSystemsApiPhantoms.cs @@ -0,0 +1,113 @@ +using System; +using VRage; +using VRage.Game.Entity; +using VRageMath; + +namespace SC.GyroscopicGunsight.API.CoreSystems +{ + /// + /// https://github.com/sstixrud/CoreSystems/blob/master/BaseData/Scripts/CoreSystems/Api/CoreSystemsApiPhantoms.cs + /// + public partial class WcApi + { + public enum TriggerActions + { + TriggerOff, + TriggerOn, + TriggerOnce, + } + + private Func> _getTargetAssessment; + //private Action>> _getPhantomInfo; + private Action _setTriggerState; + private Action _addMagazines; + private Action _setAmmo; + private Func _closePhantom; + private Func _spawnPhantom; + private Func _setPhantomFocusTarget; + + /// + /// Get information about a particular target relative to this phantom + /// + /// + /// + /// + /// + /// + internal void GetTargetAssessment(MyEntity phantom, MyEntity target, int weapon = 0, bool mustBeInrange = false, bool checkTargetOrb = false) => _getTargetAssessment?.Invoke(phantom, target, weapon, mustBeInrange, checkTargetOrb); + + /// + /// + /// + /// + /// + //internal void GetPhantomInfo(string phantomSubtypeId, ICollection> collection) => _getPhantomInfo?.Invoke(phantomSubtypeId, collection); + + /// + /// Change the phantoms current fire state + /// + /// + /// + internal void SetTriggerState(MyEntity phantom, TriggerActions trigger) => _setTriggerState?.Invoke(phantom, (int)trigger); + + /// + /// Add additional magazines + /// + /// + /// + /// + internal void AddMagazines(MyEntity phantom, int weapon, long quanity) => _addMagazines?.Invoke(phantom, weapon, quanity); + /// + /// Set/switch ammo + /// + /// + /// + /// + internal void SetAmmo(MyEntity phantom, int weapon, string ammoName) => _setAmmo?.Invoke(phantom, weapon, ammoName); + /// + /// Close phantoms, required for phantoms that do not auto close + /// + /// + /// + internal bool ClosePhantom(MyEntity phantom) => _closePhantom?.Invoke(phantom) ?? false; + + /// + /// string: weapon subtypeId + /// uint: max age, defaults to never die, you must issue close request! Max duration is 14400 ticks (4 minutes) + /// bool: close when phantom runs out of ammo + /// long: Number of ammo reloads phantom has per default, prior to you adding more, defaults to long.MaxValue + /// string: name of the ammo you want the phantom to start with, if different than default + /// TriggerActions: TriggerOff, TriggerOn, TriggerOnce + /// float?: scales the model if defined in the WeaponDefinition for this subtypeId + /// MyEntity: Parent's this phantom to another world entity. + /// StringerBuilder: Assign a name to this phantom + /// bool: Add this phantom to the world PrunningStructure + /// bool: Enable shadows for the model. + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + /// + + /// + internal MyEntity SpawnPhantom(string phantomType, uint maxAge = 0, bool closeWhenOutOfAmmo = false, long defaultReloads = long.MaxValue, string ammoOverideName = null, TriggerActions trigger = TriggerActions.TriggerOff, float? modelScale = null, MyEntity parnet = null, bool addToPrunning = false, bool shadows = false, long identityId = 0, bool sync = false) + => _spawnPhantom?.Invoke(phantomType, maxAge, closeWhenOutOfAmmo, defaultReloads, ammoOverideName, (int)trigger, modelScale, parnet, addToPrunning, shadows, identityId, sync) ?? null; + + /// + /// Set/switch ammo + /// focusId is a value between 0 and 1, can have two active focus targets. + /// + /// + /// + /// + internal bool SetPhantomFocusTarget(MyEntity phantom, MyEntity target, int focusId) => _setPhantomFocusTarget?.Invoke(phantom, target, focusId) ?? false; + } +} \ No newline at end of file diff --git a/Utility Mods/Stable/GyroscopicGunsight/Data/Scripts/GyroscopicGunsight/GyroscopicGunsightSession.cs b/Utility Mods/Stable/GyroscopicGunsight/Data/Scripts/GyroscopicGunsight/GyroscopicGunsightSession.cs new file mode 100644 index 000000000..6634dafb1 --- /dev/null +++ b/Utility Mods/Stable/GyroscopicGunsight/Data/Scripts/GyroscopicGunsight/GyroscopicGunsightSession.cs @@ -0,0 +1,148 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Sandbox.ModAPI; +using Sandbox.ModAPI.Interfaces; +using SC.GyroscopicGunsight.API.CoreSystems; +using VRage.Game; +using VRage.Game.Components; +using VRage.Game.Entity; +using VRage.Game.ModAPI; +using VRage.Utils; +using VRageMath; + +namespace SC.GyroscopicGunsight +{ + [MySessionComponentDescriptor(MyUpdateOrder.NoUpdate)] + internal class GyroscopicGunsightSession : MySessionComponentBase + { + public WcApi WcApi = new WcApi(); + + private MyStringId _gunsightTexture = MyStringId.GetOrCompute("GyroGunsight"); + private Vector4 _gunsightColor = new Vector4(1, 1, 1, 1); + Vector3D currentPos; + Vector3D vectorToTarget; + public double distanceToTarget; + Vector3D prevPosition; + Vector3D velocity; + + public double deflectionX; + public double deflectionY; + public double xRate; + public double yRate; + public double muzzleVelocity = 2000; + public double range; + + /// + /// Distance from the camera to the billboard. + /// Ideally, this should be as low as possible. + /// + private const float NearDistance = 4f; + /// + /// Size in meters of the billboard. + /// Seems to have a lower cap of 0.05? + /// + private const float SightSize = 0.1f; + + public override void LoadData() + { + WcApi.Load(); + } + + private float i = 0; + public override void Draw() + { + if (MyAPIGateway.Utilities.IsDedicated || !(WcApi?.IsReady ?? false)) + return; + + try + { + // Look for the grid the player is in + var currentGrid = (MyAPIGateway.Session.Player.Controller.ControlledEntity as IMyCockpit)?.CubeGrid; + if (currentGrid == null) + return; + + var target = WcApi.GetAiFocus((MyEntity) currentGrid); + if (target == null) + { + MyAPIGateway.Utilities.ShowNotification("No Target!", 1000/60); + return; + } + + // Grab fixed guns + // Looks for WC guns with a lead group assigned + var fixedWeapons = currentGrid.GetFatBlocks().Where(b => WcApi.HasCoreWeapon((MyEntity) b) && (b.GetProperty("Target Group")?.AsFloat()?.GetValue(b) ?? 0) != 0); + MyAPIGateway.Utilities.ShowNotification("Fixed Guns: " + fixedWeapons.Count(), 1000/60); + + + // actual calculations + foreach (var weapon in fixedWeapons) + { + Vector3D dynamicPosition = CalculateDeflection(weapon, target as IMyCubeGrid); + DrawGunsight(dynamicPosition); + } + + } + catch (Exception ex) + { + MyLog.Default.WriteLine(ex); + } + } + + /// + /// Squid's fancy leading math + /// + /// + /// + public Vector3D CalculateDeflection(IMyCubeBlock thisWeapon, IMyCubeGrid targetGrid) + { + if (thisWeapon == null || targetGrid == null) + { + MyLog.Default.WriteLine("CalculateDeflection error: thisWeapon or targetGrid is null"); + return Vector3D.Zero; // Return a default value to avoid breaking + } + + // It shouldn't matter if an NRE gets thrown here, it's caught elsewhere, and it would be an Actual Problem:tm: + //var shipAngularVelocity = thisWeapon.CubeGrid.Physics.AngularVelocity; + + // no + //var weaponAngularVelocity = Vector3D.Transform(thisWeapon.CubeGrid.Physics.GetVelocityAtPoint(thisWeapon.WorldMatrix.Translation) - thisWeapon.CubeGrid.LinearVelocity, thisWeapon.CubeGrid.WorldMatrix.GetOrientation()); + var weaponAngularVelocity = thisWeapon.CubeGrid.Physics.AngularVelocityLocal; // ? + //var weaponPos = thisWeapon.WorldMatrix.Translation; + //thisWeapon.CubeGrid.Physics.GetVelocityAtPointLocal(ref weaponPos, out weaponAngularVelocity); + + Vector3D targetPos = targetGrid.GetPosition(); + Vector3D myPos = thisWeapon.CubeGrid.GetPosition(); + + range = Vector3.Distance(myPos, targetPos); + + // it's yo-hover + deflectionX = (range / muzzleVelocity) * Math.Tan(weaponAngularVelocity.X) * range; + deflectionY = (range / muzzleVelocity) * Math.Tan(weaponAngularVelocity.Y) * range; + var deflectionZ = (range / muzzleVelocity) * Math.Tan(weaponAngularVelocity.Z) * range; + + Vector3D offsetVec = new Vector3D(deflectionX, deflectionY, deflectionZ); // Full trailing reticle + + return Vector3.Transform(offsetVec, thisWeapon.CubeGrid.WorldMatrix) + thisWeapon.WorldMatrix.Forward * range; // TODO add offset from gun to grid + } + + /// + /// Aristeas's unfancy texture math + /// + /// + public void DrawGunsight(Vector3D Position) + { + try + { + var camera = MyAPIGateway.Session.Camera; + Vector3D offsetPosition = (Position - camera.Position).Normalized() * NearDistance + camera.Position; + + MySimpleObjectDraw.DrawLine(offsetPosition + camera.WorldMatrix.Left * SightSize, offsetPosition + camera.WorldMatrix.Right * SightSize, _gunsightTexture, ref _gunsightColor, SightSize); + } + catch (Exception ex) + { + MyLog.Default.WriteLine(ex); + } + } + } +} diff --git a/Utility Mods/Stable/GyroscopicGunsight/Data/Textures_GyroSight.sbc b/Utility Mods/Stable/GyroscopicGunsight/Data/Textures_GyroSight.sbc new file mode 100644 index 000000000..2595223e4 --- /dev/null +++ b/Utility Mods/Stable/GyroscopicGunsight/Data/Textures_GyroSight.sbc @@ -0,0 +1,19 @@ + + + + + + + TransparentMaterialDefinition + GyroGunsight + + false + 1 + false + false + 0.1 + Textures\TempCursor.dds + + + + diff --git a/Utility Mods/Stable/GyroscopicGunsight/Properties/AssemblyInfo.cs b/Utility Mods/Stable/GyroscopicGunsight/Properties/AssemblyInfo.cs new file mode 100644 index 000000000..2159152e6 --- /dev/null +++ b/Utility Mods/Stable/GyroscopicGunsight/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("GyroscopicGunsight")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("GyroscopicGunsight")] +[assembly: AssemblyCopyright("Copyright © 2023")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("c2e7c36d-b0c8-448b-a6fd-905cfb11f7cb")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/Utility Mods/Stable/GyroscopicGunsight/Textures/TempCursor.dds b/Utility Mods/Stable/GyroscopicGunsight/Textures/TempCursor.dds new file mode 100644 index 000000000..c4a660a2b Binary files /dev/null and b/Utility Mods/Stable/GyroscopicGunsight/Textures/TempCursor.dds differ