[Script] Eigene Schadensberechnung

**ukur** · 10.03.2019 20:53

Zitat von Moe

https://youtu.be/9SxJkye9wYg

Ich kann nur sagen WTF?!

Es scheint völlig random zu sein, wann der Blockschaden verursacht wird.

The polling rate of the function B_AssessDamage depends on the perception rate of PERC_ASSESSDAMAGE, which is equal to 1 second:
\Ai\Ai_intern\perception.d
Npc_SetPercTime(self,1); //1 second
Npc_PercEnable(self,PERC_ASSESSDAMAGE,B_AssessDamage);

Try check BS_PARADE in Trigger-Script or LeGo Loop function with more frequent polling.

**Moe** · 12.03.2019 18:35

Setzt sich eigentlich außer mir noch jemand mit diesem Blockschaden auseinander?

Ich komme da nicht wirklich weiter und wäre ja schon ein geiles Feature, praktisch die Revolution des Gothic 2 Kampfsystems sozusagen.

**N1kX** · 24.01.2020 15:12

Hello. A lot of examples have been sorted out, but so far it has stopped as it is. I do not know how to configure the check so that if Hero hit by attaker hits, the output is of the same color, if attacker hit by hero, the output is of a different color. Now the whole conclusion is always the same color.

Code:

func void _DMG_OnDmg_Post() {
	EDI = DMG_OnDmg(EBP, MEM_ReadInt(MEM_ReadInt(ESP+644)+8), EDI, _DMG_DmgDesc);
	dmg3 = EDI;
	var oCNpc her; 
	var oCNpc sel; 
	her = Hlp_GetNpc(hero);
	sel = Hlp_GetNpc(self);
	if(dmg3 != 0)
	{
		if(Npc_IsPlayer(her))
		//if(Hlp_GetInstanceID(self) != Hlp_GetInstanceID(hero))
		{
                        //this conclusion there is
			PrintS_Ext(ConcatStrings("Урон (Damage): ",IntToString(dmg3)), RGBA(255, 215,0,255));
		}
		//else if(_^(self) == _^(hero))
		else if(Npc_IsPlayer(sel))
		{
                        //this conclusion is not
			PrintS_Ext(ConcatStrings("Урон (Damage): ",IntToString(dmg3)), RGBA(255, 0,0,255));
		};
	};
};

Thanks for help.

**Milky-Way** · 24.01.2020 16:24

Code:

her = Hlp_GetNpc(hero);
if(Npc_IsPlayer(her))

is always true?

You probably want to check for something along the lines of other?

**N1kX** · 24.01.2020 16:50

Zitat von Milky-Way

Code:

her = Hlp_GetNpc(hero);
if(Npc_IsPlayer(her))

is always true?

Yes.
I tried to check the ID of the Hero himself, but it did not bring success.
I understand that any NPS fits the condition if(Hlp_GetInstanceID(self) == Hlp_GetInstanceID(her))

Code:

func void _DMG_OnDmg_Post(){
    EDI = DMG_OnDmg(EBP, MEM_ReadInt(MEM_ReadInt(ESP+644)+8), EDI, _DMG_DmgDesc);
    dmg3 = EDI;
    var C_Npc her;
    //var oCNpc sel;
    her = Hlp_GetNpc(PC_HERO);
    //sel = Hlp_GetNpc(self);
    if(dmg3 != 0)
    {
        //if(Npc_IsPlayer(her))
        //if(Npc_IsPlayer(hero) && (self.id == 0))
        //if(her.id == 0)
        //if(Hlp_GetInstanceID(self) != Hlp_GetInstanceID(hero))
        if(Hlp_GetInstanceID(self) == Hlp_GetInstanceID(her))
        {
            PrintS_Ext(ConcatStrings("Урон: ",IntToString(dmg3)), RGBA(255, 215,0,255));
        }
        //else if(_^(self) == _^(hero))
        //else if(Npc_IsPlayer(sel))
        else
        {
            PrintS_Ext(ConcatStrings("Урон: ",IntToString(dmg3)), RGBA(255, 0,0,255));
        };
    }; };

**Neconspictor** · 24.01.2020 16:58

The variable self doesn't point necessarily to the attacker. In fact it could point to any npc.

What you need:
var int attackerptr; attackerptr = MEM_ReadInt(MEM_ReadInt(ESP+644)+8); //pointer to attacker
var int victimPtr; victimPtr = EBP ; //pointer to victim

