/*
 * G2 Free Aim v0.1.2 - Free aiming for the video game Gothic 2 by Piranha Bytes
 * Copyright (C) 2016  mud-freak (@szapp)
 *
 * This file is part of G2 Free Aim.
 * <http://github.com/szapp/g2freeAim>
 *
 * G2 Free Aim is free software: you can redistribute it and/or modify
 * it under the terms of the MIT License.
 * On redistribution this notice must remain intact and all copies must
 * identify the original author.
 *
 * G2 Free Aim is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * MIT License for more details.
 *
 * You should have received a copy of the MIT License
 * along with G2 Free Aim.  If not, see <http://opensource.org/licenses/MIT>.
 *
 *
 *   WARNING: Do not edit this file. All necessary adjustments can and should be performed in freeAim\config.d
 *   You should not need to edit anything in this file. Possible updates and revisions will replace this file.
 *   Proceed at you own risk: On modifying this file, free aiming will most certainly become unstable.
 */

/* Free aim settings, do not modify! Change the settings in freeAim\config.d */
const string FREEAIM_VERSION            = "G2 Free Aim v0.1.2"; // Do not change under any circumstances
const int    FREEAIM_REUSE_PROJECTILES  = 1;                    // Enable collection and re-using of shot projectiles
const int    FREEAIM_DISABLE_SPELLS     = 0;                    // If true, free aiming is disabled for spells
const int    FREEAIM_DRAWTIME_MAX       = 1200;                 // Max draw time (ms): When is the bow fully drawn
const int    FREEAIM_TRAJECTORY_ARC_MAX = 400;                  // Max time (ms) after which the trajectory drops off
const float  FREEAIM_ROTATION_SCALE     = 0.16;                 // Turn rate. Non-weapon mode: 0.2 (zMouseRotationScale)
const float  FREEAIM_SCATTER_DEG        = 2.2;                  // Maximum scatter radius in degrees
const int    FREEAIM_TRIGGER_COLL_FIX   = 1;                    // Apply trigger collision fix (disable collision)
const string FREEAIM_CAMERA             = "CamModFreeAim";      // CCamSys_Def script instance for free aim
const int    FREEAIM_CAMERA_X_SHIFT     = 0;                    // Camera is set to shoulderview (not recommended)
const int    FREEAIM_HITDETECTION_EXP   = 0;                    // Additional hit detection test (EXPERIMENTAL)
const int    FREEAIM_DEBUG_WEAKSPOT     = 0;                    // Visualize weakspot bbox and trajectory
const int    FREEAIM_DEBUG_TRACERAY     = 0;                    // Visualize trace ray bboxes and trajectory
const int    FREEAIM_DEBUG_CONSOLE      = 1;                    // Console command for debugging. Turn off in final mod
const float  FREEAIM_PROJECTILE_GRAVITY = 0.1;                  // The gravity decides how fast the projectile drops
const int    FREEAIM_DRAWTIME_READY     = 650;                  // Time offset for readying the bow. Fixed by animation
const int    FREEAIM_DRAWTIME_RELOAD    = 1110;                 // Time offset for reloading the bow. Fixed by animation
const int    FREEAIM_RETICLE_MIN_SIZE   = 32;                   // Smallest reticle size in pixels
const int    FREEAIM_RETICLE_MAX_SIZE   = 64;                   // Biggest reticle size in pixels
const string FREEAIM_TRAIL_FX           = "freeAim_TRAIL";      // Trailstrip FX. Should not be changed
const string FREEAIM_BREAK_FX           = "freeAim_DESTROY";    // FX of projectile breaking on impact with world
const int    FREEAIM_MAX_DIST           = 5000;                 // 50m. Shooting/reticle adjustments. Do not change
const int    FREEAIM_ACTIVE_PREVFRAME   = 0;                    // Internal. Do not change
const int    FREEAIM_FOCUS_SPELL_FREE   = 0;                    // Internal. Do not change
const int    FREEAIM_FOCUS_COLLECTION   = 1;                    // Internal. Do not change (change in ini-file)
const int    FREEAIM_ARROWAI_REDIRECT   = 0;                    // Used to redirect call-by-reference var. Do not change
const int    FLOAT1C                    = 1120403456;           // 100 as float
const int    FLOAT3C                    = 1133903872;           // 300 as float
const int    FLOAT1K                    = 1148846080;           // 1000 as float
var   int    freeAimDebugWSBBox[6];                             // Weaksopt boundingbox for debug visualization
var   int    freeAimDebugWSTrj[6];                              // Projectile trajectory for debug visualization
var   int    freeAimDebugTRBBox[6];                             // Trace ray intersection for debug visualization
var   int    freeAimDebugTRTrj[6];                              // Trace ray trajectory
var   int    freeAimReticleHndl;                                // Holds the handle of the reticle
var   int    freeAimBowDrawOnset;                               // Time onset of drawing the bow
const int    FREEAIM_G2CTRL_PREVFRAME   = 0;                    // Internal. Do not change

/* Helper class: Critical hit definitions */
class Weakspot {
    var string node;
    var int dimX;
    var int dimY;
    var int bDmg;
};

/* Helper class: Reticle definitions */
class Reticle {
    var string texture;
    var int size;
    var int color;
};

/* All addresses used (gothic2). In case of a gothic1 port: There are a lot of hardcoded address offsets in the code! */
const int zCVob__SetPositionWorld                 = 6404976; //0x61BB70
const int zCVob__GetRigidBody                     = 6285664; //0x5FE960
const int zCVob__TraceRay                         = 6291008; //0x5FFE40
const int zCArray_zCVob__IsInList                 = 7159168; //0x6D3D80
const int zCWorld__TraceRayNearestHit_Vob         = 6430624; //0x621FA0
const int oCWorld__AddVobAsChild                  = 7863856; //0x77FE30
const int zCMaterial__vtbl                        = 8593940; //0x832214
const int zCTrigger_vtbl                          = 8627196; //0x83A3FC
const int zCTriggerScript_vtbl                    = 8582148; //0x82F404
const int zString_CamModRanged                    = 9234704; //0x8CE910
const int zString_CamModMagic                     = 9235048; //0x8CEA68
const int oCAniCtrl_Human__Turn                   = 7005504; //0x6AE540
const int oCAniCtrl_Human__GetLayerAni            = 7011712; //0x6AFD80
const int oCNpc__GetAngles                        = 6820528; //0x6812B0
const int oCNpc__SetFocusVob                      = 7547744; //0x732B60
const int oCNpc__SetEnemy                         = 7556032; //0x734BC0
const int oCNpc__GetModel                         = 7571232; //0x738720
const int oCItem___CreateNewInstance              = 7423040; //0x714440
const int oCItem__InitByScript                    = 7412688; //0x711BD0
const int oCItem__InsertEffect                    = 7416896; //0x712C40
const int oCItem__RemoveEffect                    = 7416832; //0x712C00
const int oCMag_Book__GetSelectedSpell            = 4683648; //0x477780
const int zCModel__SearchNode                     = 5758960; //0x57DFF0
const int zCModel__GetBBox3DNodeWorld             = 5738736; //0x5790F0
const int zCModel__GetNodePositionWorld           = 5738816; //0x579140
//const int zTBBox3D__Draw                          = 5529312; //0x545EE0
//const int zCLineCache__Line3D                     = 5289040; //0x50B450
//const int zlineCache                              = 9257720; //0x8D42F8
const int oCGame__s_bUseOldControls               = 9118144; //0x8B21C0
const int mouseEnabled                            = 9248108; //0x8D1D6C
const int mouseSensX                              = 9019720; //0x89A148
const int mouseDeltaX                             = 9246300; //0x8D165C
const int projectileDeflectOffNpcAddr             = 6949734; //0x6A0B66
//const int zCWorld__AdvanceClock                   = 6447328; //0x6260E0 // Hook length 10
const int oCAniCtrl_Human__InterpolateCombineAni  = 7037296; //0x6B6170 // Hook length 5
const int oCAIArrow__SetupAIVob                   = 6951136; //0x6A10E0 // Hook length 6
const int oCAIArrow__CanThisCollideWith           = 6952080; //0x6A1490 // Hook length 7
const int oCAIHuman__BowMode                      = 6905600; //0x695F00 // Hook length 6
const int oCAIArrowBase__DoAI                     = 6948416; //0x6A0640 // Hook length 7
const int onArrowHitNpcAddr                       = 6949832; //0x6A0BC8 // Hook length 5
const int onArrowHitVobAddr                       = 6949929; //0x6A0C29 // Hook length 5
const int onArrowHitStatAddr                      = 6949460; //0x6A0A54 // Hook length 5
const int onArrowCollVobAddr                      = 6949440; //0x6A0C18 // Hook length 5
const int onArrowCollStatAddr                     = 6949912; //0x6A0A40 // Hook length 5
const int onArrowHitChanceAddr                    = 6953483; //0x6A1A0B // Hook length 5
const int onArrowDamageAddr                       = 6953621; //0x6A1A95 // Hook length 7
const int onDmgAnimationAddr                      = 6774593; //0x675F41 // Hook length 9
const int oCNpcFocus__SetFocusMode                = 7072800; //0x6BEC20 // Hook length 7
const int oCAIHuman__MagicMode                    = 4665296; //0x472FD0 // Hook length 7
const int oCSpell__Setup_484BA9                   = 4737961; //0x484BA9 // Hook length 6
const int spellAutoTurnAddr                       = 4665539; //0x4730C3 // Hook length 6
const int mouseUpdate                             = 5062907; //0x4D40FB // Hook length 5
const int oCAIHuman__BowMode_695F2B               = 6905643; //0x695F2B
const int oCAIHuman__BowMode_6962F2               = 6906610; //0x6962F2
const int oCAIHuman___WalkCycle_6925892           = 6925892; //0x69AE44

