From 7d6edd6c41b0c11cd60f071c350b6a6b9ff991eb Mon Sep 17 00:00:00 2001 From: ulteq Date: Tue, 6 Dec 2016 10:59:29 +0100 Subject: [PATCH] Brought the SQF variant of the woundsHandler back (for linux servers) --- addons/medical_damage/XEH_PREP.hpp | 4 +- addons/medical_damage/XEH_preInit.sqf | 9 +- .../functions/fnc_woundsHandlerSQF.sqf | 151 ++++++++++++++++++ 3 files changed, 161 insertions(+), 3 deletions(-) create mode 100644 addons/medical_damage/functions/fnc_woundsHandlerSQF.sqf diff --git a/addons/medical_damage/XEH_PREP.hpp b/addons/medical_damage/XEH_PREP.hpp index a5ac88c01c..08f7a9debc 100644 --- a/addons/medical_damage/XEH_PREP.hpp +++ b/addons/medical_damage/XEH_PREP.hpp @@ -1,5 +1,5 @@ -PREP(parseConfigForInjuries); PREP(getTypeOfDamage); - +PREP(parseConfigForInjuries); PREP(woundsHandler); +PREP(woundsHandlerSQF); diff --git a/addons/medical_damage/XEH_preInit.sqf b/addons/medical_damage/XEH_preInit.sqf index bca40832c8..f3e7680270 100644 --- a/addons/medical_damage/XEH_preInit.sqf +++ b/addons/medical_damage/XEH_preInit.sqf @@ -6,11 +6,18 @@ ADDON = false; call FUNC(parseConfigForInjuries); +// decide which woundsHandler to use by whether the extension is present or not +if ("ace_medical" callExtension "version" != "") then { + DFUNC(woundsHandlerActive) = FUNC(woundsHandler); +} else { + DFUNC(woundsHandlerActive) = FUNC(woundsHandlerSQF); +}; + [QEGVAR(medical_engine,woundReceived), { params ["_unit", "_woundedHitPoint", "_receivedDamage", "", "_ammo"]; private _typeOfDamage = _ammo call FUNC(getTypeOfDamage); - [_unit, _woundedHitPoint, _receivedDamage, _ammo, _typeOfDamage] call FUNC(woundsHandler); + [_unit, _woundedHitPoint, _receivedDamage, _ammo, _typeOfDamage] call FUNC(woundsHandlerActive); [_unit, EGVAR(medical,STATE_MACHINE)] call EFUNC(medical,addStateHandler); }] call CBA_fnc_addEventHandler; diff --git a/addons/medical_damage/functions/fnc_woundsHandlerSQF.sqf b/addons/medical_damage/functions/fnc_woundsHandlerSQF.sqf new file mode 100644 index 0000000000..13b8b98c59 --- /dev/null +++ b/addons/medical_damage/functions/fnc_woundsHandlerSQF.sqf @@ -0,0 +1,151 @@ +/* + * Author: Glowbal, commy2 + * Handling of the open wounds & injuries upon the handleDamage eventhandler. + * + * Arguments: + * 0: Unit That Was Hit + * 1: Name Of Body Part + * 2: Amount Of Damage + * 3: Shooter or source of the damage + * 4: Type of the damage done + * + * Return Value: + * None + * + * Public: No + */ +#include "script_component.hpp" + +params ["_unit", "_bodyPart", "_damage", "_typeOfProjectile", "_typeOfDamage"]; +TRACE_5("start",_unit,_bodyPart,_damage,_typeOfProjectile,_typeOfDamage); + +// Convert the selectionName to a number and ensure it is a valid selection. +private _bodyPartN = ALL_BODY_PARTS find toLower _bodyPart; +if (_bodyPartN < 0) exitWith {}; + +if (_typeOfDamage isEqualTo "") then { + _typeOfDamage = "unknown"; +}; + +// Get the damage type information. Format: [typeDamage thresholds, selectionSpecific, woundTypes] +// WoundTypes are the available wounds for this damage type. Format [[classID, selections, bleedingRate, pain], ..] +private _damageTypeInfo = [GVAR(allDamageTypesData) getVariable _typeOfDamage] param [0, [[], false, []]]; +_damageTypeInfo params ["_thresholds", "_isSelectionSpecific", "_woundTypes"]; + +// It appears we are dealing with an unknown type of damage. +if (count _woundTypes == 0) then { + // grabbing the configuration for unknown damage type + _damageTypeInfo = [GVAR(allDamageTypesData) getVariable "unknown"] param [0, [[], false, []]]; + _woundTypes = _damageTypeInfo select 2; +}; + +// find the available injuries for this damage type and damage amount +private _highestPossibleSpot = -1; +private _highestPossibleDamage = -1; +private _allPossibleInjuries = []; + +{ + _x params ["", "_selections", "", "", "_damageExtrema"]; + _damageExtrema params ["_minDamage", "_maxDamage"]; + + // Check if the damage is higher as the min damage for the specific injury + if (_damage >= _minDamage && {_damage <= _maxDamage || _maxDamage < 0}) then { + // Check if the injury can be applied to the given selection name + if ("All" in _selections || {_bodyPart in _selections}) then { // @todo, this is case sensitive! + + // Find the wound which has the highest minimal damage, so we can use this later on for adding the correct injuries + if (_minDamage > _highestPossibleDamage) then { + _highestPossibleSpot = _forEachIndex; + _highestPossibleDamage = _minDamage; + }; + + // Store the valid possible injury for the damage type, damage amount and selection + _allPossibleInjuries pushBack _x; + }; + }; +} forEach _woundTypes; + +// No possible wounds available for this damage type or damage amount. +if (_highestPossibleSpot < 0) exitWith {}; + +// Administration for open wounds and ids +private _openWounds = _unit getVariable [QEGVAR(medical,openWounds), []]; +private _woundID = _unit getVariable [QGVAR(lastUniqueWoundID), 1]; + +private _painLevel = 0; +private _woundsCreated = []; + +{ + if (_x select 0 <= _damage) exitWith { + for "_i" from 0 to ((_x select 1)-1) do { + // Find the injury we are going to add. Format [ classID, allowdSelections, bleedingRate, injuryPain] + private _oldInjury = if (random 1 >= 0.85) then { + _woundTypes select _highestPossibleSpot + } else { + selectRandom _allPossibleInjuries + }; + + _oldInjury params ["_woundClassIDToAdd", "", "_injuryBleedingRate", "_injuryPain"]; + + private _bodyPartNToAdd = [floor random 6, _bodyPartN] select _isSelectionSpecific; // 6 == count ALL_BODY_PARTS + + // Create a new injury. Format [ID, classID, bodypart, percentage treated, bleeding rate] + _injury = [_woundID, _woundClassIDToAdd, _bodyPartNToAdd, 1, _injuryBleedingRate]; + + // The higher the nastiness likelihood the higher the change to get a painful and bloody wound + private _nastinessLikelihood = if (_damage > 1) then { + (_damage ^ 0.33) + } else { + (0.1 max _damage) + }; + private _bloodiness = 0.01 + 0.99 * (1 - random[0, 1, 0.9]) ^ (1 / _nastinessLikelihood); + private _painfullness = 0.05 + 0.95 * (1 - random[0, 1, 0.5]) ^ (1 / _nastinessLikelihood); + + _bleeding = _injuryBleedingRate * _bloodiness; + + _injury set [4, _bleeding]; + _injury set [5, _damage]; + + private _pain = _injuryPain * _painfullness; + _painLevel = _painLevel max _pain; + +#ifdef DEBUG_MODE_FULL + systemChat format["%1, damage: %2, peneration: %3, bleeding: %4, pain: %5", _bodyPart, round(_damage * 100) / 100, _damage > PENETRATION_THRESHOLD, round(_bleeding * 1000) / 1000, round(_pain * 1000) / 1000]; +#endif + + if (_bodyPartNToAdd == 0 && {_damage > 1}) then { + [QEGVAR(medical,FatalInjury), _unit] call CBA_fnc_localEvent; + }; + + // todo `forceWalk` based on leg damage + private _causeLimping = (GVAR(woundsData) select _woundClassIDToAdd) select 7; + if (_causeLimping == 1 && {_damage > 0.3} && {_bodyPartNToAdd > 3}) then { + [_unit, true] call EFUNC(medical_engine,setLimping); + }; + + // Since it is a new injury, we will have to add it to the open wounds array to store it + _openWounds pushBack _injury; + + // New injuries will also increase the wound ID + _woundID = _woundID + 1; + + // Store the injury so we can process it later correctly. + _woundsCreated pushBack _injury; + }; + }; +} forEach _thresholds; + +_unit setVariable [QEGVAR(medical,openWounds), _openWounds, true]; + +[_unit, _bodyPart] call EFUNC(medical_engine,updateBodyPartVisuals); + +// Only update if new wounds have been created +if (count _woundsCreated > 0) then { + _unit setVariable [QEGVAR(medical,lastUniqueWoundID), _woundID, true]; + [_unit] call EFUNC(medical,handleIncapacitation); +}; + +[_unit, _painLevel] call EFUNC(medical,adjustPainLevel); +[_unit, "hit", PAIN_TO_SCREAM(_painLevel)] call EFUNC(medical_engine,playInjuredSound); + +TRACE_5("exit",_unit,_painLevel,_unit getVariable QEGVAR(medical,pain),_unit getVariable QEGVAR(medical,openWounds),_woundsCreated);