To get c_npc variables, use:
var c_npc slf; slf = _^(attackerptr);
var c_npc oth; oth = _^(victimPtr);

Of course, you can also cast to an oCNpc variable like this:
var oCNpc slf; slf = _^(attackerptr);

**N1kX** · 24.01.2020 17:44

Zitat von Neconspictor

The variable self doesn't point necessarily to the attacker. In fact it could point to any npc.

What you need:
var int attackerptr; attackerptr = MEM_ReadInt(MEM_ReadInt(ESP+644)+8); //pointer to attacker
var int victimPtr; victimPtr = EBP ; //pointer to victim

To get c_npc variables, use:
var c_npc slf; slf = _^(attackerptr);
var c_npc oth; oth = _^(victimPtr);

Of course, you can also cast to an oCNpc variable like this:
var oCNpc slf; slf = _^(attackerptr);

I tried it, the result - it does not go beyond the first print. I tried to swap the pointers - the result is zero.

Code:

func void _DMG_OnDmg_Post() {
	EDI = DMG_OnDmg(EBP, MEM_ReadInt(MEM_ReadInt(ESP+644)+8), EDI, _DMG_DmgDesc);
	dmg3 = EDI;
	var int attackerptr; attackerptr = MEM_ReadInt(MEM_ReadInt(ESP+644)+8); 
	var int victimPtr; victimPtr = EBP ;
	if(dmg3 != 0)
	{
		if(victimPtr)
		{
			PrintS_Ext(ConcatStrings("Урон ваш (damage hero): ",IntToString(dmg3)), RGBA(255, 215,0,255));
		}
		else if(attackerptr)
		{
			PrintS_Ext(ConcatStrings("Урон по вам (damage by hero): ",IntToString(dmg3)), RGBA(255, 0,0,255));
		};
	};
};

**Neconspictor** · 27.01.2020 12:49

victimPtr and attakerPtr should never be zero, so it is naturally that only the first Print is printed.
What do you mean with 'the result is zero' ?

**Kirides** · 27.01.2020 14:50

Zitat von Neconspictor

victimPtr and attakerPtr should never be zero, so it is naturally that only the first Print is printed.
What do you mean with 'the result is zero' ?

That's not necessarily true, attackerPtr can be zero, iirc. if someone is hit by Firerain

**Neconspictor** · 27.01.2020 15:18

Zitat von Kirides

That's not necessarily true, attackerPtr can be zero, iirc. if someone is hit by Firerain

Alright, thanks

**rezu93** · 11.05.2020 15:38

Hi,
I wonder how can i use this fucntion to calculate dmg for Charge Spells, because If i put things like this:

Code:

if (dmgDescriptor.SpellID == SPL_FIRESTORM)
{
splDMG = (SPL_DAMAGE_FIRESTORM + slf2.name1 - oth.protection[PROT_FIRE]);
dmg = splDMG;
};

The spell damage will be always the same no matter if i charge it or not.
My question is how i can check the spell level or something like this to calculate charge dmg?

**Lehona** · 11.05.2020 15:56

The DamageDescriptor contains the value

Code:

var int spellLevel;			// zDWORD 0x20

which might be how often the player charged the spell. I'm not sure, though, so you will have to try it out.

**rezu93** · 11.05.2020 16:17

Yes i tried it but it didnt work, maybe i dont know how to use it in my function .

**Lehona** · 11.05.2020 16:56

Please write in English, foreign languages not understood by the moderators are generally frowned upon here (mostly for legal purposes).

And show exactly what you have tried, otherwise we can't help you any further.

**rezu93** · 11.05.2020 17:33

Im sorry Lehona, my Google Chrome just translated my english words when i was editing, i didnt noticed

I tried this:

Code:

dmgDescriptor.spellLevel = Npc_GetActiveSpellLevel(slf);

then i printed it in game but it always show me "1" no matter if i charged or not

btw im working with G1 and spell firestorm looks like this:

Code:

func int Spell_Logic_Firestorm    (var int manaInvested)
{
    PrintDebugNpc        (PD_MAGIC,    "Spell_Logic_Firestorm");


    if     (manaInvested ==(SPL_SENDCAST_FIRESTORM*3)/10)
    ||    (manaInvested ==(SPL_SENDCAST_FIRESTORM*5)/10)
    ||    (manaInvested ==(SPL_SENDCAST_FIRESTORM*8)/10)
    {    return SPL_NEXTLEVEL;        };

    if (manaInvested >= SPL_SENDCAST_FIRESTORM) 
    {    return SPL_SENDCAST;        };


    return SPL_RECEIVEINVEST;    
};