/* Initialize free aim framework */
func void freeAim_Init() {
    const int hookFreeAim = 0;
    if (!hookFreeAim) {
        MEM_Info(""); // Copyright notice in zSpy
        var int s; s = SB_New();
        SB("     "); SB(FREEAIM_VERSION); SB(", Copyright "); SBc(169 /* (C) */); SB(" 2016  mud-freak (@szapp)");
        MEM_Info(SB_ToString()); SB_Destroy();
        MEM_Info("     <http://github.com/szapp/g2freeAim>");
        MEM_Info("     Released under the MIT License.");
        MEM_Info("     For more details see <http://opensource.org/licenses/MIT>.");
        MEM_Info("");
        MEM_Call(freeAimInitConstants); // Customized settings
		MemoryProtectionOverride(oCAIHuman__BowMode_695F2B, 6); // G2 Controls   0F 84 60 04 00 00   jz  loc_00696391
        MemoryProtectionOverride(oCAIHuman__BowMode_6962F2, 2); // G2 Controls   6A 03               push  3
        MemoryProtectionOverride(oCAIHuman___WalkCycle_6925892, 2); // G2 Ctrls  6A 05               push  5
        CC_Register(freeAimVersion, "freeaim version", "print freeaim version info");
        CC_Register(freeAimLicense, "freeaim license", "print freeaim license info");
        CC_Register(freeAimInfo, "freeaim info", "print freeaim info");
        HookEngineF(oCAniCtrl_Human__InterpolateCombineAni, 5, freeAimAnimation); // Update aiming animation
        HookEngineF(oCAIArrow__SetupAIVob, 6, freeAimSetupProjectile); // Set projectile direction and trajectory
        HookEngineF(oCAIHuman__BowMode, 6, freeAimManageReticle); // Manage the reticle (on/off)
        HookEngineF(oCNpcFocus__SetFocusMode, 7, freeAimSwitchMode); // Manage the reticle (on/off) and draw force
        HookEngineF(mouseUpdate, 5, freeAimManualRotation); // Update the player model rotation by mouse input
        HookEngineF(oCAIArrowBase__DoAI, 7, freeAimWatchProjectile); // AI loop for each projectile
        HookEngineF(onArrowDamageAddr, 7, freeAimDetectCriticalHit); // Critical hit detection
        HookEngineF(onArrowHitChanceAddr, 5, freeAimDoNpcHit); // Decide whether a projectile hits or not
        MemoryProtectionOverride(projectileDeflectOffNpcAddr, 2); // Collision behavior on npcs
        HookEngineF(onArrowCollVobAddr, 5, freeAimOnArrowCollide); // Collision behavior on non-npc vob material
        HookEngineF(onArrowCollStatAddr, 5, freeAimOnArrowCollide); // Collision behavior on static world material
        HookEngineF(onDmgAnimationAddr , 9, freeAimDmgAnimation); // Disable damage animation while aiming
        if (!FREEAIM_DISABLE_SPELLS) {
            HookEngineF(oCAIHuman__MagicMode, 7, freeAimSpellReticle); // Manage focus collection and reticle
            HookEngineF(oCSpell__Setup_484BA9, 6, freeAimSetupSpell); // Set spell fx direction and trajectory
            HookEngineF(spellAutoTurnAddr, 6, freeAimDisableSpellAutoTurn); // Prevent auto turning towards target
        };
        if (FREEAIM_DEBUG_CONSOLE) || (FREEAIM_DEBUG_WEAKSPOT) || (FREEAIM_DEBUG_TRACERAY) { // Debug visualization
            HookEngineF(zCWorld__AdvanceClock, 10, freeAimVisualizeWeakspot); // FrameFunctions hook too early
            HookEngineF(zCWorld__AdvanceClock, 10, freeAimVisualizeTraceRay);
            if (FREEAIM_DEBUG_CONSOLE) { // Enable console command for debugging
                CC_Register(freeAimDebugWeakspot, "debug freeaim weakspot", "turn debug visualization on/off");
                CC_Register(freeAimDebugTraceRay, "debug freeaim traceray", "turn debug visualization on/off");
            };
        };
        if (FREEAIM_REUSE_PROJECTILES) { // Because of balancing issues, this is a constant and not a variable
            HookEngineF(onArrowHitNpcAddr, 5, freeAimOnArrowHitNpc); // Put projectile into inventory
            HookEngineF(onArrowHitVobAddr, 5, freeAimOnArrowGetStuck); // Keep projectile alive when stuck in vob
            HookEngineF(onArrowHitStatAddr, 5, freeAimOnArrowGetStuck); // Keep projectile alive when stuck in world
        };
        if (FREEAIM_TRIGGER_COLL_FIX) { // Because by default all triggers react to objects, this is a setting
            HookEngineF(oCAIArrow__CanThisCollideWith, 7, freeAimTriggerCollisionCheck); // Fix trigger collision bug
        };
        if (!MEM_GothOptExists("FREEAIM", "enabled")) { MEM_SetGothOpt("FREEAIM", "enabled", "1"); }; // If not set
        if (!MEM_GothOptExists("FREEAIM", "focusEnabled")) { MEM_SetGothOpt("FREEAIM", "focusEnabled", "1"); }
        else if (!STR_ToInt(MEM_GetGothOpt("FREEAIM", "focusEnabled"))) {
            FREEAIM_FOCUS_COLLECTION = 0; }; // No focuscollection (performance) not recommended
        r_DefaultInit(); // Start rng for aiming accuracy
        hookFreeAim = 1;
    };
    MEM_Info(ConcatStrings(FREEAIM_VERSION, " initialized successfully."));
};

/* Return the active spell instance */
func MEMINT_HelperClass freeAimGetActiveSpellInst(var C_Npc npc) {
    if (Npc_GetActiveSpell(npc) == -1) {
        var C_Spell ret; ret = MEM_NullToInst();
        MEMINT_StackPushInst(ret);
        return;
    };
    var int magBookPtr; magBookPtr = MEM_ReadInt(_@(npc)+2324); //0x0914 oCNpc.mag_book
    const int call = 0;
    if (CALL_Begin(call)) {
        CALL__thiscall(_@(magBookPtr), oCMag_Book__GetSelectedSpell);
        call = CALL_End();
    };
    _^(CALL_RetValAsPtr()+128); //0x0080 oCSpell.C_Spell
};

/* Return whether a spell is eligible for free aiming */
func int freeAimSpellEligible(var C_Spell spell) {
    if (FREEAIM_DISABLE_SPELLS) || (!_@(spell)) { return FALSE; };
    if (spell.targetCollectAlgo != TARGET_COLLECT_FOCUS_FALLBACK_NONE)
    || (!spell.canTurnDuringInvest) || (!spell.canChangeTargetDuringInvest) {
        return FALSE;
    };
    return TRUE; // All other cases
};

/* Update internal settings when turning free aim on/off in the options */
func void freeAimUpdateSettings(var int on) {
    MEM_Info("Updating internal free aim settings");
    MEM_InitGlobalInst(); // Important as this function will be called during level change, otherwise the game crashes
    if (on) {
        Focus_Ranged.npc_azi = 15.0; // Set stricter focus collection
        MEM_WriteString(zString_CamModRanged, STR_Upper(FREEAIM_CAMERA)); // New camera mode, upper case is important
        if (!FREEAIM_DISABLE_SPELLS) { MEM_WriteString(zString_CamModMagic, STR_Upper(FREEAIM_CAMERA)); };
        FREEAIM_ACTIVE_PREVFRAME = 1;
    } else {
        Focus_Ranged.npc_azi = 45.0; // Reset ranged focus collection to standard
        Focus_Magic.npc_azi = 45.0;
        Focus_Magic.item_prio = -1;
        FREEAIM_FOCUS_SPELL_FREE = -1;
        MEM_WriteString(zString_CamModRanged, "CAMMODRANGED"); // Restore camera mode, upper case is important
        MEM_WriteString(zString_CamModMagic, "CAMMODMAGIC"); // Also for spells
        MEM_WriteByte(projectileDeflectOffNpcAddr, /*74*/ 116); // Reset to default collision behavior on npcs
        MEM_WriteByte(projectileDeflectOffNpcAddr+1, /*3B*/ 59); // jz to 0x6A0BA3
        FREEAIM_ACTIVE_PREVFRAME = -1;
    };
};

/* Update internal settings for Gothic 2 controls */
func void freeAimUpdateSettingsG2Ctrl(var int on) {
    MEM_Info("Updating internal free aim settings for Gothic 2 controls");
    if (on) { // Gothic 2 controls and free aiming enabled: Mimic the Gothic 1 controls but change the keys
        MEM_WriteByte(oCAIHuman__BowMode_695F2B, ASMINT_OP_nop); // Skip jump to Gothic 2 controls
        MEM_WriteByte(oCAIHuman__BowMode_695F2B+1, ASMINT_OP_nop);
        MEM_WriteByte(oCAIHuman__BowMode_695F2B+2, ASMINT_OP_nop);
        MEM_WriteByte(oCAIHuman__BowMode_695F2B+3, ASMINT_OP_nop);
        MEM_WriteByte(oCAIHuman__BowMode_695F2B+4, ASMINT_OP_nop);
        MEM_WriteByte(oCAIHuman__BowMode_695F2B+5, ASMINT_OP_nop);
        MEM_WriteByte(oCAIHuman__BowMode_6962F2+1, 5); // Overwrite shooting key to action button
        MEM_WriteByte(oCAIHuman___WalkCycle_6925892+1, /*19*/ 25); // Overwrite aiming key to secondary (parry) button
        FREEAIM_G2CTRL_PREVFRAME = 1;
    } else { // Gothic 2 controls or free aiming disabled: Revert to original Gothic 2 controls
        MEM_WriteByte(oCAIHuman__BowMode_695F2B, /*0F*/ 15); // Revert to G2 controls to default: jz loc_00696391
        MEM_WriteByte(oCAIHuman__BowMode_695F2B+1, /*84*/ 132);
        MEM_WriteByte(oCAIHuman__BowMode_695F2B+2, /*60*/ 96);
        MEM_WriteByte(oCAIHuman__BowMode_695F2B+3, /*04*/ 4);
        MEM_WriteByte(oCAIHuman__BowMode_695F2B+4, /*00*/ 0);
        MEM_WriteByte(oCAIHuman__BowMode_695F2B+5, /*00*/ 0);
        MEM_WriteByte(oCAIHuman__BowMode_6962F2+1, 3); // Revert to default: push 3
        MEM_WriteByte(oCAIHuman___WalkCycle_6925892+1, 5); // Revert to default: push 5
        FREEAIM_G2CTRL_PREVFRAME = -1;
    };
};

/* Check whether free aiming should be activated */
func int freeAimIsActive() {
    if (!STR_ToInt(MEM_GetGothOpt("FREEAIM", "enabled"))) // Free aiming is disabled in the menu
    || (!MEM_ReadInt(mouseEnabled)) { // Mouse controls are disabled
        if (FREEAIM_ACTIVE_PREVFRAME != -1) { freeAimUpdateSettings(0); }; // Update internal settings (turn off)
        if (FREEAIM_G2CTRL_PREVFRAME != -1) { freeAimUpdateSettingsG2Ctrl(0); }; // Disable extended Gothic 2 Controls
        return 0;
    };
    if (FREEAIM_ACTIVE_PREVFRAME != 1) { freeAimUpdateSettings(1); }; // Update internal settings (turn on)
    // Everything below is only reached if free aiming is enabled (but not necessarily active)
    if (MEM_Game.pause_screen) { return 0; }; // Only when playing
    if (!InfoManager_HasFinished()) { return 0; }; // Not in dialogs
    if (!Npc_IsInFightMode(hero, FMODE_FAR)) && (!Npc_IsInFightMode(hero, FMODE_MAGIC)) { return 0; };
    // Everything below is only reached if free aiming is enabled and active (player is in respective fight mode)
    var int keyStateAiming1; var int keyStateAiming2; // Depending on control scheme either action or blocking key
    if (MEM_ReadInt(oCGame__s_bUseOldControls)) {
        keyStateAiming1 = MEM_KeyState(MEM_GetKey("keyAction")); // A bit much, but the keys are also needed below
        keyStateAiming2 = MEM_KeyState(MEM_GetSecondaryKey("keyAction"));
        if (FREEAIM_G2CTRL_PREVFRAME != -1) { freeAimUpdateSettingsG2Ctrl(0); }; // Disable extended Gothic 2 controls
    } else {
        keyStateAiming1 = MEM_KeyState(MEM_GetKey("keyParade"));
        keyStateAiming2 = MEM_KeyState(MEM_GetSecondaryKey("keyParade"));
        if (FREEAIM_G2CTRL_PREVFRAME != 1) { freeAimUpdateSettingsG2Ctrl(1); }; // Enable extended Gothic 2 controls
    };
    var int keyPressed; keyPressed = (keyStateAiming1 == KEY_PRESSED) || (keyStateAiming1 == KEY_HOLD)
        || (keyStateAiming2 == KEY_PRESSED) || (keyStateAiming2 == KEY_HOLD);  // Pressing or holding the aiming key
    if (Npc_IsInFightMode(hero, FMODE_MAGIC)) {
        if (FREEAIM_DISABLE_SPELLS) { return 0; }; // If free aiming for spells is disabled
        if (MEM_ReadInt(oCGame__s_bUseOldControls)) && (!keyPressed) { return 0; }; // G1 controls require action key
        var C_Spell spell; spell = freeAimGetActiveSpellInst(hero);
        if (!freeAimSpellEligible(spell)) { // Check if the active spell supports free aiming
            if (FREEAIM_FOCUS_SPELL_FREE != -1) {
                Focus_Magic.npc_azi = 45.0; // Reset ranged focus collection
                Focus_Magic.item_prio = -1;
                FREEAIM_FOCUS_SPELL_FREE = -1;
            };
            return 0;
        };
        if (FREEAIM_FOCUS_SPELL_FREE != 1) {
            Focus_Magic.npc_azi = 15.0; // Set stricter focus collection
            Focus_Magic.item_prio = 0;
            FREEAIM_FOCUS_SPELL_FREE = 1;
        };
        return FMODE_MAGIC;
    };
    if (!keyPressed) { return 0; }; // If aiming key is not pressed or held
    // Get onset for drawing the bow - right when pressing down the aiming key
    if (keyStateAiming1 == KEY_PRESSED) || (keyStateAiming2 == KEY_PRESSED) {
        freeAimBowDrawOnset = MEM_Timer.totalTime + FREEAIM_DRAWTIME_READY; };
    return FMODE_FAR;
};

