[mud-freak]

Unfortunately, magic or an arrow does not always fly where the sight is directed. Here are video examples.
https://youtu.be/roFmgCuwPjY
https://youtu.be/Jzy1amqbNKw

It is enough to be at the vob/mesh, as the object will fly down.

Thank you for the detailed examples. They illustrate the issue well. It seems that this only happens with obstacles that are very close to the hero - with their bounding boxes possibly intersecting. I thought that had been fixed, but I will gladly revisit this! Thanks for bringing this to my attention.

In a future update, can I still make the option to disable the camera, which is used in GFA? Some players prefer the original camera rather than the side.

I would strongly advise against it. The camera position is centered around the projectile origin, such that the projectile flies from the (horizontal) center of the camera exactly along its z-axis. That ensures that the projectile flies where aiming. Moving the camera to either side instead - for example to create shoulder-view - creates a so-called parallax effect. The projectile flies from left/right of the camera center and intersects only at the reticle. Anything in its path will not lie underneath the reticle. I really advise to leave the camera position as designed - I put a lot of thought into this.
I might have misunderstood - what do you mean with "rather than the side"?

And do not forget about the error when due to the reloading animation, the arrow may not fit into the slot. Here you can fix it only through a trigger cycle in which the slot would be checked, if it is empty, then add the type of ammunition used by the weapon to the hand slot.

Thank you for reminding me of this! I will look into it.

[N1kX]

I would strongly advise against it. The camera position is centered around the projectile origin, such that the projectile flies from the (horizontal) center of the camera exactly along its z-axis. That ensures that the projectile flies where aiming. Moving the camera to either side instead - for example to create shoulder-view - creates a so-called parallax effect. The projectile flies from left/right of the camera center and intersects only at the reticle. Anything in its path will not lie underneath the reticle. I really advise to leave the camera position as designed - I put a lot of thought into this.
I might have misunderstood - what do you mean with "rather than the side"?

Good. I understood. The camera on the side of the character doesn't annoy me, but I've seen a lot of players on streams who turn off and don't use free aiming in modifications (if it's available there) because they don't like this camera position.


That is, as an example from a video with an error. In the New Balance, the camera position does not change when spells/weapons are active.

Edit. In general, the camera position is not important. We are waiting for an update.



I also remind you that there is such a message in zspy when an arrow hits the portal