So maybe this is the problem? Because i know this was bugged with manainvest in G1 and i want to changed it anyway but spellLevel?

Edit: I make it another way:

Code:

func int Spell_Logic_Firestorm    (var int manaInvested)
{
    skalowanie = self.name1;
    PrintDebugNpc        (PD_MAGIC,    "Spell_Logic_Firestorm");
    
    if     (manaInvested ==(SPL_SENDCAST_FIRESTORM*3)/10)
    {
    splLevel = 2;
    return SPL_NEXTLEVEL;
    }
    else if (manaInvested ==(SPL_SENDCAST_FIRESTORM*5)/10)
    {
    splLevel = 3;
    return SPL_NEXTLEVEL;
    }
    else if (manaInvested ==(SPL_SENDCAST_FIRESTORM*8)/10)
    {
    splLevel = 4;
    return SPL_NEXTLEVEL;
    };
    
    if (manaInvested >= SPL_SENDCAST_FIRESTORM) 
    {    return SPL_SENDCAST;        };


    return SPL_RECEIVEINVEST;    
};

and in DmgOnDmg function:

Code:

        if (dmgDescriptor.SpellID == SPL_FIRESTORM)
        {
            var string concatText;    
            concatText = ConcatStrings("Poziom czaru: ",IntToString(splLevel));
            PrintS_Ext(concatText,RGBA(255,   255, 255,   255));
            if (splLevel <= 1)
            {
            splDMG = (SPL_DAMAGE_FIRESTORM + slf2.name1 - oth.protection[PROT_FIRE]);    
            }
            else if (spllevel == 2)
            {    
            splDMG = (SPL_DAMAGE_FIRESTORM*2 + slf2.name1 - oth.protection[PROT_FIRE]);            
            }
            else if (spllevel == 3)
            {    
            splDMG = (SPL_DAMAGE_FIRESTORM*3 + slf2.name1 - oth.protection[PROT_FIRE]);                
            }
            else if (spllevel == 4)
            {    
            splDMG = (SPL_DAMAGE_FIRESTORM*4 + slf2.name1 - oth.protection[PROT_FIRE]);    
            };
            dmg = splDMG;
            if (splDMG < 5 && !(C_BodyStateContains(oth2, BS_MOD_BURNING)))        
            {
            dmg = MinimalDMG;
            PrintS_Ext("InstantFireStorm DMG MINIMAL",RGBA(255,   255, 255,   255));
            };
        splLevel = 1;    
        };

**Lehona** · 11.05.2020 19:29

You're not supposed to set the spellLevel, you should just read it out.

Call

Code:

Print(IntToString(dmgDescriptor.spellLevel));

in your OnDmg-function and see what happens when you use a charged-up spell.

**rezu93** · 11.05.2020 19:39

dmgDescriptor.spellLevel is always = 8 no matter if charge or not

Code:

    if (dmgDesc.SpellID > 0)
    {	
		if (dmgDesc.SpellID == SPL_FIRESTORM)
        {
			concatText = ConcatStrings("Poziom czaru: ",IntToString(dmgDesc.spellLevel));
			PrintS_Ext(concatText,RGBA(255,   255, 255,   255));
			splDMG = (SPL_DAMAGE_FIRESTORM + slf.name1 - oth.protection[PROT_FIRE]);		
			if (splDMG < 5 && !(C_BodyStateContains(oth, BS_MOD_BURNING)))
			{
			dmg = MinimalDMG;
			PrintS_Ext("InstantFireStorm DMG MINIMAL",RGBA(255,   255, 255,   255));
			};
        };

    };

**Teron Gorefiend** · 16.06.2020 13:31

Hallo, da der Thread noch nicht zu alt ist, bitte ich mal fix um Hilfe. Habe vor 2 Jahren oder so schonmal versucht die G1 Schadensberechnung zu modifizieren, nur damals erkannte das Programm sämtliche Rüstungswerte als -65.000 oder so an. Da hier aber einige gepostet haben, dass sie die Schadensberechnung in G1 erfolgreich geändert haben, möchte ich es nochmal neu versuchen.