/* Return texture file name for an animated texture. numFrames files must exist with the postfix '_[frameNo].tga' */
func string freeAimAnimateReticleByTime(var string fileName, var int fps, var int numFrames) {
    var int frameTime; frameTime = 1000/fps; // Time of one frame
    var int cycle; cycle = (MEM_Timer.totalTime % (frameTime*numFrames)) / frameTime; // Cycle through [0, numFrames]
    var string prefix; prefix = STR_SubStr(fileName, 0, STR_Len(fileName)-4); // Base name (without extension)
    var string postfix;
    if (cycle < 10) { postfix = ConcatStrings("0", IntToString(cycle)); } else { postfix = IntToString(cycle); };
    return ConcatStrings(ConcatStrings(ConcatStrings(prefix, "_"), postfix), ".TGA");
};

/* Return texture file name for an animated texture. numFrames files must exist with the postfix '_[frameNo].tga' */
func string freeAimAnimateReticleByPercent(var string fileName, var int percent, var int numFrames) {
    var int cycle; cycle = roundf(mulf(mkf(percent), divf(mkf(numFrames-1), FLOAT1C)));
    var string prefix; prefix = STR_SubStr(fileName, 0, STR_Len(fileName)-4); // Base name (without extension)
    var string postfix;
    if (cycle < 10) { postfix = ConcatStrings("0", IntToString(cycle)); } else { postfix = IntToString(cycle); };
    return ConcatStrings(ConcatStrings(ConcatStrings(prefix, "_"), postfix), ".TGA");
};

/* Hide reticle */
func void freeAimRemoveReticle() {
    if (Hlp_IsValidHandle(freeAimReticleHndl)) { View_Close(freeAimReticleHndl); };
};

/* Draw reticle */
func void freeAimInsertReticle(var int reticlePtr) {
    var Reticle reticle; reticle = _^(reticlePtr); var int size;
    if (!Hlp_StrCmp(reticle.texture, "")) {
        size = (((FREEAIM_RETICLE_MAX_SIZE-FREEAIM_RETICLE_MIN_SIZE)*(reticle.size))/100)+FREEAIM_RETICLE_MIN_SIZE;
        if (size > FREEAIM_RETICLE_MAX_SIZE) { size = FREEAIM_RETICLE_MAX_SIZE; }
        else if (size < FREEAIM_RETICLE_MIN_SIZE) { size = FREEAIM_RETICLE_MIN_SIZE; };
        var zCView screen; screen = _^(MEM_Game._zCSession_viewport);
        if (!Hlp_IsValidHandle(freeAimReticleHndl)) { // Create reticle if it does not exist
            freeAimReticleHndl = View_CreateCenterPxl(screen.psizex/2, screen.psizey/2, size, size);
            View_SetTexture(freeAimReticleHndl, reticle.texture);
            View_SetColor(freeAimReticleHndl, reticle.color);
            View_Open(freeAimReticleHndl);
        } else {
            if (!Hlp_StrCmp(View_GetTexture(freeAimReticleHndl), reticle.texture)) { // Update its texture
                View_SetTexture(freeAimReticleHndl, reticle.texture);
            };
            if (View_GetColor(freeAimReticleHndl) != reticle.color) { // Update its color
                View_SetColor(freeAimReticleHndl, reticle.color);
            };
            var zCView crsHr; crsHr = _^(getPtr(freeAimReticleHndl));
            if (crsHr.psizex != size) || (screen.psizex/2 != centerX) { // Update its size and re-position it to center
                var int centerX; centerX = screen.psizex/2;
                View_ResizePxl(freeAimReticleHndl, size, size);
                View_MoveToPxl(freeAimReticleHndl, screen.psizex/2-(size/2), screen.psizey/2-(size/2));
            };
            if (!crsHr.isOpen) { View_Open(freeAimReticleHndl); };
        };
    } else { freeAimRemoveReticle(); };
};

/* Attach an FX to the aim vob */
func void freeAimAttachFX(var string effectInst) {
    var int vobPtr; vobPtr = MEM_SearchVobByName("AIMVOB");
    if (!vobPtr) { return; };
    MEM_WriteString(vobPtr+564, effectInst); // oCItem.effect
    const int call = 0;
    if (CALL_Begin(call)) {
        CALL__thiscall(_@(vobPtr), oCItem__InsertEffect);
        call = CALL_End();
    };
};

/* Detach the FX of the aim vob */
func void freeAimDetachFX() {
    var int vobPtr; vobPtr = MEM_SearchVobByName("AIMVOB");
    if (!vobPtr) { return; };
    if (Hlp_StrCmp(MEM_ReadString(vobPtr+564), "")) { return; };
    const int call = 0;
    if (CALL_Begin(call)) {
        CALL__thiscall(_@(vobPtr), oCItem__RemoveEffect);
        call = CALL_End();
    };
    MEM_WriteString(vobPtr+564, ""); // oCItem.effect
};

/* Decide when to draw reticle or when to hide it */
func void freeAimManageReticle() {
    if (!freeAimIsActive()) {
        freeAimDetachFX();
        freeAimRemoveReticle();
    };
};

/* Switching between weapon modes (sometimes called several times in a row) */
func void freeAimSwitchMode() {
    freeAimBowDrawOnset = MEM_Timer.totalTime + FREEAIM_DRAWTIME_READY; // Reset draw force onset
    freeAimManageReticle();
};

/* Mouse handling for manually turning the player model by mouse input */
func void freeAimManualRotation() {
    if (!freeAimIsActive()) { return; };
    var int deltaX; deltaX = mulf(mkf(MEM_ReadInt(mouseDeltaX)), MEM_ReadInt(mouseSensX)); // Get mouse change in x
    if (deltaX == FLOATNULL) { return; }; // Only rotate if there was movement along x position
    deltaX = mulf(deltaX, castToIntf(FREEAIM_ROTATION_SCALE)); // Turn rate
    var int hAniCtrl; hAniCtrl = MEM_ReadInt(_@(hero)+2432); // oCNpc.anictrl
    const int call = 0; var int null;
    if (CALL_Begin(call)) {
        CALL_IntParam(_@(null)); // 0 = disable turn animation (there is none while aiming anyways)
        CALL_FloatParam(_@(deltaX));
        CALL__thiscall(_@(hAniCtrl), oCAniCtrl_Human__Turn);
        call = CALL_End();
    };
};

/* Manipulate the position of the aim vob (only for spells) */
func void freeAimManipulateAimVobPos(var int posPtr) {
    var int spell; spell = Npc_GetActiveSpell(hero);
    if (spell == -1) { return; };
    MEM_PushIntParam(spell);
    MEM_Call(freeAimShiftAimVob);
    var int pushed; pushed = MEM_PopIntResult();
    if (pushed) {
        pushed = mkf(pushed); // Amount to push the aim vob along the out vector of the camera
        var zMAT4 camPos; camPos = _^(MEM_ReadInt(MEM_ReadInt(MEMINT_oGame_Pointer_Address)+20)+60);
        MEM_WriteInt(posPtr+0, addf(MEM_ReadInt(posPtr+0), mulf(camPos.v0[2], pushed)));
        MEM_WriteInt(posPtr+4, addf(MEM_ReadInt(posPtr+4), mulf(camPos.v1[2], pushed)));
        MEM_WriteInt(posPtr+8, addf(MEM_ReadInt(posPtr+8), mulf(camPos.v2[2], pushed)));
    };
};

/* Create and set aim vob to position */
func int freeAimSetupAimVob(var int posPtr) {
    var int vobPtr; vobPtr = MEM_SearchVobByName("AIMVOB"); // Arrow needs target vob
    if (!vobPtr) { // Does not exist
        MEM_Info("freeAimSetupAimVob: Creating aim vob."); // Should be printed only once ever
        CALL__cdecl(oCItem___CreateNewInstance); // This actually allocates the memory, so no need to care about freeing
        vobPtr = CALL_RetValAsPtr();
        MEM_WriteString(vobPtr+16, "AIMVOB"); // zCVob._zCObject_objectName
        CALL_PtrParam(_@(MEM_Vobtree));
        CALL_PtrParam(vobPtr);
        CALL__thiscall(_@(MEM_World), oCWorld__AddVobAsChild);
        MEM_WriteInt(vobPtr+260, 3105); // zCVob.bitfield[0] (ignored by trace ray, no collision)
    };
    MEM_CopyBytes(_@(hero)+60, vobPtr+60, 64); // Include rotation
    freeAimManipulateAimVobPos(posPtr); // Shift the aim vob (if desired)
    const int call4 = 0; // Set position to aim vob
    if (CALL_Begin(call4)) {
        CALL_PtrParam(_@(posPtr)); // Update aim vob position
        CALL__thiscall(_@(vobPtr), zCVob__SetPositionWorld);
        call4 = CALL_End();
    };
    return vobPtr;
};