Fault: 0 Q: [start of stacktrace]
Fault: 0 Q:         MEMINT_HANDLEERROR(2, 'MEM_PtrToInst: ptr is NULL. Use MEM_NullToInst if that's what you want.') +   62 bytes
Fault: 0 Q:         MEM_WARN('MEM_PtrToInst: ptr is NULL. Use MEM_NullToInst if that's what you want.') +   21 bytes
Fault: 0 Q:         MEM_PTRTOINST(645599368)                                       +   77 bytes
Fault: 0 Q:         GFA_CC_GETCOLLISIONWITHWORLD_((instance)872528256, 4, '|NW_DRAGONISLAND_TEMPLE_03_DARK.TGA') +   58 bytes
Fault: 0 Q:         GFA_CC_PROJECTILECOLLISIONWITHWORLD()                          +  944 bytes
Fault: 0 Q:         MEM_CALLBYID(246088)                                           +  224 bytes
Fault: 0 Q:         _HOOK(701643960, 3, 751037600, 751037600, 20313684, 0, 1, 742324312, 0) +  940 bytes
Fault: 0 Q:         [UNKNOWN]                                                      +52076191 bytes
Fault: 0 Q: [end of stacktrace]
Warn:  0 Q: MEM_PtrToInst: ptr is NULL. Use MEM_NullToInst if that's what you want.

[Blubbler]

Für meine G1-Mod habe ich das Freie Zielen etwas verändert, weil ich es nervig fand, dass die Pfeile nicht dahin flogen, wo ich hinzielte. Stattdessen bewegt sich die Kamera, wenn man ungelernt ist.

[Video]

Hier sind jedenfalls die Code-Anpassungen, die ich dafür gemacht habe, falls mud-freak oder sonst jemand es vielleicht als alternativen Modus einbauen will.



In offsets_G1.d hinzufügen:

const int zCAICamera_horizontal_offset               = 68;  //0x0044

rangedAiming.d

var int LastTime; //needs to be set to 0 in Init_Global() !!
var int driftAngle;
var int camAI;

/*
 * Correct focus when not aiming. This includes preventing changes in focus collection during the shooting animation,
 * removing the reticle when not aiming and disabling focus collection all together when not aiming. This function
 * hooks oCAIHuman::BowMode() at an offset where the player model is explicitly not in the aiming animation.
 */
 
 func int GFA_RangedAiming_GetDrift (var C_Item weapon) {
	var int drift;
	drift = Hlp_Random(9);
	if 	(weapon.flags & ITEM_BOW)
	{
		if 		Npc_GetTalentSkill  (hero,NPC_TALENT_BOW) == 1
		{
			drift = (drift + 1) / 2;
		}
		else if	Npc_GetTalentSkill  (hero,NPC_TALENT_BOW) == 2
		{
			drift = 0;
		};
	}
	else if	(weapon.flags & ITEM_CROSSBOW)
	{
		if 		Npc_GetTalentSkill  (hero,NPC_TALENT_CROSSBOW) == 1
		{
			drift = (drift + 1) / 2;
		}
		else if	Npc_GetTalentSkill  (hero,NPC_TALENT_CROSSBOW) == 2
		{
			drift = 0;
		};
	}
	else
	{
		drift = 0;
	};
	if Hlp_Random(2) == 1 { drift = -1 * drift; };
	return drift;
};


func void GFA_RangedIdle() {
    if (GFA_ACTIVE > 1) {
        // In bow mode during transition between shooting and reloading
		
		//drift camera 20 times per second
		if AdeptExternal_PreciseTime() > LastTime + 1000/20  //new external function that returns the current time in milliseonds
		{
			LastTime = AdeptExternal_PreciseTime();
			var C_Item weapon;
			var int talent; var int weaponPtr;
			if (GFA_GetWeaponAndTalent(hero, _@(weaponPtr), _@(talent))) {
				weapon = _^(weaponPtr);
				var int drift;
				//vertical
				drift = GFA_RangedAiming_GetDrift(weapon);
				if (drift != 0) {
					driftAngle = fracf(GFA_MAX_RECOIL*drift, 100);

					// Get game camera
					camAI = MEM_ReadInt(zCAICamera__current);

					// Vertical drift: Classical upwards movement of the camera scaled by GFA_Recoil
					var int camYAngle; camYAngle = MEM_ReadInt(camAI+zCAICamera_elevation_offset);
					MEM_WriteInt(camAI+zCAICamera_elevation_offset, subf(camYAngle, driftAngle));
				};
				//horizontal
				drift = GFA_RangedAiming_GetDrift(weapon);
				if (drift != 0) {
					driftAngle = fracf(GFA_MAX_RECOIL*drift, 100);

					// Get game camera
					camAI = MEM_ReadInt(zCAICamera__current);

					// Vertical drift: Classical upwards movement of the camera scaled by GFA_Recoil
					var int camXAngle; camXAngle = MEM_ReadInt(camAI+zCAICamera_horizontal_offset);
					MEM_WriteInt(camAI+zCAICamera_horizontal_offset, subf(camXAngle, driftAngle));
				};
			};
		};
		
        // Shoot trace ray to update focus
        var int distance; var int target;
        GFA_AimRay(GFA_MAX_DIST, TARGET_TYPE_NPCS, _@(target), 0, _@(distance), 0);

        // Additionally, update reticle
        if (GFA_UPDATE_RET_SHOOT) {
            distance = roundf(divf(mulf(distance, FLOAT1C), mkf(GFA_MAX_DIST))); // Distance scaled between [0, 100]

            // Create reticle
            var int reticlePtr; reticlePtr = MEM_Alloc(sizeof_Reticle);
            var Reticle reticle; reticle = _^(reticlePtr);
            reticle.texture = ""; // Do not show reticle by default
            reticle.color = -1; // Do not set color by default
            reticle.size = 75; // Medium size by default

            // Retrieve reticle specs and draw/update it on screen
            GFA_GetRangedReticle_(target, distance, reticlePtr); // Retrieve reticle specs
            GFA_InsertReticle(reticlePtr);
            MEM_Free(reticlePtr);
			
			
	
        };

        // Allow to stop strafing (not to start strafing, that causes weird behavior)
        if (GFA_IsStrafing) {
            GFA_Strafe();
        };

    } else if (GFA_ACTIVE) {
        // In bow mode but not pressing down the aiming key
        GFA_RemoveReticle();

        if (GFA_NO_AIM_NO_FOCUS) {
            GFA_SetFocusAndTarget(0);
        };

        // Remove movement animations when not aiming
        GFA_AimMovement(0, "");
    };
};




/*
 * Interpolate the ranged aiming animation. This function hooks oCAIHuman::BowMode() just before
 * oCAniCtrl_Human::InterpolateCombineAni() to adjust the direction the ranged weapon is pointed in. Also the focus
 * collection is overwritten and the reticle is displayed.
 */
func void GFA_RangedAiming() {

    if (!GFA_ACTIVE) {
        return;
    } else if (GFA_ACTIVE < FMODE_FAR) {
        GFA_RemoveReticle();
        if (GFA_NO_AIM_NO_FOCUS) {
            GFA_SetFocusAndTarget(0);
        };
        return;
    };
	
	//drift camera 20 times per second
		if AdeptExternal_PreciseTime() > LastTime + 1000/20
		{
			LastTime = AdeptExternal_PreciseTime();
			var C_Item weapon;
			var int talent; var int weaponPtr;
			if (GFA_GetWeaponAndTalent(hero, _@(weaponPtr), _@(talent))) {
				weapon = _^(weaponPtr);
				var int drift;
				//vertical
				drift = GFA_RangedAiming_GetDrift(weapon);
				if (drift != 0) {
					driftAngle = fracf(GFA_MAX_RECOIL*drift, 100);

					// Get game camera
					camAI = MEM_ReadInt(zCAICamera__current);

					// Vertical drift: Classical upwards movement of the camera scaled by GFA_Recoil
					var int camYAngle; camYAngle = MEM_ReadInt(camAI+zCAICamera_elevation_offset);
					MEM_WriteInt(camAI+zCAICamera_elevation_offset, subf(camYAngle, driftAngle));
				};
				//horizontal
				drift = GFA_RangedAiming_GetDrift(weapon);
				if (drift != 0) {
					driftAngle = fracf(GFA_MAX_RECOIL*drift, 100);

					// Get game camera
					camAI = MEM_ReadInt(zCAICamera__current);

					// Vertical drift: Classical upwards movement of the camera scaled by GFA_Recoil
					var int camXAngle; camXAngle = MEM_ReadInt(camAI+zCAICamera_horizontal_offset);
					MEM_WriteInt(camAI+zCAICamera_horizontal_offset, subf(camXAngle, driftAngle));
				};
			};
		};
	

    // Shoot aim ray to retrieve the focus NPC and distance to it from the camera(!)
    var int distance; var int target;
    GFA_AimRay(GFA_MAX_DIST, TARGET_TYPE_NPCS, _@(target), 0, _@(distance), 0);
    distance = roundf(divf(mulf(distance, FLOAT1C), mkf(GFA_MAX_DIST))); // Distance scaled between [0, 100]

    // Create reticle
    var int reticlePtr; reticlePtr = MEM_Alloc(sizeof_Reticle);
    var Reticle reticle; reticle = _^(reticlePtr);
    reticle.texture = ""; // Do not show reticle by default
    reticle.color = -1; // Do not set color by default
    reticle.size = 75; // Medium size by default

    // Retrieve reticle specs and draw/update it on screen
    GFA_GetRangedReticle_(target, distance, reticlePtr); // Retrieve reticle specs
    GFA_InsertReticle(reticlePtr);
    MEM_Free(reticlePtr);

    // Pointing distance: Take the max distance, otherwise it looks strange on close range targets
    distance = mkf(GFA_MAX_DIST);

    // Get camera vob
    var zCVob camVob; camVob = _^(MEM_Game._zCSession_camVob);
    var zMAT4 camPos; camPos = _^(_@(camVob.trafoObjToWorld[0]));

    // Calculate position form distance and camera position (not from the player model!)
    var int pos[3];
    // Distance along out vector (facing direction) from camera position
    pos[0] = addf(camPos.v0[zMAT4_position], mulf(camPos.v0[zMAT4_outVec], distance));
    pos[1] = addf(camPos.v1[zMAT4_position], mulf(camPos.v1[zMAT4_outVec], distance));
    pos[2] = addf(camPos.v2[zMAT4_position], mulf(camPos.v2[zMAT4_outVec], distance));

    // Get aiming angles
    var oCNpc her; her = getPlayerInst();
    var int herPtr; herPtr = _@(her);
    var int angleX; var int angXptr; angXptr = _@(angleX);
    var int angleY; var int angYptr; angYptr = _@(angleY);
    var int posPtr; posPtr = _@(pos);
    const int call = 0;
    if (CALL_Begin(call)) {
        CALL_PtrParam(_@(angYptr));
        CALL_PtrParam(_@(angXptr)); // X angle not needed
        CALL_PtrParam(_@(posPtr));
        CALL__thiscall(_@(herPtr), oCNpc__GetAngles);
        call = CALL_End();
    };

    // Prevent multiplication with too small numbers. Would result in twitching while aiming
    if (lf(absf(angleY), 1048576000)) { // 0.25
        if (lf(angleY, FLOATNULL)) {
            angleY =  -1098907648; // -0.25
        } else {
            angleY = 1048576000; // 0.25
        };
    };

    // This following paragraph is inspired by oCAIHuman::BowMode() (0x6961FA in Gothic 2)
    angleY = negf(subf(mulf(angleY, /* 0.0055 */ 1001786197), FLOATHALF)); // Scale and flip Y [-90° +90°] to [+1 0]
    if (lf(angleY, FLOATNULL)) {
        // Maximum aim height (straight up)
        angleY = FLOATNULL;
    } else if (gf(angleY, FLOATONE)) {
        // Minimum aim height (down)
        angleY = FLOATONE;
    };

    // New aiming coordinates. Overwrite the arguments one and two passed to oCAniCtrl_Human::InterpolateCombineAni()
    MEM_WriteInt(ESP+20, FLOATHALF); // First argument: Always aim at center (azimuth). G2: esp+44h-30h, G1: esp+2Ch-18h
    ECX = angleY; // Second argument: New elevation
};


/*
 * Prevent locking the player in place when aiming in ranged combat while falling. This function hooks the end of
 * oCAIHuman::BowMode() to overwrite, whether aiming is active or not, to force reaction to falling in
 * oCAIHuman::_WalkCycle().
 */
func void GFA_RangedLockMovement() {
    if (!GFA_ACTIVE) {
        return;
    };

    if (GFA_ACTIVE < FMODE_FAR) {
        // Overwrite: Not aiming. Necessary for falling while strafing
        GFA_AimMovement(0, "");
        EAX = 0;
    } else {
        // Otherwise allow strafing and lock movement
        GFA_Strafe();
        EAX = 1; // Should not be necessary, just for safety
    };
};


/*
 * This function hooks the condition whether to start aiming or not. Setting EAX to one starts aiming, setting it to
 * zero prevents the initiation of aiming. This function hooks oCAIHuman::BowMode() at the aiming condition and
 * overwrites the outcome of the if-condition. Essentially, this function allows to start aiming while running.
 * Additionally, this function is used to detect the onset of aiming (so it is also used if GFA_STRAFING is disabled).
 */
func void GFA_RangedAimingCondition() {
    var oCNpc her; her = getPlayerInst();
    var int herPtr; herPtr = _@(her);
    var int aniCtrlPtr; aniCtrlPtr = her.anictrl;

    // Set onset for draw force and steady aim
    GFA_BowDrawOnset = MEM_Timer.totalTime;
    GFA_MouseMovedLast = MEM_Timer.totalTime;

    // If free aiming or aim movement are not enabled, revert to default condition (aiming only if standing)
    if (!GFA_ACTIVE) || (!GFA_STRAFING) {
        const int call = 0;
        if (CALL_Begin(call)) {
            CALL_PutRetValTo(_@(EAX));
            CALL__thiscall(_@(aniCtrlPtr), oCAniCtrl_Human__IsStanding);
            call = CALL_End();
        };
        return;
    } else if (GFA_ACTIVE < FMODE_FAR) {
        EAX = 0;
        return;
    };

    // There is no forward aim movement with Gothic 1 controls (do not allow aiming while moving forwards)
    if (GFA_ACTIVE_CTRL_SCHEME == 1) {
        if (MEM_KeyPressed(MEM_GetKey("keyUp"))) || (MEM_KeyPressed(MEM_GetSecondaryKey("keyUp"))) {
            EAX = 0;
            return;
        };
    };

    // Set body state to standing
    var int standing; standing = BS_STAND & ~BS_FLAG_INTERRUPTABLE & ~BS_FLAG_FREEHANDS;
    const int call2 = 0;
    if (CALL_Begin(call2)) {
        CALL_IntParam(_@(standing));
        CALL__thiscall(_@(herPtr), oCNpc__SetBodyState);
        call2 = CALL_End();
    };

    // Remove turning animations (player model sometimes gets stuck in turning animation)
    var int model; model = her._zCVob_visual;
    if (objCheckInheritance(model, zCModel__classDef)) {
        const int twenty = 20;
        const int call3 = 0;
        if (CALL_Begin(call3)) {
            CALL_IntParam(_@(twenty));
            CALL_IntParam(_@(twenty));
            CALL__thiscall(_@(model), zCModel__FadeOutAnisLayerRange);
            call3 = CALL_End();
        };
    };

    // Start aiming animation
    EAX = 1;
};

In rangedShooting die Chance zu treffen dafür auf 100 gesetzt (3 veränderte Zeilen):

[...]
    if (!GFA_GetWeaponAndTalent(hero, _@(weaponPtr), _@(talent))) {
        // On error return 50% accuracy
        return 100;
    };
[...]
            var int hitchance;
            if (GOTHIC_BASE_VERSION == 1) {
                // In Gothic 1, the hit chance is determined by dexterity (for both bows and crossbows)
                hitchance = 100;
[...]
        hit = TRUE;//lf(mkf(rand), hitChance); // rand < hitChance
[...]

Und in ranged.d

func int GFA_GetAccuracy(var C_Item weapon, var int talent) {

	return 100;

In settings.d

const int   GFA_TRUE_HITCHANCE     = FALSE;
const float GFA_ROTATION_SCALE     = 0.11;

[neocromicon]

Jo richtig geil, finde ich persönlich viel besser als das Original System! Danke für die Arbeit.

[mud-freak]

Für meine G1-Mod habe ich das Freie Zielen etwas verändert, weil ich es nervig fand, dass die Pfeile nicht dahin flogen, wo ich hinzielte. Stattdessen bewegt sich die Kamera, wenn man ungelernt ist.

Spannend! Danke fürs Teilen. Tatsächlich war so etwas schon einmal sehr ähnlich in GFA eingebaut. In einem Ansatz ging es um den Rückstoß beim Armbrustschießen (der jetzt lediglich vertikal stattfindet) und in einem anderen ging es um den Wunsch eines Lesers hier im Thread, für die Simulation von Zittern, wenn man zu lang zielt. Gelöst war es letztlich auf die gleiche Weise wie hier.
(Um der Terminologie deines Codes zu folgen nutze ich hier teilweise "vertikal" und "horizontal", obwohl es sich eigentlich um Elevation und Azimut handelt).
Die vertikale Abweichung findet sich heute noch im Rückstoß wieder. Ich habe mal in den Git-Commits gegraben, um den Grund zu finden, warum es die horizontale Abweichung nicht mehr gibt: Diese Implementation von Rotationen um horizontale und vertikale Achse der Kamera ist permanent. Während das bei einer vertikalen Verschiebung kein Problem ist, verursacht eine Rotation um die Y-Achse (horizontale Verschiebung) eine bleibende Diskrepanz zwischen Kamera Z und Spielermodell Z (Blickrichtung). D.h. die Kamera schaut in die eine Richtung, das Spielermodell allerdings in eine andere. Diese Diskrepanz bleibt dann auch nach dem Zielen/Schießen für den weiteren Verlauf des Spiels bestehen, selbst wenn sich der Kameramodus ändert. Zwar ziehst du hier aus einer pseudo-gleichmäßigen Verteilung um ungefähr null, trotzdem kann sich die Diskrepanz anhäufen, oder ist zumindest nicht null, wenn man aufhört zu zielen. In kurz: die Kamera folgt der Spielerausrichtung, der Spieler aber nicht der Kameraausrichtung. Man müsste die horizontale Verschiebung also eher über eine Rotation des Spielermodells implementieren, wollte man es problemlos umsetzen.

Implementation hin oder her, die Idee wäre ein Aspekt, den ich mir vorstellen könnte als Alternative zur Streuung in GFA aufzunehmen. Leider gibt es aber noch ein nicht unerhebliches Detail. Bei GFA ist es wichtig, dass die Trefferwahrscheinlichkeit beim freien Zielen etwa der ohne entspricht - aus Balancinggründen. Da die Berechnung in vanilla Gothic nicht linear ist (etwa stückweise linear aber durch zusätzliche Abhängigkeit von der Entfernung zum Ziel nicht ohne weiteres winkelbasierend darstellbar), ist die Trefferwahrscheinlichkeit in der aktuellen Version von GFA durch Streuung so unnatürlich weit und in vielen Kontexten unweigerlich schlichtweg falsch. Vor etwa einem Jahr hatte ich angefangen, das für alle Entfernungen besser zu modellieren, hatte aber leider nicht die Zeit das bisher zu veröffentlichen. Man müsste also auch hier bei der Kamerabewegung eine Formel finden, die durchschnittlich zu einer ähnlichen Trefferwahrscheinlichkeit führt wie ohne freies Zielen. Das könnte ich mir anschauen, wenn ich so etwas in GFA wieder aufnehme.

Da sich Streuung und Kamerakreisen beides auf Winkel reduzieren lässt, ist die Berechnung der Trefferwahrscheinlichkeit die gleiche und beides ließe sich sehr einfach als zwei Alternativen in GFA anbieten. Dabei ist die Kamerabewegung für direkteres visuelles Feedback auf jeden Fall schöner.

[N1kX]

I noticed that they may have forgotten to use r_max instead of hlp_random in the COLLECTABLE.D, COLLISION.D, and CRITICALHIT.D

[mud-freak]

I noticed that they may have forgotten to use r_max instead of hlp_random in the COLLECTABLE.D, COLLISION.D, and CRITICALHIT.D

Thanks for the note. If I recall correctly, I preferred Hlp_Random in the config scripts as they are more widely known than LeGo's RNG functions. There should be no noticeable difference. Both are based on linear congruential generators, only with different constants; Hlp_Random uses rand from Microsoft Visual C++ and LeGo implements the constants used in GCC.

[N1kX]

Thanks for the note. If I recall correctly, I preferred Hlp_Random in the config scripts as they are more widely known than LeGo's RNG functions. There should be no noticeable difference. Both are based on linear congruential generators, only with different constants; Hlp_Random uses rand from Microsoft Visual C++ and LeGo implements the constants used in GCC.

I'm just saying that in the new version of the zTrueChance plugin, Gratt will replace the Hlp_Random function with another one (a plus will also be added ranged combat), which will use the mt19937 method, not rand.

[Blubbler]

verursacht eine Rotation um die Y-Achse (horizontale Verschiebung) eine bleibende Diskrepanz zwischen Kamera Z und Spielermodell Z (Blickrichtung). D.h. die Kamera schaut in die eine Richtung, das Spielermodell allerdings in eine andere. Diese Diskrepanz bleibt dann auch nach dem Zielen/Schießen für den weiteren Verlauf des Spiels bestehen, selbst wenn sich der Kameramodus ändert.

Ich habe das Problem inzwischen so "gelöst", dass die Abweichung der X-Achse wieder auf 0 gesetzt wird, wenn sie zu groß wird.

Und ich habe auch mal den Patch direkt bearbeitet: https://upload.worldofplayers.de/files12/FreeAiming.zip
Dieser Patch enthält aber nur die neue Zielvariante.

In G2 könnte es also vom Balancing her problematisch sein. Das habe ich nicht getestet.
Vielleicht kann ja jemand Rückmeldung geben.

[fyryNy]

Hello, can GFA be modified so that in Gothic 1 you could aim with Right Mouse Button and shoot with Left Mouse Button, so it would be possible to move forward while aiming?

[mud-freak]

Hello, can GFA be modified so that in Gothic 1 you could aim with Right Mouse Button and shoot with Left Mouse Button, so it would be possible to move forward while aiming?

Hi, thanks for the input. That would be something that can be added to the to-do list. Whether I will implemented, I cannot guarantee.

[fyryNy]

Would it be hard to make it work that way?