Problem ist, dass das Spiel abstürzt, sobald ich einen Gegner treffe. Spiel startet, ich kann auch alles machen, bis die Schadensberechnung ausgeführt wird.

Ich vermute mal, dass der Fehler bei HookEngineF(7567329, 6, _DMG_OnDmg_Post); oder
const int oCNpc__OnDamage_Hit = 7541776; HookEngineF(oCNpc__OnDamage_Hit, 7, _DMG_OnDmg_Pre); liegt.
Habe damals Post 48/49 mal gefragt was man dort für G1 einsetzen müsse, hat glaube ich auch funktioniert. Aber vielleicht muss man dank Lego upgrade da jetzt was neues eintragen. Wie gesagt soll für G1 laufen, für G2 läuft es momentan noch Problemlos, wobei ich noch das alte script mit DMG_OnDmg(var int victimPtr, var int attackerPtr, var int dmg) benutze,

Edit:
hat sich erledigt, hab vergessen
EDI = DMG_OnDmg(EBP, MEM_ReadInt(MEM_ReadInt(ESP+644)+8), EDI, _DMG_DmgDesc); auf EAX = DMG_OnDmg(ECX, MEM_ReadInt(MEM_ReadInt(ESP+548)+4), EAX, _DMG_DmgDesc); umzuändern.

Aber selbes Problem bleibt wie ich auch damals schon hatte. Das Programm erkennt Rüstungswerte ab 30 oder so auf einmal als minus 100.000 oder so an. Ich verstehs nichts, wenn ich den Rüstungswert des Helden im Dialog oder so abfrage wird der richtige Rüstungswert erkannt.

**Kirides** · 10.08.2020 16:12

Ich hatte jetzt das Problem, das ich einen Brandschaden-Effekt hinzufügen wollte, aber durch dieses Script gab es zu dem benötigten Zeitpunkt keinen "Angreifer" (attackerPtr leer)

Also habe ich mich hingesetzt und ... dabei kam die Klassendefinition für eine oCVisualFX raus.
Zauber wie Feuersturm machen Flächenschaden, aber der "Explosions-Effekt" hat keinen "attackerPtr". Diesen kann man aber über den VisualFX aus der DamageDescription auslesen:

"visFx.inflictor" ist hierbei derjenige der den Zaube gewirkt hat.

Code:

func int DMG_OnDmg(var int victimPtr, var int attackerPtr, var int dmg, var int dmgDescriptorPtr) {	
	// ...
	var int dmgIsVFX; dmgIsVFX = FALSE;

	if (!attackerptr && dmgDesc.visualFX) {
		// z.B. Brandschaden
		var oCVisualFX visFx; visFx = MEM_PtrToInst(dmgDesc.visualFX);		
		attackerptr = visFx.inflictor;
		dmgIsVFX = TRUE;
	};
	
	// ...
};

Ich benutze es um der Feuersturm-Explosion den gleichen Brandschaden über Zeit wie dem Feuerstum zu geben. Das ist für die immersion wichtig (Warum brennt der angegriffene, aber die anderen getroffenen bekommen keinen Brandschaden über Zeit?)

oCVisualFX.d - Zugriff auf die Eigenschaften einer VisualFx (z.B. Feuer-Effekt durch Vobs)

Spoiler:(zum lesen bitte Text markieren)

Code:

const int oCVisualFX_bitfield_offset                      = 1372;
const int oCVisualFX_bitfield_collisionOccured            = ((1 << 1) - 1) <<  0;
const int oCVisualFX_bitfield_showVisual                  = ((1 << 1) - 1) <<  1;
const int oCVisualFX_bitfield_isChild                     = ((1 << 1) - 1) <<  2;
const int oCVisualFX_bitfield_isDeleted                   = ((1 << 1) - 1) <<  3;
const int oCVisualFX_bitfield_initialized                 = ((1 << 1) - 1) <<  4;
const int oCVisualFX_bitfield_shouldDelete                = ((1 << 1) - 1) <<  5;
const int oCVisualFX_bitfield_lightning                   = ((1 << 1) - 1) <<  6;
const int oCVisualFX_bitfield_fxInvestOriginInitialized   = ((1 << 1) - 1) <<  7;