/* Shoot aim-tailored trace ray. Do no use for other purposes. This function is customized for aiming. */
func int freeAimRay(var int distance, var int focusType, var int vobPtr, var int posPtr, var int distPtr,
        var int trueDistPtr) {
    // Flags: (VOB_IGNORE_NO_CD_DYN | POLY_IGNORE_TRANSP | VOB_IGNORE_PROJECTILES | POLY_TEST_WATER)
    const int flags = (1<<0) | (1<<8) | (1<<9) | (1<<14); // Do not change (will make trace ray unstable)
    var zMAT4 camPos; camPos = _^(MEM_ReadInt(MEM_ReadInt(MEMINT_oGame_Pointer_Address)+20)+60); //0=right, 2=out, 3=pos
    var int herPtr; herPtr = _@(hero);
    // Shift the start point for the trace ray beyond the player model. Necessary, because if zooming out,
    // (1) there might be something between camera and hero and (2) the maximum aiming distance is off.
    var int dist; dist = sqrtf(addf(addf( // Distance between camera and player model (does not care about cam offset)
        sqrf(subf(MEM_ReadInt(herPtr+72), camPos.v0[3])),
        sqrf(subf(MEM_ReadInt(herPtr+88), camPos.v1[3]))),
        sqrf(subf(MEM_ReadInt(herPtr+104), camPos.v2[3]))));
    if (FREEAIM_CAMERA_X_SHIFT) { // Shifting the camera (shoulderview) is not recommended. Aiming is harder + less fps?
        // This makes the distance mentioned above more complex and requires the calculation of a point-line distance
        // For illustration: http://mathworld.wolfram.com/Point-LineDistance3-Dimensional.html
        var int line[6]; // Line with two points along the camera right vector at the level of the player model
        line[0] = subf(MEM_ReadInt(herPtr+72),  mulf(camPos.v0[0], FLOAT1K)); // Left of player model
        line[1] = subf(MEM_ReadInt(herPtr+88),  mulf(camPos.v1[0], FLOAT1K));
        line[2] = subf(MEM_ReadInt(herPtr+104), mulf(camPos.v2[0], FLOAT1K));
        line[3] = addf(MEM_ReadInt(herPtr+72),  mulf(camPos.v0[0], FLOAT1K)); // Right of player model
        line[4] = addf(MEM_ReadInt(herPtr+88),  mulf(camPos.v1[0], FLOAT1K));
        line[5] = addf(MEM_ReadInt(herPtr+104), mulf(camPos.v2[0], FLOAT1K));
        var int u[3]; var int v[3]; // Subtract both points of the line from the camera position
        u[0] = subf(camPos.v0[3], line[0]); v[0] = subf(camPos.v0[3], line[3]);
        u[1] = subf(camPos.v1[3], line[1]); v[1] = subf(camPos.v1[3], line[4]);
        u[2] = subf(camPos.v2[3], line[2]); v[2] = subf(camPos.v2[3], line[5]);
        var int crossProd[3]; // Cross-product
        crossProd[0] = subf(mulf(u[1], v[2]), mulf(u[2], v[1]));
        crossProd[1] = subf(mulf(u[2], v[0]), mulf(u[0], v[2]));
        crossProd[2] = subf(mulf(u[0], v[1]), mulf(u[1], v[0]));
        dist = sqrtf(addf(addf(sqrf(crossProd[0]), sqrf(crossProd[1])), sqrf(crossProd[2])));
        dist = divf(dist, mkf(2000)); // Divide area of triangle by length between the points on the line
    };
    var int traceRayVec[6];
    traceRayVec[0] = addf(camPos.v0[3], mulf(camPos.v0[2], dist)); // Start ray from here
    traceRayVec[1] = addf(camPos.v1[3], mulf(camPos.v1[2], dist));
    traceRayVec[2] = addf(camPos.v2[3], mulf(camPos.v2[2], dist));
    traceRayVec[3] = mulf(camPos.v0[2], mkf(distance)); // Direction-/to-vector of ray
    traceRayVec[4] = mulf(camPos.v1[2], mkf(distance));
    traceRayVec[5] = mulf(camPos.v2[2], mkf(distance));
    var int fromPosPtr; fromPosPtr = _@(traceRayVec);
    var int dirPosPtr; dirPosPtr = _@(traceRayVec)+12;
    var int worldPtr; worldPtr = _@(MEM_World);
    const int call = 0;
    if (CALL_Begin(call)) {
        CALL_IntParam(_@(flags)); // Trace ray flags
        CALL_PtrParam(_@(herPtr)); // Ignore player model
        CALL_PtrParam(_@(dirPosPtr)); // Trace ray direction
        CALL__fastcall(_@(worldPtr), _@(fromPosPtr), zCWorld__TraceRayNearestHit_Vob);
        call = CALL_End();
    };
    var int found; found = CALL_RetValAsInt(); // Did the trace ray hit
    if (!found) && (!MEM_World.foundVob) { // Fix the intersection if there was no hit (trace ray is inconsistent)
        MEM_World.foundIntersection[0] = addf(traceRayVec[0], traceRayVec[3]);
        MEM_World.foundIntersection[1] = addf(traceRayVec[1], traceRayVec[4]);
        MEM_World.foundIntersection[2] = addf(traceRayVec[2], traceRayVec[5]);
    };
    var int foundFocus; foundFocus = 0; // Is the focus vob in the trace ray vob list
    var int potentialVob; potentialVob = MEM_ReadInt(herPtr+2476); // oCNpc.focus_vob // Focus vob by focus collection
    if (potentialVob) { // Check if collected focus matches the desired focus type
        var int runDetailedTraceRay; runDetailedTraceRay = 0; // Second trace ray only if focus vob is reasonable
        if (!focusType) { // No focus vob (still a trace ray though)
            foundFocus = 0;
        } else if (focusType != TARGET_TYPE_ITEMS) && (Hlp_Is_oCNpc(potentialVob)) { // Validate focus vob, if it is npc
            var C_Npc target; target = _^(potentialVob);
            MEM_PushInstParam(target); // Function is not defined yet at time of parsing:
            MEM_Call(C_NpcIsUndead); // C_NpcIsUndead(target);
            var int npcIsUndead; npcIsUndead = MEM_PopIntResult();
            if ((focusType == TARGET_TYPE_NPCS) // Any npc
            || ((focusType == TARGET_TYPE_ORCS) && target.guild > GIL_SEPERATOR_ORC) // Only focus orcs
            || ((focusType == TARGET_TYPE_HUMANS) && target.guild < GIL_SEPERATOR_HUM) // Only focus humans
            || ((focusType == TARGET_TYPE_UNDEAD) && npcIsUndead)) // Only focus undead npcs
            && (!Npc_IsInState(target, ZS_Unconscious)) // Do not allow focusing npcs that are down
            && (!Npc_IsInState(target, ZS_MagicSleep))
            && (!Npc_IsDead(target)) {
                var int potVobPtr; potVobPtr = _@(potentialVob);
                var int voblist; voblist = _@(MEM_World.traceRayVobList_array);
                const int call2 = 0;
                if (CALL_Begin(call2)) { // More complicated for npcs: Check if npc is in trace ray vob list
                    CALL_PtrParam(_@(potVobPtr)); // Explanation: Npcs are never HIT by a trace ray (only collected)
                    CALL__thiscall(_@(voblist), zCArray_zCVob__IsInList);
                    call2 = CALL_End();
                };
                runDetailedTraceRay = CALL_RetValAsInt(); // Will perform detailed trace ray if npc was in vob list
            };
        } else if (focusType <= TARGET_TYPE_ITEMS) && (Hlp_Is_oCItem(potentialVob)) {
            runDetailedTraceRay = 1; // Will perform detailed trace ray
        };
        if (runDetailedTraceRay) { // If focus collection is reasonable, run a more detailed examination
            // zCWorld::TraceRayNearestHit (0x621D82 in g2)
            flags = (1<<0) | (1<<2); // (zTRACERAY_VOB_IGNORE_NO_CD_DYN | zTRACERAY_VOB_BBOX) // Important!
            var int trRep; trRep = MEM_Alloc(40); // sizeof_zTTraceRayReport
            const int call3 = 0;
            if (CALL_Begin(call3)) {
                CALL_PtrParam(_@(trRep)); // zTTraceRayReport
                CALL_IntParam(_@(flags)); // Trace ray flags
                CALL_PtrParam(_@(dirPosPtr)); // Trace ray direction
                CALL_PtrParam(_@(fromPosPtr)); // Start vector
                CALL__thiscall(_@(potentialVob), zCVob__TraceRay); // This is a vob specific trace ray
                call3 = CALL_End();
            };
            if (CALL_RetValAsInt()) { // Got a hit: Update trace ray report
                MEM_World.foundVob = potentialVob;
                MEM_CopyWords(trRep+12, _@(MEM_World.foundIntersection), 3); // 0x0C zVEC3
                foundFocus = potentialVob; // Confirmed focus vob
            };
            MEM_Free(trRep); // Free the report
        };
    };
    if (foundFocus != potentialVob) { // If focus vob changed by the validation above
        const int call4 = 0; // Set the focus vob properly: reference counter
        if (CALL_Begin(call4)) {
            CALL_PtrParam(_@(foundFocus)); // If no valid focus was found, this will remove the focus (foundFocus == 0)
            CALL__thiscall(_@(herPtr), oCNpc__SetFocusVob);
            call4 = CALL_End();
        };
    };
    if (MEM_ReadInt(herPtr+1176)) { //0x0498 oCNpc.enemy
        const int call5 = 0; var int null; // Remove the enemy properly: reference counter
        if (CALL_Begin(call5)) {
            CALL_PtrParam(_@(null)); // Always remove oCNpc.enemy. Target will be set to aimvob when shooting
            CALL__thiscall(_@(herPtr), oCNpc__SetEnemy);
            call5 = CALL_End();
        };
    };
    // Debug visualization
    if (FREEAIM_DEBUG_TRACERAY) {
        freeAimDebugTRBBox[0] = subf(MEM_World.foundIntersection[0], mkf(10));
        freeAimDebugTRBBox[1] = subf(MEM_World.foundIntersection[1], mkf(10));
        freeAimDebugTRBBox[2] = subf(MEM_World.foundIntersection[2], mkf(10));
        freeAimDebugTRBBox[3] = addf(freeAimDebugTRBBox[0], mkf(20));
        freeAimDebugTRBBox[4] = addf(freeAimDebugTRBBox[1], mkf(20));
        freeAimDebugTRBBox[5] = addf(freeAimDebugTRBBox[2], mkf(20));
        freeAimDebugTRTrj[0] = traceRayVec[0];
        freeAimDebugTRTrj[1] = traceRayVec[1];
        freeAimDebugTRTrj[2] = traceRayVec[2];
        freeAimDebugTRTrj[3] = addf(traceRayVec[0], traceRayVec[3]);
        freeAimDebugTRTrj[4] = addf(traceRayVec[1], traceRayVec[4]);
        freeAimDebugTRTrj[5] = addf(traceRayVec[2], traceRayVec[5]);
    };
    // Write call-by-reference variables
    if (vobPtr) { MEM_WriteInt(vobPtr, MEM_World.foundVob); };
    if (posPtr) { MEM_CopyWords(_@(MEM_World.foundIntersection), posPtr, 3); };
    if (distPtr) { // Distance between intersection and player model
        distance = sqrtf(addf(addf(
            sqrf(subf(MEM_World.foundIntersection[0], traceRayVec[0])),
            sqrf(subf(MEM_World.foundIntersection[1], traceRayVec[1]))),
            sqrf(subf(MEM_World.foundIntersection[2], traceRayVec[2]))));
        MEM_WriteInt(distPtr, distance);
    };
    if (trueDistPtr) { // Distance between intersection and camera
        distance = sqrtf(addf(addf(
            sqrf(subf(MEM_World.foundIntersection[0], camPos.v0[3])),
            sqrf(subf(MEM_World.foundIntersection[1], camPos.v1[3]))),
            sqrf(subf(MEM_World.foundIntersection[2], camPos.v2[3]))));
        MEM_WriteInt(trueDistPtr, distance);
    };
    return found;
};

/* Internal helper function for freeAimGetReticleRanged() for ranged combat */
func void freeAimGetReticleRanged_(var int target, var int distance, var int returnPtr) {
    var C_Npc targetNpc; var int talent; var C_Item weapon; // Retrieve target npc, weapon and talent
    if (Npc_IsInFightMode(hero, FMODE_FAR)) { weapon = Npc_GetReadiedWeapon(hero); }
    else if (Npc_HasEquippedRangedWeapon(hero)) { weapon = Npc_GetEquippedRangedWeapon(hero); }
    else { MEM_Error("freeAimGetReticleRanged_: No valid weapon equipped/readied!"); return; }; // Should never happen
    if (weapon.flags & ITEM_BOW) { talent = hero.HitChance[NPC_TALENT_BOW]; } // Bow talent
    else if (weapon.flags & ITEM_CROSSBOW) { talent = hero.HitChance[NPC_TALENT_CROSSBOW]; } // Crossbow talent
    else { MEM_Error("freeAimGetReticleRanged_: No valid weapon equipped/readied!"); return; };
    if (Hlp_Is_oCNpc(target)) { targetNpc = _^(target); } else { targetNpc = MEM_NullToInst(); };
    // Call customized function
    MEM_PushInstParam(targetNpc);
    MEM_PushInstParam(weapon);
    MEM_PushIntParam(talent);
    MEM_PushIntParam(distance);
    MEM_PushIntParam(returnPtr);
    MEM_Call(freeAimGetReticleRanged); // freeAimGetReticleRanged(targetNpc, weapon, talent, distance, returnPtr);
};

