(*

 * Hedgewars, a free turn based strategy game

 * Copyright (c) 2004-2013 Andrey Korotaev <unC0Rr@gmail.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; version 2 of the License

 *

 * This program 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

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA

 *)

{$INCLUDE "options.inc"}

unit uAIAmmoTests;

interface

uses uConsts, uFloat, uTypes, uAIMisc;

const

    amtest_Rare            = $00000001; // check only several positions

    amtest_NoTarget        = $00000002; // each pos, but no targetting

    amtest_MultipleAttacks = $00000004; // test could result in multiple attacks, set AttacksNum

var windSpeed: real;

type TAttackParams = record

        Time, AttacksNum: Longword;

        Angle, Power: LongInt;

        ExplX, ExplY, ExplR: LongInt;

        AttackPutX, AttackPutY: LongInt;

        end;

function TestBazooka(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

function TestSnowball(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

function TestGrenade(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

function TestMolotov(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

function TestClusterBomb(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

function TestWatermelon(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

function TestDrillRocket(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

function TestMortar(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

function TestShotgun(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

function TestDesertEagle(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

function TestSniperRifle(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

function TestBaseballBat(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

function TestFirePunch(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

function TestWhip(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

function TestKamikaze(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

function TestAirAttack(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

function TestTeleport(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

function TestHammer(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

function TestCake(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

function TestDynamite(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

type TAmmoTestProc = function (Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

    TAmmoTest = record

            proc: TAmmoTestProc;

            flags: Longword;

            end;

const AmmoTests: array[TAmmoType] of TAmmoTest =

            (

            (proc: nil;              flags: 0), // amNothing

            (proc: @TestGrenade;     flags: 0), // amGrenade

            (proc: @TestClusterBomb; flags: 0), // amClusterBomb

            (proc: @TestBazooka;     flags: 0), // amBazooka

            (proc: nil;              flags: 0), // amBee

            (proc: @TestShotgun;     flags: 0), // amShotgun

            (proc: nil;              flags: 0), // amPickHammer

            (proc: nil;              flags: 0), // amSkip

            (proc: nil;              flags: 0), // amRope

            (proc: nil;              flags: 0), // amMine

            (proc: @TestDesertEagle; flags: amtest_MultipleAttacks), // amDEagle

            (proc: @TestDynamite;    flags: amtest_NoTarget), // amDynamite

            (proc: @TestFirePunch;   flags: amtest_NoTarget), // amFirePunch

            (proc: @TestWhip;        flags: amtest_NoTarget), // amWhip

            (proc: @TestBaseballBat; flags: amtest_NoTarget), // amBaseballBat

            (proc: nil;              flags: 0), // amParachute

            (proc: @TestAirAttack;   flags: amtest_Rare), // amAirAttack

            (proc: nil;              flags: 0), // amMineStrike

            (proc: nil;              flags: 0), // amBlowTorch

            (proc: nil;              flags: 0), // amGirder

            (proc: nil;              flags: 0), // amTeleport

            //(proc: @TestTeleport;    flags: amtest_OnTurn), // amTeleport

            (proc: nil;              flags: 0), // amSwitch

            (proc: @TestMortar;      flags: 0), // amMortar

            (proc: @TestKamikaze;    flags: 0), // amKamikaze

            (proc: @TestCake;        flags: amtest_Rare or amtest_NoTarget), // amCake

            (proc: nil;              flags: 0), // amSeduction

            (proc: @TestWatermelon;  flags: 0), // amWatermelon

            (proc: nil;              flags: 0), // amHellishBomb

            (proc: nil;              flags: 0), // amNapalm

            (proc: @TestDrillRocket; flags: 0), // amDrill

            (proc: nil;              flags: 0), // amBallgun

            (proc: nil;              flags: 0), // amRCPlane

            (proc: nil;              flags: 0), // amLowGravity

            (proc: nil;              flags: 0), // amExtraDamage

            (proc: nil;              flags: 0), // amInvulnerable

            (proc: nil;              flags: 0), // amExtraTime

            (proc: nil;              flags: 0), // amLaserSight

            (proc: nil;              flags: 0), // amVampiric

            (proc: @TestSniperRifle; flags: 0), // amSniperRifle

            (proc: nil;              flags: 0), // amJetpack

            (proc: @TestMolotov;     flags: 0), // amMolotov

            (proc: nil;              flags: 0), // amBirdy

            (proc: nil;              flags: 0), // amPortalGun

            (proc: nil;              flags: 0), // amPiano

            (proc: @TestGrenade;     flags: 0), // amGasBomb

            (proc: @TestShotgun;     flags: 0), // amSineGun

            (proc: nil;              flags: 0), // amFlamethrower

            (proc: @TestGrenade;     flags: 0), // amSMine

            (proc: @TestHammer;      flags: amtest_NoTarget), // amHammer

            (proc: nil;              flags: 0), // amResurrector

            (proc: nil;              flags: 0), // amDrillStrike

            (proc: nil;              flags: 0), // amSnowball

            (proc: nil;              flags: 0), // amTardis

            //(proc: nil;              flags: 0), // amStructure

            (proc: nil;              flags: 0), // amLandGun

            (proc: nil;              flags: 0), // amIceGun

            (proc: nil;              flags: 0), // amKnife

            (proc: nil;              flags: 0)  // amGirder

            );

implementation

uses uVariables, uUtils, uGearsHandlers;

function Metric(x1, y1, x2, y2: LongInt): LongInt; inline;

begin

Metric:= abs(x1 - x2) + abs(y1 - y2)

end;

function TestBazooka(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

var Vx, Vy, r, mX, mY: real;

    rTime: LongInt;

    EX, EY: LongInt;

    valueResult: LongInt;

    x, y, dX, dY: real;

    t: LongInt;

    value: LongInt;

begin

mX:= hwFloat2Float(Me^.X);

mY:= hwFloat2Float(Me^.Y);

ap.Time:= 0;

rTime:= 350;

ap.ExplR:= 0;

valueResult:= BadTurn;

repeat

    rTime:= rTime + 300 + Level * 50 + random(300);

    Vx:= - windSpeed * rTime * 0.5 + (Targ.Point.X + AIrndSign(2) - mX) / rTime;

    Vy:= cGravityf * rTime * 0.5 - (Targ.Point.Y + 1 - mY) / rTime;

    r:= sqr(Vx) + sqr(Vy);

    if not (r > 1) then

        begin

        x:= mX;

        y:= mY;

        dX:= Vx;

        dY:= -Vy;

        t:= rTime;

        repeat

            x:= x + dX;

            y:= y + dY;

            dX:= dX + windSpeed;

            dY:= dY + cGravityf;

            dec(t)

        until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or

               ((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5))) or (t <= 0);

        EX:= trunc(x);

        EY:= trunc(y);

        if Level = 1 then

            value:= RateExplosion(Me, EX, EY, 101, afTrackFall or afErasesLand)

        else value:= RateExplosion(Me, EX, EY, 101);

        if (value = 0) and (Targ.Kind = gtHedgehog) and (Targ.Score > 0) then

            value:= 1024 - Metric(Targ.Point.X, Targ.Point.Y, EX, EY) div 64;

        if valueResult <= value then

            begin

            ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random((Level - 1) * 9));

            ap.Power:= trunc(sqrt(r) * cMaxPower) - random((Level - 1) * 17 + 1);

            ap.ExplR:= 100;

            ap.ExplX:= EX;

            ap.ExplY:= EY;

            valueResult:= value

            end;

        end

//until (value > 204800) or (rTime > 4250); not so useful since adding score to the drowning

until rTime > 5050 - Level * 800;

TestBazooka:= valueResult

end;

function TestDrillRocket(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

var Vx, Vy, r, mX, mY: real;

    rTime: LongInt;

    EX, EY: LongInt;

    valueResult: LongInt;

    x, y, dX, dY: real;

    t: LongInt;

    value: LongInt;

    t2: real;

    timer: Longint;

begin

    if (Level > 3) then exit(BadTurn);

    mX:= hwFloat2Float(Me^.X);

    mY:= hwFloat2Float(Me^.Y);

    ap.Time:= 0;

    rTime:= 350;

    ap.ExplR:= 0;

    valueResult:= BadTurn;

    repeat

        rTime:= rTime + 300 + Level * 50 + random(300);

        Vx:= - windSpeed * rTime * 0.5 + (Targ.Point.X + AIrndSign(2) - mX) / rTime;

        Vy:= cGravityf * rTime * 0.5 - (Targ.Point.Y - 35 - mY) / rTime;

        r:= sqr(Vx) + sqr(Vy);

        if not (r > 1) then

            begin

            x:= mX;

            y:= mY;

            dX:= Vx;

            dY:= -Vy;

            t:= rTime;

            repeat

                x:= x + dX;

                y:= y + dY;

                dX:= dX + windSpeed;

                dY:= dY + cGravityf;

                dec(t)

            until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or

                   ((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5))) or (y > cWaterLine);

            if TestCollExcludingObjects(trunc(x), trunc(y), 5) and (Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) > 21) then

                begin

                timer := 500;

                t2 := 0.5 / sqrt(sqr(dX) + sqr(dY));

                dX := dX * t2;

                dY := dY * t2;

                repeat

                    x:= x + dX;

                    y:= y + dY;

                    dec(timer);

                until (Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) < 22)

                    or (x < 0)

                    or (y < 0)

                    or (trunc(x) > LAND_WIDTH)

                    or (trunc(y) > LAND_HEIGHT)

                    or not TestCollExcludingObjects(trunc(x), trunc(y), 5)

                    or (timer = 0)

                end;

            EX:= trunc(x);

            EY:= trunc(y);

            // Try to prevent AI from thinking firing into water will cause a drowning

            if (EY < cWaterLine-5) and (Timer > 0) and (Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) > 21) then exit(BadTurn);

            if Level = 1 then

                value:= RateExplosion(Me, EX, EY, 101, afTrackFall or afErasesLand)

            else value:= RateExplosion(Me, EX, EY, 101);

            if valueResult <= value then

                begin

                ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random((Level - 1) * 9));

                ap.Power:= trunc(sqrt(r) * cMaxPower) - random((Level - 1) * 17 + 1);

                ap.ExplR:= 100;

                ap.ExplX:= EX;

                ap.ExplY:= EY;

                valueResult:= value-2500 // trying to make it slightly less attractive than a bazooka, to prevent waste.  AI could use awareness of weapon count

                end;

            end

    until rTime > 5050 - Level * 800;

    TestDrillRocket:= valueResult

end;

function TestSnowball(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

var Vx, Vy, r: real;

    rTime: LongInt;

    EX, EY: LongInt;

    valueResult: LongInt;

    x, y, dX, dY, meX, meY: real;

    t: LongInt;

    value: LongInt;

begin

meX:= hwFloat2Float(Me^.X);

meY:= hwFloat2Float(Me^.Y);

ap.Time:= 0;

rTime:= 350;

ap.ExplR:= 0;

valueResult:= BadTurn;

repeat

    rTime:= rTime + 300 + Level * 50 + random(1000);

    Vx:= - windSpeed * rTime * 0.5 + ((Targ.Point.X + AIrndSign(2)) - meX) / rTime;

    Vy:= cGravityf * rTime * 0.5 - (Targ.Point.Y - meY) / rTime;

    r:= sqr(Vx) + sqr(Vy);

    if not (r > 1) then

        begin

        x:= meX;

        y:= meY;

        dX:= Vx;

        dY:= -Vy;

        t:= rTime;

        repeat

            x:= x + dX;

            y:= y + dY;

            dX:= dX + windSpeed;

            dY:= dY + cGravityf;

            dec(t)

        until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or

               ((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5))) or (t <= 0);

        EX:= trunc(x);

        EY:= trunc(y);

        value:= RateShove(Me, trunc(x), trunc(y), 5, 1, trunc((abs(dX)+abs(dY))*20), -dX, -dY, afTrackFall);

        // LOL copypasta: this is score for digging with... snowball

        //if value = 0 then

        //    value:= - Metric(Targ.Point.X, Targ.Point.Y, EX, EY) div 64;

        if valueResult <= value then

            begin

            ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random((Level - 1) * 9));

            ap.Power:= trunc(sqrt(r) * cMaxPower) - random((Level - 1) * 17 + 1);

            ap.ExplR:= 0;

            ap.ExplX:= EX;

            ap.ExplY:= EY;

            valueResult:= value

            end;

     end

until (rTime > 5050 - Level * 800);

TestSnowball:= valueResult

end;

function TestMolotov(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

var Vx, Vy, r: real;

    Score, EX, EY, valueResult: LongInt;

    TestTime: LongInt;

    x, y, dY, meX, meY: real;

    t: LongInt;

begin

meX:= hwFloat2Float(Me^.X);

meY:= hwFloat2Float(Me^.Y);

valueResult:= BadTurn;

TestTime:= 0;

ap.ExplR:= 0;

repeat

    inc(TestTime, 300);

    Vx:= (Targ.Point.X - meX) / TestTime;

    Vy:= cGravityf * (TestTime div 2) - Targ.Point.Y - meY / TestTime;

    r:= sqr(Vx) + sqr(Vy);

    if not (r > 1) then

        begin

        x:= meX;

        y:= meY;

        dY:= -Vy;

        t:= TestTime;

        repeat

            x:= x + Vx;

            y:= y + dY;

            dY:= dY + cGravityf;

            dec(t)

        until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 6)) or

               ((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 6))) or (t = 0);

        EX:= trunc(x);

        EY:= trunc(y);

        if t < 50 then

            Score:= RateExplosion(Me, EX, EY, 97)  // average of 17 attempts, most good, but some failing spectacularly

        else

            Score:= BadTurn;

        if valueResult < Score then

            begin

            ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));

            ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);

            ap.ExplR:= 100;

            ap.ExplX:= EX;

            ap.ExplY:= EY;

            valueResult:= Score

            end;

        end

until (TestTime > 5050 - Level * 800);

TestMolotov:= valueResult

end;

function TestGrenade(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

const tDelta = 24;

var Vx, Vy, r: real;

    Score, EX, EY, valueResult: LongInt;

    TestTime: LongInt;

    x, y, meX, meY, dY: real;

    t: LongInt;

begin

valueResult:= BadTurn;

TestTime:= 0;

ap.ExplR:= 0;

meX:= hwFloat2Float(Me^.X);

meY:= hwFloat2Float(Me^.Y);

repeat

    inc(TestTime, 1000);

    Vx:= (Targ.Point.X - meX) / (TestTime + tDelta);

    Vy:= cGravityf * ((TestTime + tDelta) div 2) - (Targ.Point.Y - meY) / (TestTime + tDelta);

    r:= sqr(Vx) + sqr(Vy);

    if not (r > 1) then

        begin

        x:= meX;

        y:= meY;

        dY:= -Vy;

        t:= TestTime;

        repeat

            x:= x + Vx;

            y:= y + dY;

            dY:= dY + cGravityf;

            dec(t)

        until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or

               ((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5))) or (t = 0);

    EX:= trunc(x);

    EY:= trunc(y);

    if t < 50 then

        if Level = 1 then

            Score:= RateExplosion(Me, EX, EY, 101, afTrackFall or afErasesLand)

        else Score:= RateExplosion(Me, EX, EY, 101)

    else

        Score:= BadTurn;

    if (valueResult < Score) and (Score > 0) then

        begin

        ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level * 3));

        ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 20);

        ap.Time:= TestTime;

        ap.ExplR:= 100;

        ap.ExplX:= EX;

        ap.ExplY:= EY;

        valueResult:= Score

        end;

    end

//until (Score > 204800) or (TestTime > 4000);

until TestTime > 4500 - Level * 512;

TestGrenade:= valueResult

end;

function TestClusterBomb(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt;

const tDelta = 24;

var Vx, Vy, r: real;

    Score, EX, EY, valueResult: LongInt;

    TestTime: Longword;

    x, y, dY, meX, meY: real;

    t: LongInt;

begin

valueResult:= BadTurn;

TestTime:= 500;

ap.ExplR:= 0;

meX:= hwFloat2Float(Me^.X);

meY:= hwFloat2Float(Me^.Y);

repeat

    inc(TestTime, 900);

    // Try to overshoot slightly, seems to pay slightly better dividends in terms of hitting cluster

    if meX<Targ.Point.X then

        Vx:= ((Targ.Point.X+10) - meX) / (TestTime + tDelta)

    else

        Vx:= ((Targ.Point.X-10) - meX) / (TestTime + tDelta);

    Vy:= cGravityf * ((TestTime + tDelta) div 2) - ((Targ.Point.Y-50) - meY) / (TestTime + tDelta);

    r:= sqr(Vx)+sqr(Vy);

    if not (r > 1) then

        begin

        x:= meX;

        y:= meY;

        dY:= -Vy;

        t:= TestTime;

    repeat

        x:= x + Vx;

        y:= y + dY;

        dY:= dY + cGravityf;

        dec(t)

    until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or

           ((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5))) or (t = 0);

    EX:= trunc(x);

    EY:= trunc(y);

    if t < 50 then

        Score:= RateExplosion(Me, EX, EY, 41)