const int oCVisualFX_bitfield_fxInvestTargetInitialized   = ((1 << 1) - 1) <<  8;
const int oCVisualFX_bitfield_fxInvestStopped             = ((1 << 1) - 1) <<  9;
const int oCVisualFX_bitfield_timeScaled                  = ((1 << 1) - 1) << 10;
const int oCVisualFX_bitfield_fovMorph                    = ((1 << 2) - 1) << 11;

const int oCVisualFX_bitfield_level                       = ((1 << 5) - 1) << 13;

const int oCVisualFX_bitfield_collisionCtr                = ((1 << 3) - 1) << 18;
const int oCVisualFX_bitfield_queueSetLevel               = ((1 << 5) - 1) << 21;

class oCVisualFX
{
//zCVob {
//zCObject {
var int    _vtbl;
var int    _zCObject_refCtr;
var int    _zCObject_hashIndex;
var int    _zCObject_hashNext;
var string _zCObject_objectName; // zSTRING
//}
var int    _zCVob_globalVobTreeNode;
var int    _zCVob_lastTimeDrawn;
var int    _zCVob_lastTimeCollected;
var int    _zCVob_vobLeafList_array;
var int    _zCVob_vobLeafList_numAlloc;
var int    _zCVob_vobLeafList_numInArray;
var int    _zCVob_trafoObjToWorld[16];
var int    _zCVob_bbox3D_mins[3];
var int    _zCVob_bbox3D_maxs[3];
var int    _zCVob_bsphere3D_center[3];
var int    _zCVob_bsphere3D_radius;
var int    _zCVob_touchVobList_array;
var int    _zCVob_touchVobList_numAlloc;
var int    _zCVob_touchVobList_numInArray;
var int    _zCVob_type;
var int    _zCVob_groundShadowSizePacked;
var int    _zCVob_homeWorld;
var int    _zCVob_groundPoly;
var int    _zCVob_callback_ai;
var int    _zCVob_trafo;
var int    _zCVob_visual;
var int    _zCVob_visualAlpha;
var int    _zCVob_m_fVobFarClipZScale;
var int    _zCVob_m_AniMode;
var int    _zCVob_m_aniModeStrength;
var int    _zCVob_m_zBias;
var int    _zCVob_rigidBody;
var int    _zCVob_lightColorStat;
var int    _zCVob_lightColorDyn;
var int    _zCVob_lightDirectionStat[3];
var int    _zCVob_vobPresetName;
var int    _zCVob_eventManager;
var int    _zCVob_nextOnTimer;
var int    _zCVob_bitfield[5];
var int    _zCVob_m_poCollisionObjectClass;
var int    _zCVob_m_poCollisionObject;
  
//}

// public:
var string	visName_S;                  // zSTRING
var string	visSize_S;                  // zSTRING
var int		  visAlpha;				            // float
var string	visAlphaBlendFunc_S;        // zSTRING
var int		  visTexAniFPS;			          // float
var int		  visTexAniIsLooping;         // int
var string	emTrjMode_S;                // zSTRING
var string  emTrjOriginNode_S;          // zSTRING
var string	emTrjTargetNode_S;          // zSTRING
var int		  emTrjTargetRange;		        // float
var int		  emTrjTargetAzi;		          // float
var int		  emTrjTargetElev;		        // float
var int		  emTrjNumKeys;
var int		  emTrjNumKeysVar;
var int		  emTrjAngleElevVar;	        // float
var int		  emTrjAngleHeadVar;	        // float
var int		  emTrjKeyDistVar;		        // float
var string	emTrjLoopMode_S;            // zSTRING
var string	emTrjEaseFunc_S;            // zSTRING
var int		  emTrjEaseVel;			          // float
var int		  emTrjDynUpdateDelay;	      // float
var int		  emTrjDynUpdateTargetOnly;
var string	emFXCreate_S;               // zSTRING
var string	emFXInvestOrigin_S;         // zSTRING
var string	emFXInvestTarget_S;         // zSTRING
var int		  emFXTriggerDelay;		        // float
var int		  emFXCreatedOwnTrj;          // int
var string	emActionCollDyn_S;	        // zSTRING		// CREATE, BOUNCE, COLLIDE
var string	emActionCollStat_S;	        // zSTRING		// CREATE, CREATEONCE, BOUNCE, COLLIDE, CREATEQUAD
var string	emFXCollStat_S;             // zSTRING
var string	emFXCollDyn_S;              // zSTRING
var string	emFXCollDynPerc_S;          // zSTRING
var string	emFXCollStatAlign_S;        // zSTRING			// TRAJECTORY, COLLISIONNORMAL
var string	emFXCollDynAlign_S;         // zSTRING
var int		  emFXLifeSpan;			          // float
var int		  emCheckCollision;
var int		  emAdjustShpToOrigin;
var int		  emInvestNextKeyDuration;	  // float
var int		  emFlyGravity;				        // float
var string	emSelfRotVel_S;             // zSTRING
var string	userString[5];              // zSTRING
var string	lightPresetName;            // zSTRING
var string	sfxID;                      // zSTRING
var int		  sfxIsAmbient;		            // zBOOL
var int		  sendAssessMagic;            // int
var int		  secsPerDamage;	            // float
var int		  dScriptEnd;		              // zBYTE
var int		  visSize[3];			            // zVEC3
var int		  emTrjMode;
var int		  emActionCollDyn;
var int		  emActionCollStat;
var int		  emSelfRotVel[3]; // zVEC3
var int		  emTrjEaseFunc; // enum TEaseFunc
var int		  emTrjLoopMode; // enum TTrjLoopMode
var int		  fxState; // enum zTVFXState

//  static zCParser*		fxParser;
//  static oCVisualFX*		actFX;

var int root; // oCVisualFX*
var int parent; 		// oCVisualFX*
var int fxInvestOrigin; // oCVisualFX*
var int fxInvestTarget; // oCVisualFX*
var int ai;				// oCVisualFXAI*
//zCArray <oCVisualFX *> fxList {
var int fxList_array;
var int fxList_numAlloc;
var int fxList_numInArray;
// }
//zCArray <oCVisualFX *> childList {
var int childList_array;
var int childList_numAlloc;
var int childList_numInArray;
// }
//zCArray <oCEmitterKey *> emKeyList {
var int emKeyList_array;
var int emKeyList_numAlloc;
var int emKeyList_numInArray;
// }
//zCArray <zCVob *> vobList {
var int vobList_array;
var int vobList_numAlloc;
var int vobList_numInArray;
// }
//zCArray <zCVob *> ignoreVobList {
var int ignoreVobList_array;
var int ignoreVobList_numAlloc;
var int ignoreVobList_numInArray;
// }
//zCArray <zCVob *> allowedCollisionVobList {
var int allowedCollisionVobList_array;
var int allowedCollisionVobList_numAlloc;
var int allowedCollisionVobList_numInArray;
// }
//zCArray <zCVob *> collidedVobs {
var int collidedVobs_array;
var int collidedVobs_numAlloc;
var int collidedVobs_numInArray;
// }
//zCArray <zSVisualFXColl> queuedCollisions {
var int queuedCollisions_array;
var int queuedCollisions_numAlloc;
var int queuedCollisions_numInArray;
// }
// oCTrajectory trajectory {
    //zCArray <zCPositionKey *> keyList {
    var int trajectory_keyList_array;
    var int trajectory_keyList_numAlloc;
    var int trajectory_keyList_numInArray;
    // }
var int spl; // zCKBSpline*
var int mode;
var int length; // float
// zMAT4 res {
    var int trajectory_res_v0[4]; //zREAL[4]
    var int trajectory_res_v1[4]; //zREAL[4]
    var int trajectory_res_v2[4]; //zREAL[4]
    var int trajectory_res_v3[4]; //zREAL[4]
// }
var int lastKey;
// }
var int earthQuake;   // zCEarthquake*
var int screenFX;     // zCVobScreenFX*
var int screenFXTime; // float
var int screenFXDir;
	
var int orgNode;    // zCModelNodeInst*
var int targetNode; // zCModelNodeInst*

var int lastSetVisual;    // zCVisual*
var int origin;           // zCVob*
var int inflictor;        // zCVob*
var int target;           // zCVob*
var int light;            // zCVobLight*
var int lightRange;       // float	
var int sfx;              // zCSoundFX*
var int sfxHnd;           // zTSoundHandle	

var string fxName; // zSTRING

var int fxBackup;   // oCEmitterKey*
var int lastSetKey; // oCEmitterKey*
var int actKey;     // oCEmitterKey*
var int frameTime;      // float
var int collisionTime;  // float
var int deleteTime;     // float
var int damageTime;     // float

var int targetPos[3];     // zPOINT3
var int lastTrjDir[3];    // zVEC3
var int keySize[3];       // zVEC3
var int actSize[3];       // zVEC3
var int castEndSize[3];   // zVEC3

var int nextLevelTime;    // float
var int easeTime;         // float
var int age;              // float
var int trjUpdateTime;    // float
var int emTrjDist;        // float
var int trjSign;          // float
var int levelTime;        // float
var int lifeSpanTimer;    // float
var int fxStartTime;      // float
var int oldFovX;          // float 
var int oldFovY;          // float - 0x0558

// { - 0x055C
// collisionOccured;           // zBOOL : 1
	
// showVisual;                 // zBOOL : 1
// isChild;                    // zBOOL : 1
// isDeleted;                  // zBOOL : 1

// initialized;                // zBOOL : 1
// shouldDelete;               // zBOOL : 1
// lightning;                  // zBOOL : 1
// fxInvestOriginInitialized;  // zBOOL : 1
// fxInvestTargetInitialized;  // zBOOL : 1
// fxInvestStopped;            // zBOOL : 1
// timeScaled;                 // zBOOL : 1
// fovMorph;                   //       : 2
// level;                      //       : 5
// collisionCtr;               //       : 3
// queueSetLevel;              //       : 5
var int bitfield;
// }

// protected:
var int damage;     // float - 0x0560
    var int damageType;

// private:
    var int spellType;
    var int spellCat;
    var int spellTargetTypes;