/* Update aiming animation. Hook oCAniCtrl_Human::InterpolateCombineAni */
func void freeAimAnimation() {
    if (freeAimIsActive() != FMODE_FAR) { return; };
    var int herPtr; herPtr = _@(hero);
    var int distance; var int target;
    if (FREEAIM_FOCUS_COLLECTION) { // Set focus npc if there is a valid one under the reticle
        freeAimRay(FREEAIM_MAX_DIST, TARGET_TYPE_NPCS, _@(target), 0, _@(distance), 0); // Shoot ray and retrieve info
        distance = roundf(divf(mulf(distance, FLOAT1C), mkf(FREEAIM_MAX_DIST))); // Distance scaled between [0, 100]
    } else { // More performance friendly. Here, there will be NO focus, otherwise it gets stuck on npcs.
        const int call4 = 0; var int null; // Set the focus vob properly: reference counter
        if (CALL_Begin(call4)) {
            CALL_PtrParam(_@(null)); // This will remove the focus
            CALL__thiscall(_@(herPtr), oCNpc__SetFocusVob);
            call4 = CALL_End();
        };
        const int call5 = 0; // Remove the enemy properly: reference counter
        if (CALL_Begin(call5)) {
            CALL_PtrParam(_@(null)); // Always remove oCNpc.enemy. Target will be set to aimvob when shooting
            CALL__thiscall(_@(herPtr), oCNpc__SetEnemy);
            call5 = CALL_End();
        };
        distance = 25; // No distance check ever. Set it to medium distance
        target = 0; // No focus target ever
    };
    var int autoAlloc[7]; var Reticle reticle; reticle = _^(_@(autoAlloc)); // Gothic takes care of freeing this ptr
    MEM_CopyWords(_@s(""), _@(autoAlloc), 5); // reticle.texture (reset string) // Do not show reticle by default
    reticle.color = -1; // Do not set color by default
    reticle.size = 75; // Medium size by default
    freeAimGetReticleRanged_(target, distance, _@(reticle)); // Retrieve reticle specs
    freeAimInsertReticle(_@(reticle)); // Draw/update reticle
    var zMAT4 camPos; camPos = _^(MEM_ReadInt(MEM_ReadInt(MEMINT_oGame_Pointer_Address)+20)+60); //0=right, 2=out, 3=pos
    var int pos[3]; // The position is calculated from the camera, not the player model
    pos[0] = addf(camPos.v0[3], mulf(camPos.v0[2], mkf(FREEAIM_MAX_DIST)));
    pos[1] = addf(camPos.v1[3], mulf(camPos.v1[2], mkf(FREEAIM_MAX_DIST)));
    pos[2] = addf(camPos.v2[3], mulf(camPos.v2[2], mkf(FREEAIM_MAX_DIST)));
    // Get aiming angles
    var int angleX; var int angXptr; angXptr = _@(angleX);
    var int angleY; var int angYptr; angYptr = _@(angleY);
    var int posPtr; posPtr = _@(pos); // So many pointers because it is a recyclable call
    const int call3 = 0;
    if (CALL_Begin(call3)) {
        CALL_PtrParam(_@(angYptr));
        CALL_PtrParam(_@(angXptr)); // X angle not needed
        CALL_PtrParam(_@(posPtr));
        CALL__thiscall(_@(herPtr), oCNpc__GetAngles);
        call3 = CALL_End();
    };
    if (lf(absf(angleY), 1048576000)) { // Prevent multiplication with too small numbers. Would result in aim twitching
        if (lf(angleY, FLOATNULL)) { angleY =  -1098907648; } // -0.25
        else { angleY = 1048576000; }; // 0.25
    };
    // This following paragraph is essentially "copied" from oCAIHuman::BowMode (0x695F00 in g2)
    angleY = negf(subf(mulf(angleY, 1001786197), FLOATHALF)); // Scale and flip Y [-90° +90°] to [+1 0]
    if (lef(angleY, FLOATNULL)) { angleY = FLOATNULL; } // Maximum aim height (straight up)
    else if (gef(angleY, 1065353216)) { angleY = 1065353216; }; // Minimum aim height (down)
    // New aiming coordinates. Overwrite the arguments passed to oCAniCtrl_Human::InterpolateCombineAni
    MEM_WriteInt(ESP+4, FLOATHALF); // Always aim at center (x angle)
    MEM_WriteInt(ESP+8, angleY);
};

/* Internal helper function for freeAimGetDrawForce() */
func int freeAimGetDrawForce_() {
    var int talent; var C_Item weapon; // Retrieve the weapon first to distinguish between (cross-)bow talent
    if (Npc_IsInFightMode(hero, FMODE_FAR)) { weapon = Npc_GetReadiedWeapon(hero); }
    else if (Npc_HasEquippedRangedWeapon(hero)) { weapon = Npc_GetEquippedRangedWeapon(hero); }
    else { MEM_Error("freeAimGetDrawForce_: No valid weapon equipped/readied!"); return -1; }; // Should never happen
    if (weapon.flags & ITEM_BOW) { talent = hero.HitChance[NPC_TALENT_BOW]; } // Bow talent
    else if (weapon.flags & ITEM_CROSSBOW) { talent = hero.HitChance[NPC_TALENT_CROSSBOW]; } // Crossbow talent
    else { MEM_Error("freeAimGetDrawForce_: No valid weapon equipped/readied!"); return -1; };
    // Call customized function
    MEM_PushInstParam(weapon);
    MEM_PushIntParam(talent);
    MEM_Call(freeAimGetDrawForce); // freeAimGetDrawForce(weapon, talent);
    var int drawForce; drawForce = MEM_PopIntResult();
    if (drawForce > 100) { drawForce = 100; } else if (drawForce < 0) { drawForce = 0; }; // Must be in [0, 100]
    return drawForce;
};

/* Internal helper function for freeAimGetAccuracy() */
func int freeAimGetAccuracy_() {
    var int talent; var C_Item weapon; // Retrieve the weapon first to distinguish between (cross-)bow talent
    if (Npc_IsInFightMode(hero, FMODE_FAR)) { weapon = Npc_GetReadiedWeapon(hero); }
    else if (Npc_HasEquippedRangedWeapon(hero)) { weapon = Npc_GetEquippedRangedWeapon(hero); }
    else { MEM_Error("freeAimGetAccuracy_: No valid weapon equipped/readied!"); return -1; }; // Should never happen
    if (weapon.flags & ITEM_BOW) { talent = hero.HitChance[NPC_TALENT_BOW]; } // Bow talent
    else if (weapon.flags & ITEM_CROSSBOW) { talent = hero.HitChance[NPC_TALENT_CROSSBOW]; } // Crossbow talent
    else { MEM_Error("freeAimGetAccuracy_: No valid weapon equipped/readied!"); return -1; };
    // Call customized function
    MEM_PushInstParam(weapon);
    MEM_PushIntParam(talent);
    MEM_Call(freeAimGetAccuracy); // freeAimGetAccuracy(weapon, talent);
    var int accuracy; accuracy = MEM_PopIntResult();
    if (accuracy < 1) { accuracy = 1; } else if (accuracy > 100) { accuracy = 100; }; // Limit to [1, 100] // Div by 0!
    return accuracy;
};

/* Internal helper function for freeAimScaleInitialDamage() */
func int freeAimScaleInitialDamage_(var int basePointDamage) {
    var int talent; var C_Item weapon; // Retrieve the weapon first to distinguish between (cross-)bow talent
    if (Npc_IsInFightMode(hero, FMODE_FAR)) { weapon = Npc_GetReadiedWeapon(hero); }
    else if (Npc_HasEquippedRangedWeapon(hero)) { weapon = Npc_GetEquippedRangedWeapon(hero); }
    else { MEM_Error("freeAimScaleInitialDamage_: No valid weapon equipped/readied!"); return basePointDamage; };
    if (weapon.flags & ITEM_BOW) { talent = hero.HitChance[NPC_TALENT_BOW]; } // Bow talent
    else if (weapon.flags & ITEM_CROSSBOW) { talent = hero.HitChance[NPC_TALENT_CROSSBOW]; } // Crossbow talent
    else { MEM_Error("freeAimScaleInitialDamage_: No valid weapon equipped/readied!"); return basePointDamage; };
    // Call customized function
    MEM_PushIntParam(basePointDamage);
    MEM_PushInstParam(weapon);
    MEM_PushIntParam(talent);
    MEM_Call(freeAimScaleInitialDamage); // freeAimScaleInitialDamage(basePointDamage, weapon, talent);
    basePointDamage = MEM_PopIntResult();
    if (basePointDamage < 0) { basePointDamage = 0; }; // No negative damage
    return basePointDamage;
};

/* Set the projectile direction and trajectory. Hook oCAIArrow::SetupAIVob */
func void freeAimSetupProjectile() {
    var int projectile; projectile = MEM_ReadInt(ESP+4);  // First argument is the projectile
    var C_Npc shooter; shooter = _^(MEM_ReadInt(ESP+8)); // Second argument is shooter
    if (FREEAIM_ACTIVE_PREVFRAME != 1) || (!Npc_IsPlayer(shooter)) { return; }; // Only if player and if fa WAS active
    // 1st: Set base damage of projectile // oCItem.damage[DAM_INDEX_POINT];
    var int baseDamage; baseDamage = MEM_ReadStatArr(projectile+364, DAM_INDEX_POINT);
    var int newBaseDamage; newBaseDamage = freeAimScaleInitialDamage_(baseDamage);
    MEM_WriteStatArr(projectile+364, DAM_INDEX_POINT, newBaseDamage);
    // 2nd: Manipulate aiming accuracy (scatter): Rotate target position (azimuth, elevation)
    var int distance; freeAimRay(FREEAIM_MAX_DIST, TARGET_TYPE_NPCS, 0, 0, 0, _@(distance)); // Trace ray intersection
    var int accuracy; accuracy = freeAimGetAccuracy_(); // Change the accuracy calculation in that function, not here!
    if (accuracy > 100) { accuracy = 100; } else if (accuracy < 1) { accuracy = 1; }; // Prevent devision by zero
    var int bias; bias = castToIntf(FREEAIM_SCATTER_DEG);
    var int slope; slope = negf(divf(castToIntf(FREEAIM_SCATTER_DEG), FLOAT1C));
    var int angleMax; angleMax = roundf(mulf(addf(mulf(slope, mkf(accuracy)), bias), FLOAT1K)); // y = slope*acc+bias
    var int angleY; angleY = fracf(r_MinMax(-angleMax, angleMax), 1000); // Degrees azimuth
    angleMax = roundf(sqrtf(subf(sqrf(mkf(angleMax)), sqrf(mulf(angleY, FLOAT1K))))); // sqrt(angleMax^2-angleY^2)
    var int angleX; angleX = fracf(r_MinMax(-angleMax, angleMax), 1000); // Degrees elevation (restrict to circle)
    var zMAT4 camPos; camPos = _^(MEM_ReadInt(MEM_ReadInt(MEMINT_oGame_Pointer_Address)+20)+60); //0=right, 2=out, 3=pos
    var int pos[3]; pos[0] = FLOATNULL; pos[1] = FLOATNULL; pos[2] = distance;
    SinCosApprox(Print_ToRadian(angleX)); // Rotate around x-axis (elevation scatter)
    pos[1] = mulf(negf(pos[2]), sinApprox); // y*cos - z*sin = y'
    pos[2] = mulf(pos[2], cosApprox);       // y*sin + z*cos = z'
    SinCosApprox(Print_ToRadian(angleY)); // Rotate around y-axis (azimuth scatter)
    pos[0] = mulf(pos[2], sinApprox); //  x*cos + z*sin = x'
    pos[2] = mulf(pos[2], cosApprox); // -x*sin + z*cos = z'
    var int newPos[3]; // Rotation (translation into local coordinate system of camera)
    newPos[0] = addf(addf(mulf(camPos.v0[0], pos[0]), mulf(camPos.v0[1], pos[1])), mulf(camPos.v0[2], pos[2]));
    newPos[1] = addf(addf(mulf(camPos.v1[0], pos[0]), mulf(camPos.v1[1], pos[1])), mulf(camPos.v1[2], pos[2]));
    newPos[2] = addf(addf(mulf(camPos.v2[0], pos[0]), mulf(camPos.v2[1], pos[1])), mulf(camPos.v2[2], pos[2]));
    pos[0] = addf(camPos.v0[3], newPos[0]);
    pos[1] = addf(camPos.v1[3], newPos[1]);
    pos[2] = addf(camPos.v2[3], newPos[2]);
    // 3rd: Set projectile drop-off (by draw force)
    const int call2 = 0;
    if (CALL_Begin(call2)) {
        CALL__thiscall(_@(projectile), zCVob__GetRigidBody); // Get ridigBody this way, it will be properly created
        call2 = CALL_End();
    };
    var int rBody; rBody = CALL_RetValAsInt(); // zCRigidBody*
    var int drawForce; drawForce = freeAimGetDrawForce_(); // Modify the draw force in that function, not here!
    var int gravityMod; gravityMod = FLOATONE; // Gravity only modified on short draw time
    if (drawForce < 25) { gravityMod = castToIntf(3.0); }; // Very short draw time increases gravity
    var int dropTime; dropTime = (drawForce*(FREEAIM_TRAJECTORY_ARC_MAX*100))/10000;
    FF_ApplyOnceExtData(freeAimDropProjectile, dropTime, 1, rBody); // When to hit the projectile with gravity
    freeAimBowDrawOnset = MEM_Timer.totalTime + FREEAIM_DRAWTIME_RELOAD; // Reset draw timer
    MEM_WriteInt(rBody+236, mulf(castToIntf(FREEAIM_PROJECTILE_GRAVITY), gravityMod)); // Set gravity (but not enabled)
    if (Hlp_Is_oCItem(projectile)) && (Hlp_StrCmp(MEM_ReadString(projectile+564), "")) { // Projectile has no FX
        MEM_WriteString(projectile+564, FREEAIM_TRAIL_FX); // Set trail strip fx for better visibility
        const int call3 = 0;
        if (CALL_Begin(call3)) {
            CALL__thiscall(_@(projectile), oCItem__InsertEffect);
            call3 = CALL_End();
        };
    };
    // 4th: Setup the aim vob
    var int vobPtr; vobPtr = freeAimSetupAimVob(_@(pos));
    // Print info to zSpy
    var int s; s = SB_New();
    SB("freeAimSetupProjectile: ");
    SB("drawforce="); SBi(drawForce); SB("% ");
    SB("accuracy="); SBi(accuracy); SB("% ");
    SB("scatter="); SB(STR_Prefix(toStringf(angleX), 5)); SBc(176 /* deg */);
    SB("/"); SB(STR_Prefix(toStringf(angleY), 5)); SBc(176 /* deg */); SB(" ");
    SB("init-basedamage="); SBi(newBaseDamage); SB("/"); SBi(baseDamage);
    MEM_Info(SB_ToString()); SB_Destroy();
    MEM_WriteInt(ESP+12, vobPtr); // Overwrite the third argument (target vob) passed to oCAIArrow::SetupAIVob
};