    var int savePpsValue;         // float
    var int saveVisSizeStart[2];  // zVEC2
var int transRing_v0[3];      // zPOINT3
var int transRing_v1[3];      // zPOINT3
var int transRing_v2[3];      // zPOINT3
var int transRing_v3[3];      // zPOINT3
var int transRing_v4[3];      // zPOINT3
var int transRing_v5[3];      // zPOINT3
var int transRing_v6[3];      // zPOINT3
var int transRing_v7[3];      // zPOINT3
var int transRing_v8[3];      // zPOINT3
var int transRing_v9[3];      // zPOINT3

    var int ringPos;
    var int emTrjFollowHitLastCheck;  // zBOOL
    var int bIsProjectile;            // zBOOL
    var int bPfxMeshSetByVisualFX;    // zBOOL
    var int m_bAllowMovement;         // zBOOL
    var int m_fSleepTimer;            // zREAL
};

( Die Klassendefiniton ist nur mit Gothic 2 Die Nacht des Raben kompatibel. )

**Kirides** · 22.08.2020 14:29

Falls jemand in seiner Schadensberechnun wissen möchte ob ein Treffer ein "Volltreffer" war, dann könnt ihr iesen Code hier verwenden (Gothic 2)

in der Konstante "Dmg_IsHit" steht dann ob der aktuelle Treffer ein Volltreffer ist. (1 = Volltreffer, 0 = Mindestschadens-berechnung)