/* This function is timed by draw force and is responsible for applying gravity to a projectile */
func void freeAimDropProjectile(var int rigidBody) {
    if (!rigidBody) || (!MEM_ReadInt(rigidBody)) { return; };
    if (MEM_ReadInt(rigidBody+188) == FLOATNULL) // zCRigidBody.velocity[3]
    && (MEM_ReadInt(rigidBody+192) == FLOATNULL)
    && (MEM_ReadInt(rigidBody+196) == FLOATNULL) { return; }; // Do not add gravity if projectile already stopped moving
    MEM_WriteByte(rigidBody+256, 1); // Turn on gravity (zCRigidBody.bitfield)
};

/* Internal helper function for freeAimHitRegNpc() */
func int freeAimHitRegNpc_(var C_Npc target) {
    var C_Item weapon; weapon = MEM_NullToInst(); // Daedalus pseudo locals
    if (Npc_IsInFightMode(hero, FMODE_FAR)) { weapon = Npc_GetReadiedWeapon(hero); }
    else if (Npc_HasEquippedRangedWeapon(hero)) { weapon = Npc_GetEquippedRangedWeapon(hero); };
    var int material; material = -1; // No armor
    if (Npc_HasEquippedArmor(target)) {
        var C_Item armor; armor = Npc_GetEquippedArmor(target);
        material = armor.material;
    };
    // Call customized function
    MEM_PushInstParam(target);
    MEM_PushInstParam(weapon);
    MEM_PushIntParam(material);
    MEM_Call(freeAimHitRegNpc); // freeAimHitRegNpc(target, weapon, material);
    return MEM_PopIntResult();
};

/* Internal helper function for freeAimHitRegWld() */
func int freeAimHitRegWld_(var C_Npc shooter, var int material, var string texture) {
    var C_Item weapon; weapon = MEM_NullToInst(); // Daedalus pseudo locals
    if (Npc_IsInFightMode(shooter, FMODE_FAR)) { weapon = Npc_GetReadiedWeapon(shooter); }
    else if (Npc_HasEquippedRangedWeapon(shooter)) { weapon = Npc_GetEquippedRangedWeapon(shooter); };
    // Call customized function
    MEM_PushInstParam(shooter);
    MEM_PushInstParam(weapon);
    MEM_PushIntParam(material);
    MEM_PushStringParam(texture);
    MEM_Call(freeAimHitRegWld); // freeAimHitRegWld(shooter, weapon, material, texture);
    return MEM_PopIntResult();
};

/* Determine the hit chance. For the player it's always 100%. True hit chance is calculated in freeAimGetAccuracy() */
func void freeAimDoNpcHit() {
    var int hitChance; hitChance = MEM_ReadInt(ESP+24); // esp+1ACh+194h
    var C_Npc target; target = _^(MEM_ReadInt(ESP+28)); // esp+1ACh+190h // oCNpc*
    var C_Npc shooter; shooter = _^(MEM_ReadInt(EBP+92)); // ebp+5Ch // oCNpc*
    var int projectile; projectile = MEM_ReadInt(EBP+88); // ebp+58h // oCItem*
    if (FREEAIM_ACTIVE_PREVFRAME != 1) || (!Npc_IsPlayer(shooter)) { // Default hitchance for npcs or if fa is disabled
        MEM_WriteByte(projectileDeflectOffNpcAddr, /*74*/ 116); // Reset to default collision behavior on npcs
        MEM_WriteByte(projectileDeflectOffNpcAddr+1, /*3B*/ 59); // jz to 0x6A0BA3
        return;
    };
    var int intersection; intersection = 1; // Hit registered (positive hit determined by the engine at this point)
    if (FREEAIM_HITDETECTION_EXP) { // Additional hit detection test (EXPERIMENTAL). Will lead to some hits not detected
        intersection = 0; // Check here if "any" point along the line of the projectile direction lies inside the bbox
        var zTBBox3D targetBBox; targetBBox = _^(_@(target)+124); // oCNpc.bbox3D
        var int dir[3]; // Direction of collision line along the right-vector of projectile (projectile flies sideways)
        dir[0] = MEM_ReadInt(projectile+60); dir[1] = MEM_ReadInt(projectile+76); dir[2] = MEM_ReadInt(projectile+92);
        var int line[6]; // Collision line
        line[0] = addf(MEM_ReadInt(projectile+ 72), mulf(dir[0], FLOAT3C)); // Start 3m behind the projectile
        line[1] = addf(MEM_ReadInt(projectile+ 88), mulf(dir[1], FLOAT3C)); // So far because of bbox at close range
        line[2] = addf(MEM_ReadInt(projectile+104), mulf(dir[2], FLOAT3C));
        var int i; i=0; var int iter; iter = 700/5; // 7meters
        while(i <= iter); i += 1; // Walk along the line in steps of 5cm
            line[3] = subf(line[0], mulf(dir[0], mkf(i*5))); // Next point along the collision line
            line[4] = subf(line[1], mulf(dir[1], mkf(i*5)));
            line[5] = subf(line[2], mulf(dir[2], mkf(i*5)));
            if (lef(targetBBox.mins[0], line[3])) && (lef(targetBBox.mins[1], line[4]))
            && (lef(targetBBox.mins[2], line[5])) && (gef(targetBBox.maxs[0], line[3]))
            && (gef(targetBBox.maxs[1], line[4])) && (gef(targetBBox.maxs[2], line[5])) {
                intersection = 1; break; }; // Current point is inside the bbox
        end;
    };
    var int hit;
    if (intersection) { // By default this is always true
        var int collision; collision = freeAimHitRegNpc_(target); // 0=destroy, 1=stuck, 2=deflect
        if (collision == 2) { // Deflect (no damage)
            MEM_WriteByte(projectileDeflectOffNpcAddr, ASMINT_OP_nop); // Skip npc armor collision check, deflect always
            MEM_WriteByte(projectileDeflectOffNpcAddr + 1, ASMINT_OP_nop);
            hit = FALSE;
        } else {
            MEM_WriteByte(projectileDeflectOffNpcAddr, /*74*/ 116); // Jump beyond armor collision check, deflect never
            MEM_WriteByte(projectileDeflectOffNpcAddr+1, /*60*/ 96); // jz to 0x6A0BC8
            if (!collision) { // Destroy (no damage)
                MEM_WriteInt(projectile+816, -1); // Delete item instance (it will not be put into the directory)
                hit = FALSE;
            } else { // Collide (damage)
                hit = TRUE;
            };
        };
    } else { // Destroy the projectile if it did not physically hit
        MEM_WriteByte(projectileDeflectOffNpcAddr, /*74*/ 116); // Jump beyond the armor collision check, deflect never
        MEM_WriteByte(projectileDeflectOffNpcAddr+1, /*60*/ 96); // jz to 0x6A0BC8
        MEM_WriteInt(projectile+816, -1); // Delete item instance (it will not be put into the directory)
        hit = FALSE;
    };
    MEM_WriteInt(ESP+24, hit*100); // Player always hits = 100%
};

/* Arrow collides with world (static or non-npc vob). Either destroy, deflect or collide */
func void freeAimOnArrowCollide() {
    var oCItem projectile; projectile = _^(MEM_ReadInt(ESI+60)); // esi+3Ch
    var C_Npc shooter; shooter = _^(MEM_ReadInt(esi+92)); // esi+5Ch
    var int matobj; matobj = MEM_ReadInt(ECX); // zCMaterial* or zCPolygon*
    if (MEM_ReadInt(matobj) != zCMaterial__vtbl) { matobj = MEM_ReadInt(matobj+24); }; // Static world: Read zCPolygon
    var int material; material = MEM_ReadInt(matobj+64);
    var string texture; texture = "";
    if (MEM_ReadInt(matobj+52)) { // For the case that the material has no assigned texture (which should not happen)
        texture = MEM_ReadString(MEM_ReadInt(matobj+52)+16); // zCMaterial.texture._zCObject_objectName
    };
    var int collision; collision = freeAimHitRegWld_(shooter, material, texture); // 0=destroy, 1=stay, 2=deflect
    if (collision == 1) { // Collide
        EDI = material; // Sets the condition at 0x6A0A45 and 0x6A0C1A to true: Projectile stays
    } else {
        EDI = -1;  // Sets the condition at 0x6A0A45 and 0x6A0C1A to false: Projectile deflects
        if (!collision) {
            if (FF_ActiveData(freeAimDropProjectile, _@(projectile._zCVob_rigidBody))) {
                FF_RemoveData(freeAimDropProjectile, _@(projectile._zCVob_rigidBody)); };
            if (FREEAIM_REUSE_PROJECTILES) { // Destroy
                Wld_StopEffect(FREEAIM_BREAK_FX); // Sometimes collides several times
                Wld_PlayEffect(FREEAIM_BREAK_FX, projectile, projectile, 0, 0, 0, FALSE);
                MEM_WriteInt(ESI+56, -1073741824); // oCAIArrow.lifeTime // Mark this AI for freeAimWatchProjectile()
            };
        };
    };
};

/* Arrow gets stuck in npc: put projectile instance into inventory and let ai die */
func void freeAimOnArrowHitNpc() {
    var oCItem projectile; projectile = _^(MEM_ReadInt(ESI+88));
    var C_Npc victim; victim = _^(EDI);
    // Call customized function
    MEM_PushIntParam(projectile.instanz);
    MEM_PushInstParam(victim);
    MEM_Call(freeAimGetUsedProjectileInstance); // freeAimGetUsedProjectileInstance(projectile.instanz, victim);
    var int projInst; projInst = MEM_PopIntResult();
    if (projInst > 0) { CreateInvItem(victim, projInst); }; // Put respective instance in inventory
    if (FF_ActiveData(freeAimDropProjectile, _@(projectile._zCVob_rigidBody))) {
        FF_RemoveData(freeAimDropProjectile, _@(projectile._zCVob_rigidBody)); };
    MEM_WriteInt(ESI+56, -1073741824); // oCAIArrow.lifeTime // Mark this AI for freeAimWatchProjectile()
};

/* Arrow gets stuck in static or dynamic world (non-npc): keep ai alive */
func void freeAimOnArrowGetStuck() {
    var int projectilePtr; projectilePtr = MEM_ReadInt(ESI+88);
    var oCItem projectile; projectile = _^(projectilePtr);
    if (FF_ActiveData(freeAimDropProjectile, _@(projectile._zCVob_rigidBody))) {
        FF_RemoveData(freeAimDropProjectile, _@(projectile._zCVob_rigidBody)); };
    // Have projectile not go to deep in. Might not make sense but trust me. (RightVec will be multiplied later)
    projectile._zCVob_trafoObjToWorld[0] = mulf(projectile._zCVob_trafoObjToWorld[0], -1096111445);
    projectile._zCVob_trafoObjToWorld[4] = mulf(projectile._zCVob_trafoObjToWorld[4], -1096111445);
    projectile._zCVob_trafoObjToWorld[8] = mulf(projectile._zCVob_trafoObjToWorld[8], -1096111445);
};