Code:

/// Gibt an ob der aktuelle Treffer ein "Volltreffer" ist.
const int Dmg_IsHit = 0;

func int DMG_OnDmg(var int victimPtr, var int attackerPtr, var int dmg, var int dmgDescriptorPtr) {
    // ...
};

func void _DMG_OnDmg_Post() {
    Dmg_IsHit = MEM_ReadInt((ESP + 640) - 356 /*zBOOL bHasHit*/);
    EDI = DMG_OnDmg(EBP, MEM_ReadInt(MEM_ReadInt(ESP+644)+8), EDI, _DMG_DmgDesc);
};

EDIT: In dem Script werden ja 2 Hooks verwendet, einmal um den oSDamageDescriptor zu bekommen und einmal für das setzen des Schadens für Npc->ChangeAttribute(...)

Ist es falsch/gefährlich wenn man statt der 2 Hooks nur einen verwenden würde, aber dafür den oSDamageDescriptor aus dem ESP+644 (280h +4) auslesen würde? (Soweit ich dem Zeug in IDA glauben kann, sollte das das Stack-Argument vom übergebenen &oSDamageDescriptor sein :/ )

Code:

func void _DMG_OnDmg_Post() {
	Dmg_IsHit = MEM_ReadInt((ESP + 640) - 356 /* zBOOL bHasHit */);
	EDI = DMG_OnDmg(EBP, MEM_ReadInt(MEM_ReadInt(ESP+644)+8), EDI, +MEM_ReadInt((ESP + 640) + 4));
};

[Script] Eigene Schadensberechnung

Themen-Optionen

Berechtigungen