/* Fix trigger collision bug. Taken from http://forum.worldofplayers.de/forum/threads/1126551/page10?p=20894916 */
func void freeAimTriggerCollisionCheck() {
    var int vobPtr; vobPtr = ESP+4;
    var int shooter; shooter = MEM_ReadInt(ECX+92);
    var int vtbl; vtbl = MEM_ReadInt(MEM_ReadInt(vobPtr));
    if (vtbl != zCTrigger_vtbl) && (vtbl != zCTriggerScript_vtbl) { return; }; // It is no Trigger
    var zCTrigger trigger; trigger = _^(MEM_ReadInt(vobPtr));
    if (trigger.bitfield & zCTrigger_bitfield_respondToObject)
    && (trigger.bitfield & zCTrigger_bitfield_reactToOnTouch) { return; }; // Object-reacting trigger
    MEM_WriteInt(vobPtr, shooter); // The engine ignores the shooter
};

/* Once a projectile stopped moving keep it alive */
func void freeAimWatchProjectile() {
    var int arrowAI; arrowAI = ECX; // oCAIArrow*
    var int projectilePtr; projectilePtr = MEM_ReadInt(ESP+4); // oCItem*
    var int removePtr; removePtr = MEM_ReadInt(ESP+8); // int* (call-by-reference argument)
    if (!projectilePtr) { return; }; // oCItem* might not exist
    var oCItem projectile; projectile = _^(projectilePtr);
    if (!projectile._zCVob_rigidBody) { return; }; // zCRigidBody* might not exist the first time
    // Reset projectile gravity (zCRigidBody.gravity) after collision (oCAIArrow.collision)
    if (MEM_ReadInt(arrowAI+52)) { MEM_WriteInt(projectile._zCVob_rigidBody+236, FLOATONE); }; // Set gravity to default
    if (!FREEAIM_REUSE_PROJECTILES) { return; }; // Normal projectile handling
    // If the projectile stopped moving (and did not hit npc)
    if (MEM_ReadInt(arrowAI+56) != -1073741824) && !(projectile._zCVob_bitfield[0] & zCVob_bitfield0_physicsEnabled) {
        if (FF_ActiveData(freeAimDropProjectile, _@(projectile._zCVob_rigidBody))) {
            FF_RemoveData(freeAimDropProjectile, _@(projectile._zCVob_rigidBody)); };
        if (Hlp_StrCmp(projectile.effect, FREEAIM_TRAIL_FX)) { // Remove trail strip fx
            const int call2 = 0;
            if (CALL_Begin(call2)) {
                CALL__thiscall(_@(projectilePtr), oCItem__RemoveEffect);
                call2 = CALL_End();
            };
        };
        var C_Npc emptyNpc; emptyNpc = MEM_NullToInst();
        // Call customized function
        MEM_PushIntParam(projectile.instanz);
        MEM_PushInstParam(emptyNpc);
        MEM_Call(freeAimGetUsedProjectileInstance); // freeAimGetUsedProjectileInstance(projectile.instanz, emptyNpc);
        var int projInst; projInst = MEM_PopIntResult();
        if (projInst > 0) { // Will be -1 on invalid item
            if (projInst != projectile.instanz) { // Only change the instance if different
                const int call3 = 0; const int one = 1;
                if (CALL_Begin(call3)) {
                    CALL_IntParam(_@(one)); // Amount
                    CALL_PtrParam(_@(projInst)); // Instance ID
                    CALL__thiscall(_@(projectilePtr), oCItem__InitByScript);
                    call3 = CALL_End();
                };
            };
            projectile.flags = projectile.flags &~ ITEM_NFOCUS; // Focusable
            MEM_WriteInt(arrowAI+56, FLOATONE); // oCAIArrow.lifeTime // Set high lifetime to ensure item visibility
            MEM_WriteInt(removePtr, 0); // Do not remove vob on AI destruction
            MEM_WriteInt(ESP+8, _@(FREEAIM_ARROWAI_REDIRECT)); // Divert the actual "return" value
        };
    } else if (MEM_ReadInt(arrowAI+56) == -1073741824) { // Marked as positive hit on npc: do not keep alive
        MEM_WriteInt(arrowAI+56, FLOATNULL); // oCAIArrow.lifeTime
    };
};

/* Disable damage animation. Taken from http://forum.worldofplayers.de/forum/threads/1474431?p=25057480#post25057480 */
func void freeAimDmgAnimation() {
    var C_Npc victim; victim = _^(ECX);
    if (Npc_IsPlayer(victim)) && (freeAimIsActive()) { EAX = 0; }; // Disable damage animation while aiming
};

/* Visualize the bounding boxes of the trace ray its trajectory for debugging */
func void freeAimVisualizeTraceRay() {
    if (!FREEAIM_DEBUG_TRACERAY) { return; };
    if (freeAimDebugTRBBox[0]) { // Visualize intersection bounding box
        var int cGreenPtr; cGreenPtr = _@(zCOLOR_GREEN);
        var int bboxPtr; bboxPtr = _@(freeAimDebugTRBBox);
        const int call = 0;
        if (CALL_Begin(call)) {
            CALL_PtrParam(_@(cGreenPtr));
            CALL__thiscall(_@(bboxPtr), zTBBox3D__Draw);
            call = CALL_End();
        };
    };
    if (freeAimDebugTRTrj[0]) { // Visualize trace ray trajectory
        var int pos1Ptr; pos1Ptr = _@(freeAimDebugTRTrj);
        var int pos2Ptr; pos2Ptr = _@(freeAimDebugTRTrj)+12;
        const int call2 = 0; var int null;
        if (CALL_Begin(call2)) {
            CALL_IntParam(_@(null));
            CALL_IntParam(_@(zCOLOR_GREEN));
            CALL_PtrParam(_@(pos2Ptr));
            CALL_PtrParam(_@(pos1Ptr));
            CALL__thiscall(_@(zlineCache), zCLineCache__Line3D);
            call2 = CALL_End();
        };
    };
};

/* Visualize the bounding box of the weakspot and the projectile trajectory for debugging */
func void freeAimVisualizeWeakspot() {
    if (!FREEAIM_DEBUG_WEAKSPOT) { return; };
    if (freeAimDebugWSBBox[0]) { // Visualize weak spot bounding box
        var int cRedPtr; cRedPtr = _@(zCOLOR_RED);
        var int bboxPtr; bboxPtr = _@(freeAimDebugWSBBox);
        const int call = 0;
        if (CALL_Begin(call)) {
            CALL_PtrParam(_@(cRedPtr));
            CALL__thiscall(_@(bboxPtr), zTBBox3D__Draw);
            call = CALL_End();
        };
    };
    if (freeAimDebugWSTrj[0]) { // Visualize projectile trajectory
        var int pos1Ptr; pos1Ptr = _@(freeAimDebugWSTrj);
        var int pos2Ptr; pos2Ptr = _@(freeAimDebugWSTrj)+12;
        const int call2 = 0; var int null;
        if (CALL_Begin(call2)) {
            CALL_IntParam(_@(null));
            CALL_IntParam(_@(zCOLOR_RED));
            CALL_PtrParam(_@(pos2Ptr));
            CALL_PtrParam(_@(pos1Ptr));
            CALL__thiscall(_@(zlineCache), zCLineCache__Line3D);
            call2 = CALL_End();
        };
    };
};

/* Internal helper function for freeAimCriticalHitEvent() */
func void freeAimCriticalHitEvent_(var C_Npc target) {
    var C_Item weapon; weapon = MEM_NullToInst(); // Daedalus pseudo locals
    if (Npc_IsInFightMode(hero, FMODE_FAR)) { weapon = Npc_GetReadiedWeapon(hero); }
    else if (Npc_HasEquippedRangedWeapon(hero)) { weapon = Npc_GetEquippedRangedWeapon(hero); };
    // Call customized function
    MEM_PushInstParam(target);
    MEM_PushInstParam(weapon);
    MEM_Call(freeAimCriticalHitEvent); // freeAimCriticalHitEvent(target, weapon);
};

/* Internal helper function for freeAimCriticalHitDef() */
func void freeAimCriticalHitDef_(var C_Npc target, var int damage, var int returnPtr) {
    var C_Item weapon; weapon = MEM_NullToInst(); // Daedalus pseudo locals
    if (Npc_IsInFightMode(hero, FMODE_FAR)) { weapon = Npc_GetReadiedWeapon(hero); }
    else if (Npc_HasEquippedRangedWeapon(hero)) { weapon = Npc_GetEquippedRangedWeapon(hero); };
    // Call customized function
    MEM_PushInstParam(target);
    MEM_PushInstParam(weapon);
    MEM_PushIntParam(damage);
    MEM_PushIntParam(returnPtr);
    MEM_Call(freeAimCriticalHitDef); // freeAimCriticalHitDef(target, weapon, damage, returnPtr);
    MEM_WriteString(returnPtr, STR_Upper(MEM_ReadString(returnPtr))); // Nodes are always upper case
    if (lf(MEM_ReadInt(returnPtr+28), FLOATNULL)) { MEM_WriteInt(returnPtr+28, FLOATNULL); }; // Correct negative damage
};

/* Console function to enable/disable weak spot debug output */
func string freeAimDebugWeakspot(var string command) {
    FREEAIM_DEBUG_WEAKSPOT = !FREEAIM_DEBUG_WEAKSPOT;
    if (FREEAIM_DEBUG_WEAKSPOT) { return "Debug weak spot on."; } else { return "Debug weak spot off."; };
};

/* Console function to enable/disable trace ray debug output */
func string freeAimDebugTraceRay(var string command) {
    FREEAIM_DEBUG_TRACERAY = !FREEAIM_DEBUG_TRACERAY;
    if (FREEAIM_DEBUG_TRACERAY) { return "Debug trace ray on."; } else { return "Debug trace ray off."; };
};

/* Console function to show freeAim version */
func string freeAimVersion(var string command) {
    return FREEAIM_VERSION;
};

/* Console function to show freeAim license */
func string freeAimLicense(var string command) {
    var int s; s = SB_New();
    SB(FREEAIM_VERSION); SB(", Copyright "); SBc(169 /* (C) */); SB(" 2016  mud-freak (@szapp)"); SBc(13); SBc(10);
    SB("<http://github.com/szapp/g2freeAim>"); SBc(13); SBc(10);
    SB("Released under the MIT License."); SBc(13); SBc(10);
    SB("For more details see <http://opensource.org/licenses/MIT>."); SBc(13); SBc(10);
    var string ret; ret = SB_ToString(); SB_Destroy();
    return ret;
};

/* Console function to show freeAim info */
func string freeAimInfo(var string command) {
    const string onOff[2] = {"off", "on"};
    var int s; s = SB_New();
    SB(FREEAIM_VERSION); SBc(13); SBc(10);
    SB("Enabled: "); SB(MEM_ReadStatStringArr(onOff, STR_ToInt(MEM_GetGothOpt("FREEAIM", "enabled")))); SBc(13);SBc(10);
    SB("Focus: "); SB(MEM_ReadStatStringArr(onOff, FREEAIM_FOCUS_COLLECTION)); SBc(13); SBc(10);
    SB("Reuse projectiles: "); SB(MEM_ReadStatStringArr(onOff, FREEAIM_REUSE_PROJECTILES)); SBc(13); SBc(10);
    SB("Free aim for spells: "); SB(MEM_ReadStatStringArr(onOff, !FREEAIM_DISABLE_SPELLS)); SBc(13); SBc(10);
    var string ret; ret = SB_ToString(); SB_Destroy();
    return ret;
};

/* Detect critical hits and increase base damage. Modify the weak spot in freeAimCriticalHitDef() */
func void freeAimDetectCriticalHit() {
    var int damagePtr; damagePtr = ESP+228; // esp+1ACh+C8h // zREAL*
    var int target; target = MEM_ReadInt(ESP+28); // esp+1ACh+190h // oCNpc*
    var int projectile; projectile = MEM_ReadInt(EBP+88); // ebp+58h // oCItem*
    var C_Npc shooter; shooter = _^(MEM_ReadInt(EBP+92)); // ebp+5Ch // oCNpc*
    if (FREEAIM_ACTIVE_PREVFRAME != 1) || (!Npc_IsPlayer(shooter)) { return; }; // Only if player and if fa WAS active
    var C_Npc targetNpc; targetNpc = _^(target);
    // Get model from target npc
    const int call = 0;
    if (CALL_Begin(call)) {
        CALL__thiscall(_@(target), oCNpc__GetModel);
        call = CALL_End();
    };
    var int model; model = CALL_RetValAsPtr();
    // Get weak spot node from target model
    var int autoAlloc[8]; var Weakspot weakspot; weakspot = _^(_@(autoAlloc)); // Gothic takes care of freeing this ptr
    MEM_CopyWords(_@s(""), _@(autoAlloc), 5); // weakspot.node (reset string)
    freeAimCriticalHitDef_(targetNpc, MEM_ReadInt(damagePtr), _@(weakspot)); // Retrieve weakspot specs
    var int nodeStrPtr; nodeStrPtr = _@(weakspot);
    if (Hlp_StrCmp(MEM_ReadString(nodeStrPtr), "")) { return; }; // No critical node defined
    const int call2 = 0;
    if (CALL_Begin(call2)) {
        CALL_PtrParam(_@(nodeStrPtr));
        CALL__thiscall(_@(model), zCModel__SearchNode);
        call2 = CALL_End();
    };
    var int node; node = CALL_RetValAsPtr();
    if (!node) { MEM_Warn("freeAimDetectCriticalHit: Node not found!"); return; };
    if (weakspot.dimX == -1) && (weakspot.dimY == -1) { // Retrieve the bbox by model
        if (MEM_ReadInt(node+8)) { // node->nodeVisual // If the node has a dedicated visual, retrieve bbox
            // Get the bbox of the node (although zCModelNodeInst has a zTBBox3D property, it is empty the first time)
            CALL_PtrParam(node); CALL_RetValIsStruct(24); // sizeof_zTBBox3D // No recyclable call possible
            CALL__thiscall(model, zCModel__GetBBox3DNodeWorld);
            var int nodeBBoxPtr; nodeBBoxPtr = CALL_RetValAsPtr();
            MEM_CopyWords(nodeBBoxPtr, _@(freeAimDebugWSBBox), 6); // zTBBox3D
            MEM_Free(nodeBBoxPtr); // Free memory
        } else {
            MEM_Error("freeAimDetectCriticalHit: Node has no boundingbox!");
            return;
        };
    } else if (weakspot.dimX < 0) || (weakspot.dimY < 0) { // Bbox dimensions must be positive
        MEM_Error("freeAimDetectCriticalHit: Boundingbox dimensions illegal!");
        return;
    } else { // Create bbox by dimensions
        weakspot.dimX /= 2; weakspot.dimY /= 2;
        // Get the position of the node (although zCModelNodeInst has a position property, it is empty the first time)
        CALL_PtrParam(node); CALL_RetValIsStruct(12); // sizeof_zVEC3 // No recyclable call possible bc of structure
        CALL__thiscall(model, zCModel__GetNodePositionWorld);
        var int nodPosPtr; nodPosPtr = CALL_RetValAsInt();
        var int nodePos[3]; MEM_CopyWords(nodPosPtr, _@(nodePos), 3);
        MEM_Free(nodPosPtr); // Free memory
        freeAimDebugWSBBox[0] = subf(nodePos[0], mkf(weakspot.dimX)); // Build an own bbox by the passed node dimensions
        freeAimDebugWSBBox[1] = subf(nodePos[1], mkf(weakspot.dimY));
        freeAimDebugWSBBox[2] = subf(nodePos[2], mkf(weakspot.dimX));
        freeAimDebugWSBBox[3] = addf(nodePos[0], mkf(weakspot.dimX));
        freeAimDebugWSBBox[4] = addf(nodePos[1], mkf(weakspot.dimY));
        freeAimDebugWSBBox[5] = addf(nodePos[2], mkf(weakspot.dimX));
    };
    // The internal engine functions are not accurate enough for detecting a shot through a bbox
    // Instead check here if "any" point along the line of projectile direction lies inside the bbox of the node
    var int dir[3]; // Direction of collision line along the right-vector of the projectile (projectile flies sideways)
    dir[0] = MEM_ReadInt(projectile+60); dir[1] = MEM_ReadInt(projectile+76); dir[2] = MEM_ReadInt(projectile+92);
    freeAimDebugWSTrj[0] = addf(MEM_ReadInt(projectile+ 72), mulf(dir[0], FLOAT3C)); // Start 3m behind the projectile
    freeAimDebugWSTrj[1] = addf(MEM_ReadInt(projectile+ 88), mulf(dir[1], FLOAT3C)); // So far bc bbox at close range
    freeAimDebugWSTrj[2] = addf(MEM_ReadInt(projectile+104), mulf(dir[2], FLOAT3C));
    var int intersection; intersection = 0; // Critical hit detected
    var int i; i=0; var int iter; iter = 700/5; // 7meters: Max distance from model bbox edge to node bbox (e.g. troll)
    while(i <= iter); i += 1; // Walk along the line in steps of 5cm
        freeAimDebugWSTrj[3] = subf(freeAimDebugWSTrj[0], mulf(dir[0], mkf(i*5))); // Next point along the collision line
        freeAimDebugWSTrj[4] = subf(freeAimDebugWSTrj[1], mulf(dir[1], mkf(i*5)));
        freeAimDebugWSTrj[5] = subf(freeAimDebugWSTrj[2], mulf(dir[2], mkf(i*5)));
        if (lef(freeAimDebugWSBBox[0], freeAimDebugWSTrj[3])) && (lef(freeAimDebugWSBBox[1], freeAimDebugWSTrj[4]))
        && (lef(freeAimDebugWSBBox[2], freeAimDebugWSTrj[5])) && (gef(freeAimDebugWSBBox[3], freeAimDebugWSTrj[3]))
        && (gef(freeAimDebugWSBBox[4], freeAimDebugWSTrj[4])) && (gef(freeAimDebugWSBBox[5], freeAimDebugWSTrj[5])) {
            intersection = 1; }; // Current point is inside the node bbox, but stay in loop for debugging the line
    end;
    var int s; s = SB_New(); // Print info to zSpy
    SB("freeAimDetectCriticalHit: ");
    SB("criticalhit="); SBi(intersection); SB(" ");
    SB("basedamage="); SBi(roundf(weakspot.bDmg)); SB("/"); SBi(roundf(MEM_ReadInt(damagePtr))); SB(" ");
    SB("ciriticalnode='"); SB(weakspot.node); SB("' ");
    SB(" ("); SBi(weakspot.dimX); SB("x"); SBi(weakspot.dimY); SB(")");
    MEM_Info(SB_ToString()); SB_Destroy();
    if (intersection) { // Critical hit detected
        freeAimCriticalHitEvent_(targetNpc); // Use this function to add an event, e.g. a print or a sound
        MEM_WriteInt(damagePtr, weakspot.bDmg); // Base damage not final damage
    };
};

/* Set the spell fx direction and trajectory. Hook oCSpell::Setup */
func void freeAimSetupSpell() {
    var int casterPtr; casterPtr = MEM_ReadInt(EBP+52); //0x0034 oCSpell.spellCasterNpc
    if (!casterPtr) { return; }; // No caster
    var C_Npc caster; caster = _^(casterPtr);
    if (FREEAIM_ACTIVE_PREVFRAME != 1) || (!Npc_IsPlayer(caster)) { return; }; // Only if player and if fa WAS active
    var C_Spell spell; spell = _^(EBP+128); //0x0080 oCSpell.C_Spell
    if (!freeAimSpellEligible(spell)) { return; }; // Only with eligible spells
    var int focusType; // No focus display for TARGET_COLLECT_NONE (still focus collection though)
    if (!spell.targetCollectAlgo) { focusType = 0; } else { focusType = spell.targetCollectType; };
    var int pos[3]; freeAimRay(spell.targetCollectRange, focusType, 0, _@(pos), 0, 0);
    var int vobPtr; vobPtr = freeAimSetupAimVob(_@(pos)); // Setup the aim vob
    MEM_WriteInt(ESP+4, vobPtr); // Overwrite target vob
};

/* Internal helper function for freeAimGetReticleSpell() for magic combat */
func void freeAimGetReticleSpell_(var int target, var C_Spell spellInst, var int distance, var int returnPtr) {
    var C_Npc targetNpc; var int spellID; var int spellLvl; var int isScroll; var int manaInvested;
    spellID = Npc_GetActiveSpell(hero);
    spellLvl = Npc_GetActiveSpellLevel(hero);
    isScroll = Npc_GetActiveSpellIsScroll(hero);
    manaInvested = MEM_ReadInt(_@(spellInst)-56); // 0x0048 oCSpell.manaInvested
    if (Hlp_Is_oCNpc(target)) { targetNpc = _^(target); } else { targetNpc = MEM_NullToInst(); };
    // Call customized function
    MEM_PushInstParam(targetNpc);
    MEM_PushIntParam(spellID);
    MEM_PushInstParam(spellInst);
    MEM_PushIntParam(spellLvl);
    MEM_PushIntParam(isScroll);
    MEM_PushIntParam(manaInvested);
    MEM_PushIntParam(distance);
    MEM_PushIntParam(returnPtr);
    MEM_Call(freeAimGetReticleSpell); // freeAimGetReticleSpell(target, spellID, spellInst, spellLvl, isScroll, ...);
};

/* Manage reticle style and focus collection for magic combat */
func void freeAimSpellReticle() {
    if (!freeAimIsActive()) { freeAimRemoveReticle(); return; }; // Only with eligible spells
    var C_Spell spell; spell = freeAimGetActiveSpellInst(hero);
    var int distance; var int target;
    if (FREEAIM_FOCUS_COLLECTION) && (spell.targetCollectRange > 0) { // Set focus npc if there is a valid one
        var int focusType; // No focus display for TARGET_COLLECT_NONE (still focus collection though)
        if (!spell.targetCollectAlgo) || (spell.targetCollectAzi <= 0) || (spell.targetCollectElev <= 0)
        { focusType = 0; } else { focusType = spell.targetCollectType; };
        freeAimRay(spell.targetCollectRange, focusType, _@(target), 0, _@(distance), 0); // Shoot ray
        distance = roundf(divf(mulf(distance, FLOAT1C), mkf(spell.targetCollectRange))); // Distance scaled to [0, 100]
    } else { // More performance friendly. Here, there will be NO focus, otherwise it gets stuck on npcs.
        var int herPtr; herPtr = _@(hero);
        const int call2 = 0; var int null; // Set the focus vob properly: reference counter
        if (CALL_Begin(call2)) {
            CALL_PtrParam(_@(null)); // This will remove the focus
            CALL__thiscall(_@(herPtr), oCNpc__SetFocusVob);
            call2 = CALL_End();
        };
        if (!MEM_ReadInt(herPtr+1176)) { //0x0498 oCNpc.enemy
            const int call3 = 0; // Remove the enemy properly: reference counter
            if (CALL_Begin(call3)) {
                CALL_PtrParam(_@(null)); // Always remove oCNpc.enemy. Target will be set to aimvob when shooting
                CALL__thiscall(_@(herPtr), oCNpc__SetEnemy);
                call3 = CALL_End();
            };
        };
        distance = 25; // No distance check ever. Set it to medium distance
        target = 0; // No focus target ever
    };
    var int autoAlloc[7]; var Reticle reticle; reticle = _^(_@(autoAlloc)); // Gothic takes care of freeing this ptr
    MEM_CopyWords(_@s(""), _@(autoAlloc), 5); // reticle.texture (reset string) // Do not show reticle by default
    reticle.color = -1; // Do not set color by default
    reticle.size = 75; // Medium size by default
    freeAimGetReticleSpell_(target, spell, distance, _@(reticle)); // Retrieve reticle specs
    freeAimInsertReticle(_@(reticle)); // Draw/update reticle
};

/* Disable auto turning towards the target for free aiming spells */
func void freeAimDisableSpellAutoTurn() {
    var int herPtr; herPtr = _@(hero);
    if (freeAimIsActive() && MEM_ReadInt(herPtr+1176)) { //0x0498 oCNpc.enemy
        const int call3 = 0; var int null; // Remove the enemy properly: reference counter
        if (CALL_Begin(call3)) {
            CALL_PtrParam(_@(null)); // Always remove oCNpc.enemy. Target will be set to aimvob when shooting
            CALL__thiscall(_@(herPtr), oCNpc__SetEnemy); // This disables turning towards the target
            call3 = CALL_End();
        };
    };
};