hedgewars/uAIAmmoTests.pas
author Xeli
Mon, 28 May 2012 19:33:57 +0200
changeset 7141 ea6ad9a97fca
parent 7134 beb16926ae5c
child 7154 56e329edf4b8
permissions -rw-r--r--
change the array which represents the keyboard state to be a boolean array rather than byte array
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
71
5f56c6979496 - Changed falling damage scoring
unc0rr
parents: 70
diff changeset
     1
(*
1066
1f1b3686a2b0 Update copyright headers a bit
unc0rr
parents: 1024
diff changeset
     2
 * Hedgewars, a free turn based strategy game
6700
e04da46ee43c the most important commit of the year
koda
parents: 6580
diff changeset
     3
 * Copyright (c) 2004-2012 Andrey Korotaev <unC0Rr@gmail.com>
71
5f56c6979496 - Changed falling damage scoring
unc0rr
parents: 70
diff changeset
     4
 *
183
57c2ef19f719 Relicense to GPL
unc0rr
parents: 143
diff changeset
     5
 * This program is free software; you can redistribute it and/or modify
57c2ef19f719 Relicense to GPL
unc0rr
parents: 143
diff changeset
     6
 * it under the terms of the GNU General Public License as published by
57c2ef19f719 Relicense to GPL
unc0rr
parents: 143
diff changeset
     7
 * the Free Software Foundation; version 2 of the License
71
5f56c6979496 - Changed falling damage scoring
unc0rr
parents: 70
diff changeset
     8
 *
183
57c2ef19f719 Relicense to GPL
unc0rr
parents: 143
diff changeset
     9
 * This program is distributed in the hope that it will be useful,
57c2ef19f719 Relicense to GPL
unc0rr
parents: 143
diff changeset
    10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
57c2ef19f719 Relicense to GPL
unc0rr
parents: 143
diff changeset
    11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
57c2ef19f719 Relicense to GPL
unc0rr
parents: 143
diff changeset
    12
 * GNU General Public License for more details.
71
5f56c6979496 - Changed falling damage scoring
unc0rr
parents: 70
diff changeset
    13
 *
183
57c2ef19f719 Relicense to GPL
unc0rr
parents: 143
diff changeset
    14
 * You should have received a copy of the GNU General Public License
57c2ef19f719 Relicense to GPL
unc0rr
parents: 143
diff changeset
    15
 * along with this program; if not, write to the Free Software
57c2ef19f719 Relicense to GPL
unc0rr
parents: 143
diff changeset
    16
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
71
5f56c6979496 - Changed falling damage scoring
unc0rr
parents: 70
diff changeset
    17
 *)
5f56c6979496 - Changed falling damage scoring
unc0rr
parents: 70
diff changeset
    18
2630
079ef82eac75 revamped file access and debug display
koda
parents: 2616
diff changeset
    19
{$INCLUDE "options.inc"}
079ef82eac75 revamped file access and debug display
koda
parents: 2616
diff changeset
    20
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    21
unit uAIAmmoTests;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    22
interface
4357
a1fcfc341a52 Introduce unit uTypes in order to remove some cyclic unit dependencies
unC0Rr
parents: 4317
diff changeset
    23
uses SDLh, uConsts, uFloat, uTypes;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
    24
const amtest_OnTurn = $00000001;
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
    25
7078
a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition
nemo
parents: 7041
diff changeset
    26
var windSpeed: real;
a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition
nemo
parents: 7041
diff changeset
    27
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
    28
type TAttackParams = record
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    29
        Time: Longword;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    30
        Angle, Power: LongInt;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    31
        ExplX, ExplY, ExplR: LongInt;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    32
        AttackPutX, AttackPutY: LongInt;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    33
        end;
433
9f8f22094c0e AI thinks in separate thread
unc0rr
parents: 409
diff changeset
    34
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
    35
function TestBazooka(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
4580
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
    36
function TestSnowball(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
    37
function TestGrenade(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
3018
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking.
nemo
parents: 2978
diff changeset
    38
function TestMolotov(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
2978
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
    39
function TestClusterBomb(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
2973
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
    40
function TestWatermelon(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
    41
function TestMortar(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
    42
function TestShotgun(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
    43
function TestDesertEagle(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
    44
function TestBaseballBat(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
    45
function TestFirePunch(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
6770
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
    46
function TestWhip(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
    47
function TestAirAttack(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
3370
37f4f83fedb1 Teleport AI:
mbait
parents: 3350
diff changeset
    48
function TestTeleport(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
5645
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
    49
function TestHammer(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
    50
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
    51
type TAmmoTestProc = function (Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    52
    TAmmoTest = record
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    53
            proc: TAmmoTestProc;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    54
            flags: Longword;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    55
            end;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
    56
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
    57
const AmmoTests: array[TAmmoType] of TAmmoTest =
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    58
            (
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    59
            (proc: nil;              flags: 0), // amNothing
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    60
            (proc: @TestGrenade;     flags: 0), // amGrenade
2978
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
    61
            (proc: @TestClusterBomb; flags: 0), // amClusterBomb
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    62
            (proc: @TestBazooka;     flags: 0), // amBazooka
3080
b7fa8ad60e3b Engine:
smxx
parents: 3066
diff changeset
    63
            (proc: nil;              flags: 0), // amBee
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    64
            (proc: @TestShotgun;     flags: 0), // amShotgun
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    65
            (proc: nil;              flags: 0), // amPickHammer
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    66
            (proc: nil;              flags: 0), // amSkip
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    67
            (proc: nil;              flags: 0), // amRope
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    68
            (proc: nil;              flags: 0), // amMine
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    69
            (proc: @TestDesertEagle; flags: 0), // amDEagle
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    70
            (proc: nil;              flags: 0), // amDynamite
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    71
            (proc: @TestFirePunch;   flags: 0), // amFirePunch
6770
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
    72
            (proc: @TestWhip;        flags: 0), // amWhip
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    73
            (proc: @TestBaseballBat; flags: 0), // amBaseballBat
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    74
            (proc: nil;              flags: 0), // amParachute
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    75
            (proc: @TestAirAttack;   flags: amtest_OnTurn), // amAirAttack
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    76
            (proc: nil;              flags: 0), // amMineStrike
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    77
            (proc: nil;              flags: 0), // amBlowTorch
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    78
            (proc: nil;              flags: 0), // amGirder
3739
97cf933e5bd2 disable AI teleport
koda
parents: 3717
diff changeset
    79
            (proc: nil;              flags: 0), // amTeleport
97cf933e5bd2 disable AI teleport
koda
parents: 3717
diff changeset
    80
            //(proc: @TestTeleport;    flags: amtest_OnTurn), // amTeleport
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    81
            (proc: nil;              flags: 0), // amSwitch
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    82
            (proc: @TestMortar;      flags: 0), // amMortar
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    83
            (proc: nil;              flags: 0), // amKamikaze
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    84
            (proc: nil;              flags: 0), // amCake
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    85
            (proc: nil;              flags: 0), // amSeduction
2973
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
    86
            (proc: @TestWatermelon;  flags: 0), // amWatermelon
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    87
            (proc: nil;              flags: 0), // amHellishBomb
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    88
            (proc: nil;              flags: 0), // amNapalm
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    89
            (proc: nil;              flags: 0), // amDrill
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    90
            (proc: nil;              flags: 0), // amBallgun
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    91
            (proc: nil;              flags: 0), // amRCPlane
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    92
            (proc: nil;              flags: 0), // amLowGravity
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    93
            (proc: nil;              flags: 0), // amExtraDamage
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    94
            (proc: nil;              flags: 0), // amInvulnerable
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    95
            (proc: nil;              flags: 0), // amExtraTime
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    96
            (proc: nil;              flags: 0), // amLaserSight
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    97
            (proc: nil;              flags: 0), // amVampiric
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    98
            (proc: nil;              flags: 0), // amSniperRifle
3342
b4f01613dcd7 Some initial stubs for portal just so Tiy will quit nagging. Also let folks know what approximation of physics I plan to try, here.
nemo
parents: 3236
diff changeset
    99
            (proc: nil;              flags: 0), // amJetpack
3066
5c0efa437728 Enable birdy. Has egg bombing. Eggs should possibly have a dX component. No poison yet, no egg sprite.
nemo
parents: 3022
diff changeset
   100
            (proc: @TestMolotov;     flags: 0), // amMolotov
3350
5cd02aafc612 Engine:
smxx
parents: 3342
diff changeset
   101
            (proc: nil;              flags: 0), // amBirdy
5cd02aafc612 Engine:
smxx
parents: 3342
diff changeset
   102
            (proc: nil;              flags: 0), // amPortalGun
3382
633046fa040c Gas grenade:
mbait
parents: 3372
diff changeset
   103
            (proc: nil;              flags: 0), // amPiano
3384
7eb4707d43f0 * added some comments
sheepluva
parents: 3382
diff changeset
   104
            (proc: @TestGrenade;     flags: 0), // amGasBomb
3476
1ec68b8d3bd1 Henek adds a flamethrower, updates some translations, and tweaks how fire works.
nemo
parents: 3439
diff changeset
   105
            (proc: @TestShotgun;     flags: 0), // amSineGun
3710
411f5c2b5292 Engine:
smaxx
parents: 3697
diff changeset
   106
            (proc: nil;              flags: 0), // amFlamethrower
3717
d88719b0f0dc Engine:
smaxx
parents: 3710
diff changeset
   107
            (proc: @TestGrenade;     flags: 0), // amSMine
5645
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   108
            (proc: @TestHammer;      flags: 0), // amHammer
4246
e5cb885492df drillstrike! might require the drill patch to improve behavior
koda
parents: 4226
diff changeset
   109
            (proc: nil;              flags: 0), // amResurrector
4881
35e6269227b6 still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents: 4580
diff changeset
   110
            (proc: nil;              flags: 0), // amDrillStrike
7078
a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition
nemo
parents: 7041
diff changeset
   111
            (proc: nil;              flags: 0), // amSnowball
4883
7cddc9201a1d added dummy for tardis and ugly icons for tardis and structure
Henek
parents: 4881
diff changeset
   112
            (proc: nil;              flags: 0), // amTardis
5024
1e332947147c Landgun, first pass. At sdw's request.
nemo
parents: 4976
diff changeset
   113
            (proc: nil;              flags: 0), // amStructure
7007
0ccdff4ae8e9 Initial stub for freezer
nemo
parents: 6992
diff changeset
   114
            (proc: nil;              flags: 0), // amLandGun
0ccdff4ae8e9 Initial stub for freezer
nemo
parents: 6992
diff changeset
   115
            (proc: nil;              flags: 0)  // amIceGun
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   116
            );
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   117
439
c336ed82e76d Fix bugs:
unc0rr
parents: 438
diff changeset
   118
const BadTurn = Low(LongInt) div 4;
369
2aed85310727 AI compiles, but doesn't work
unc0rr
parents: 351
diff changeset
   119
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   120
implementation
4374
bcefeeabaa33 Move some stuff from uMisc to uUtils
unC0Rr
parents: 4367
diff changeset
   121
uses uAIMisc, uVariables, uUtils;
370
c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents: 369
diff changeset
   122
5150
63ad8a648afd Allow head of rope to attach to hogs/barrels/crates again. Rope still does not, to avoid the bug.
nemo
parents: 5024
diff changeset
   123
function Metric(x1, y1, x2, y2: LongInt): LongInt; inline;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   124
begin
370
c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents: 369
diff changeset
   125
Metric:= abs(x1 - x2) + abs(y1 - y2)
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   126
end;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   127
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   128
function TestBazooka(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
5151
cbadb9fa52fc An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster.
nemo
parents: 5150
diff changeset
   129
var Vx, Vy, r, mX, mY: real;
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 439
diff changeset
   130
    rTime: LongInt;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   131
    EX, EY: LongInt;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   132
    valueResult: LongInt;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   133
    x, y, dX, dY: real;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   134
    t: LongInt;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   135
    value: LongInt;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   136
begin
5151
cbadb9fa52fc An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster.
nemo
parents: 5150
diff changeset
   137
mX:= hwFloat2Float(Me^.X);
cbadb9fa52fc An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster.
nemo
parents: 5150
diff changeset
   138
mY:= hwFloat2Float(Me^.Y);
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   139
ap.Time:= 0;
375
18012da67681 AI works properly
unc0rr
parents: 374
diff changeset
   140
rTime:= 350;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   141
ap.ExplR:= 0;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   142
valueResult:= BadTurn;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   143
repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   144
    rTime:= rTime + 300 + Level * 50 + random(300);
7078
a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition
nemo
parents: 7041
diff changeset
   145
    Vx:= - windSpeed * rTime * 0.5 + (Targ.X + AIrndSign(2) - mX) / rTime;
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   146
    Vy:= cGravityf * rTime * 0.5 - (Targ.Y - mY) / rTime;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   147
    r:= sqr(Vx) + sqr(Vy);
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   148
    if not (r > 1) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   149
        begin
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   150
        x:= mX;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   151
        y:= mY;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   152
        dX:= Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   153
        dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   154
        t:= rTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   155
        repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   156
            x:= x + dX;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   157
            y:= y + dY;
7078
a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition
nemo
parents: 7041
diff changeset
   158
            dX:= dX + windSpeed;
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   159
            dY:= dY + cGravityf;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   160
            dec(t)
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   161
        until TestCollExcludingMe(Me, trunc(x), trunc(y), 5) or (t <= 0);
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   162
        
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   163
        EX:= trunc(x);
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   164
        EY:= trunc(y);
6767
ccbf07b38a43 First pass at making AI drowning aware. No concerns of performance, only applied to bazooka (not bat/fp etc)
nemo
parents: 6700
diff changeset
   165
        if Me^.Hedgehog^.BotLevel = 1 then
ccbf07b38a43 First pass at making AI drowning aware. No concerns of performance, only applied to bazooka (not bat/fp etc)
nemo
parents: 6700
diff changeset
   166
            value:= RateExplosion(Me, EX, EY, 101, 3)
ccbf07b38a43 First pass at making AI drowning aware. No concerns of performance, only applied to bazooka (not bat/fp etc)
nemo
parents: 6700
diff changeset
   167
        else value:= RateExplosion(Me, EX, EY, 101);
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   168
        if value = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   169
            value:= - Metric(Targ.X, Targ.Y, EX, EY) div 64;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   170
        if valueResult <= value then
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   171
            begin
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   172
            ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random((Level - 1) * 9));
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   173
            ap.Power:= trunc(sqrt(r) * cMaxPower) - random((Level - 1) * 17 + 1);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   174
            ap.ExplR:= 100;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   175
            ap.ExplX:= EX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   176
            ap.ExplY:= EY;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   177
            valueResult:= value
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   178
            end;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   179
        end
6772
13d13aefa4de small tweak. make drowning prefer higher health hogs
nemo
parents: 6771
diff changeset
   180
//until (value > 204800) or (rTime > 4250); not so useful since adding score to the drowning
13d13aefa4de small tweak. make drowning prefer higher health hogs
nemo
parents: 6771
diff changeset
   181
until rTime > 4250;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   182
TestBazooka:= valueResult
39
b78e7185ed13 - Increased FPS
unc0rr
parents: 37
diff changeset
   183
end;
374
95169697cc38 - UFO smokes
unc0rr
parents: 371
diff changeset
   184
4580
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   185
function TestSnowball(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   186
var Vx, Vy, r: real;
4580
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   187
    rTime: LongInt;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   188
    EX, EY: LongInt;
4580
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   189
    valueResult: LongInt;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   190
    x, y, dX, dY, meX, meY: real;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   191
    t: LongInt;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   192
    value: LongInt;
4580
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   193
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   194
begin
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   195
meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   196
meY:= hwFloat2Float(Me^.Y);
4580
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   197
ap.Time:= 0;
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   198
rTime:= 350;
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   199
ap.ExplR:= 0;
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   200
valueResult:= BadTurn;
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   201
repeat
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   202
    rTime:= rTime + 300 + Level * 50 + random(1000);
7078
a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition
nemo
parents: 7041
diff changeset
   203
    Vx:= - windSpeed * rTime * 0.5 + ((Targ.X + AIrndSign(2)) - meX) / rTime;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   204
    Vy:= cGravityf * rTime * 0.5 - (Targ.Y - meY) / rTime;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   205
    r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   206
    if not (r > 1) then
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   207
        begin
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   208
        x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   209
        y:= meY;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   210
        dX:= Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   211
        dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   212
        t:= rTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   213
        repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   214
            x:= x + dX;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   215
            y:= y + dY;
7078
a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition
nemo
parents: 7041
diff changeset
   216
            dX:= dX + windSpeed;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   217
            dY:= dY + cGravityf;
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   218
            dec(t)
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   219
        until TestCollExcludingMe(Me, trunc(x), trunc(y), 5) or (t <= 0);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   220
        EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   221
        EY:= trunc(y);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   222
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   223
        value:= RateShove(Me, trunc(x), trunc(y), 5, 1, trunc((abs(dX)+abs(dY))*20), -dX, -dY, 1);
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   224
        if value = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   225
            value:= - Metric(Targ.X, Targ.Y, EX, EY) div 64;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   226
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   227
        if valueResult <= value then
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   228
            begin
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   229
            ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random((Level - 1) * 9));
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   230
            ap.Power:= trunc(sqrt(r) * cMaxPower) - random((Level - 1) * 17 + 1);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   231
            ap.ExplR:= 0;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   232
            ap.ExplX:= EX;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   233
            ap.ExplY:= EY;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   234
            valueResult:= value
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   235
            end;
4580
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   236
     end
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   237
until (rTime > 4250);
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   238
TestSnowball:= valueResult
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   239
end;
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   240
3018
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking.
nemo
parents: 2978
diff changeset
   241
function TestMolotov(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   242
var Vx, Vy, r: real;
3018
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking.
nemo
parents: 2978
diff changeset
   243
    Score, EX, EY, valueResult: LongInt;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking.
nemo
parents: 2978
diff changeset
   244
    TestTime: Longword;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   245
    x, y, dY, meX, meY: real;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   246
    t: LongInt;
3018
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking.
nemo
parents: 2978
diff changeset
   247
begin
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   248
meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   249
meY:= hwFloat2Float(Me^.Y);
3018
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking.
nemo
parents: 2978
diff changeset
   250
valueResult:= BadTurn;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking.
nemo
parents: 2978
diff changeset
   251
TestTime:= 0;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking.
nemo
parents: 2978
diff changeset
   252
ap.ExplR:= 0;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking.
nemo
parents: 2978
diff changeset
   253
repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   254
    inc(TestTime, 300);
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   255
    Vx:= (Targ.X - meX) / TestTime;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   256
    Vy:= cGravityf * (TestTime div 2) - Targ.Y - meY / TestTime;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   257
    r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   258
    if not (r > 1) then
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   259
        begin
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   260
        x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   261
        y:= meY;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   262
        dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   263
        t:= TestTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   264
        repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   265
            x:= x + Vx;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   266
            y:= y + dY;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   267
            dY:= dY + cGravityf;
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   268
            dec(t)
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   269
        until TestCollExcludingMe(Me, trunc(x), trunc(y), 7) or (t = 0);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   270
        EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   271
        EY:= trunc(y);
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   272
        if t < 50 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   273
            Score:= RateExplosion(Me, EX, EY, 97)  // average of 17 attempts, most good, but some failing spectacularly
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   274
        else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   275
            Score:= BadTurn;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   276
                  
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   277
        if valueResult < Score then
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   278
            begin
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   279
            ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   280
            ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   281
            ap.Time:= TestTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   282
            ap.ExplR:= 100;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   283
            ap.ExplX:= EX;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   284
            ap.ExplY:= EY;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   285
            valueResult:= Score
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   286
            end;
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   287
        end
3022
94afd5fc5738 Adjust increment since there is no timer
nemo
parents: 3018
diff changeset
   288
until (TestTime > 4250);
3018
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking.
nemo
parents: 2978
diff changeset
   289
TestMolotov:= valueResult
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking.
nemo
parents: 2978
diff changeset
   290
end;
13ceaad4767e Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking.
nemo
parents: 2978
diff changeset
   291
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   292
function TestGrenade(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
70
82d93eeecebe - Many AI improvements
unc0rr
parents: 66
diff changeset
   293
const tDelta = 24;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   294
var Vx, Vy, r: real;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   295
    Score, EX, EY, valueResult: LongInt;
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   296
    TestTime: Longword;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   297
    x, y, meX, meY, dY: real;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   298
    t: LongInt;
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   299
begin
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   300
valueResult:= BadTurn;
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   301
TestTime:= 0;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   302
ap.ExplR:= 0;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   303
meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   304
meY:= hwFloat2Float(Me^.Y);
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   305
repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   306
    inc(TestTime, 1000);
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   307
    Vx:= (Targ.X - meX) / (TestTime + tDelta);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   308
    Vy:= cGravityf * ((TestTime + tDelta) div 2) - (Targ.Y - meY) / (TestTime + tDelta);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   309
    r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   310
    if not (r > 1) then
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   311
        begin
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   312
        x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   313
        y:= meY; 
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   314
        dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   315
        t:= TestTime;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   316
        repeat
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   317
            x:= x + Vx;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   318
            y:= y + dY;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   319
            dY:= dY + cGravityf;
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   320
            dec(t)
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   321
        until TestCollExcludingMe(Me, trunc(x), trunc(y), 5) or (t = 0);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   322
    EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   323
    EY:= trunc(y);
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   324
    if t < 50 then 
6769
44ad49a3a126 Add drowning to grenade too, try some little optimisations
nemo
parents: 6767
diff changeset
   325
        if Me^.Hedgehog^.BotLevel = 1 then
44ad49a3a126 Add drowning to grenade too, try some little optimisations
nemo
parents: 6767
diff changeset
   326
            Score:= RateExplosion(Me, EX, EY, 101, 3)
44ad49a3a126 Add drowning to grenade too, try some little optimisations
nemo
parents: 6767
diff changeset
   327
        else Score:= RateExplosion(Me, EX, EY, 101)
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   328
    else 
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   329
        Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   330
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   331
    if valueResult < Score then
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   332
        begin
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   333
        ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   334
        ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   335
        ap.Time:= TestTime;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   336
        ap.ExplR:= 100;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   337
        ap.ExplX:= EX;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   338
        ap.ExplY:= EY;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   339
        valueResult:= Score
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   340
        end;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   341
    end
6772
13d13aefa4de small tweak. make drowning prefer higher health hogs
nemo
parents: 6771
diff changeset
   342
//until (Score > 204800) or (TestTime > 4000);
13d13aefa4de small tweak. make drowning prefer higher health hogs
nemo
parents: 6771
diff changeset
   343
until TestTime > 4000;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   344
TestGrenade:= valueResult
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   345
end;
375
18012da67681 AI works properly
unc0rr
parents: 374
diff changeset
   346
2978
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   347
function TestClusterBomb(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   348
const tDelta = 24;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   349
var Vx, Vy, r: real;
2978
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   350
    Score, EX, EY, valueResult: LongInt;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   351
    TestTime: Longword;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   352
    x, y, dY, meX, meY: real;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   353
    t: LongInt;
2978
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   354
begin
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   355
valueResult:= BadTurn;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   356
TestTime:= 0;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   357
ap.ExplR:= 0;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   358
meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   359
meY:= hwFloat2Float(Me^.Y);
2978
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   360
repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   361
    inc(TestTime, 1000);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   362
    // Try to overshoot slightly, seems to pay slightly better dividends in terms of hitting cluster
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   363
    if meX<Targ.X then
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   364
        Vx:= ((Targ.X+10) - meX) / (TestTime + tDelta)
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   365
    else
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   366
        Vx:= ((Targ.X-10) - meX) / (TestTime + tDelta);
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   367
    Vy:= cGravityf * ((TestTime + tDelta) div 2) - ((Targ.Y-50) - meY) / (TestTime + tDelta);
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   368
    r:= sqr(Vx)+sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   369
    if not (r > 1) then
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   370
        begin
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   371
        x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   372
        y:= meY;
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   373
        dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   374
        t:= TestTime;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   375
    repeat
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   376
        x:= x + Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   377
        y:= y + dY;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   378
        dY:= dY + cGravityf;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   379
        dec(t)
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   380
    until TestCollExcludingMe(Me, trunc(x), trunc(y), 5) or (t = 0);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   381
    EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   382
    EY:= trunc(y);
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   383
    if t < 50 then 
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   384
        Score:= RateExplosion(Me, EX, EY, 41)
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   385
    else 
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   386
        Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   387
2978
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   388
     if valueResult < Score then
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   389
        begin
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   390
        ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   391
        ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
2978
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   392
        ap.Time:= TestTime;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   393
        ap.ExplR:= 90;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   394
        ap.ExplX:= EX;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   395
        ap.ExplY:= EY;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   396
        valueResult:= Score
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   397
        end;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   398
     end
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   399
until (TestTime = 4000);
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   400
TestClusterBomb:= valueResult
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   401
end;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   402
2973
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   403
function TestWatermelon(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   404
const tDelta = 24;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   405
var Vx, Vy, r: real;
2973
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   406
    Score, EX, EY, valueResult: LongInt;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   407
    TestTime: Longword;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   408
    x, y, dY, meX, meY: real;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   409
    t: LongInt;
2973
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   410
begin
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   411
valueResult:= BadTurn;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   412
TestTime:= 0;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   413
ap.ExplR:= 0;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   414
meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   415
meY:= hwFloat2Float(Me^.Y);
2973
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   416
repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   417
    inc(TestTime, 1000);
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   418
    Vx:= (Targ.X - meX) / (TestTime + tDelta);
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   419
    Vy:= cGravityf * ((TestTime + tDelta) div 2) - ((Targ.Y-50) - meY) / (TestTime + tDelta);
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   420
    r:= sqr(Vx)+sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   421
    if not (r > 1) then
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   422
        begin
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   423
        x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   424
        y:= meY;
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   425
        dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   426
        t:= TestTime;
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   427
        repeat
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   428
            x:= x + Vx;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   429
            y:= y + dY;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   430
            dY:= dY + cGravityf;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   431
            dec(t)
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   432
        until TestCollExcludingMe(Me, trunc(x), trunc(y), 7) or (t = 0);
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   433
        
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   434
        EX:= trunc(x);
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   435
        EY:= trunc(y);
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   436
        if t < 50 then 
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   437
            Score:= RateExplosion(Me, EX, EY, 200) + RateExplosion(Me, EX, EY + 120, 200)
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   438
        else 
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   439
            Score:= BadTurn;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   440
            
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   441
        if valueResult < Score then
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   442
            begin
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   443
            ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   444
            ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   445
            ap.Time:= TestTime;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   446
            ap.ExplR:= 300;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   447
            ap.ExplX:= EX;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   448
            ap.ExplY:= EY;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   449
            valueResult:= Score
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   450
            end;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   451
        end
2973
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   452
until (TestTime = 4000);
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   453
TestWatermelon:= valueResult
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   454
end;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   455
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   456
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   457
    function Solve(TX, TY, MX, MY: LongInt): LongWord;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   458
    var A, B, D, T: real;
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   459
        C: LongInt;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   460
    begin
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   461
        A:= sqr(cGravityf);
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   462
        B:= - cGravityf * (TY - MY) - 1;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   463
        C:= sqr(TY - MY) + sqr(TX - MX);
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   464
        D:= sqr(B) - A * C;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   465
        if D >= 0 then
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   466
            begin
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   467
            D:= sqrt(D) - B;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   468
            if D >= 0 then
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   469
                T:= sqrt(D * 2 / A)
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   470
            else
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   471
                T:= 0;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   472
            Solve:= trunc(T)
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   473
            end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   474
            else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   475
                Solve:= 0
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   476
    end;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   477
    
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   478
function TestMortar(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   479
//const tDelta = 24;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   480
var Vx, Vy: real;
6990
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6894
diff changeset
   481
    Score, EX, EY: LongInt;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   482
    TestTime: Longword;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   483
    x, y, dY, meX, meY: real;
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   484
begin
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   485
    TestMortar:= BadTurn;
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   486
    ap.ExplR:= 0;
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   487
    meX:= hwFloat2Float(Me^.X);
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   488
    meY:= hwFloat2Float(Me^.Y);
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   489
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   490
    if (Level > 2) then
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   491
        exit(BadTurn);
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   492
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   493
    TestTime:= Solve(Targ.X, Targ.Y, trunc(meX), trunc(meY));
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   494
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   495
    if TestTime = 0 then
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   496
        exit(BadTurn);
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   497
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   498
    Vx:= (Targ.X - meX) / TestTime;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   499
    Vy:= cGravityf * (TestTime div 2) - (Targ.Y - meY) / TestTime;
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   500
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   501
    x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   502
    y:= meY;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   503
    dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   504
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   505
    repeat
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   506
        x:= x + Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   507
        y:= y + dY;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   508
        dY:= dY + cGravityf;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   509
        EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   510
        EY:= trunc(y);
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   511
    until TestCollExcludingMe(Me, EX, EY, 5) or (EY > cWaterLine);
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   512
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   513
    if (EY < cWaterLine) and (dY >= 0) then
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   514
        begin
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   515
        Score:= RateExplosion(Me, EX, EY, 91);
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   516
        if (Score = 0) then
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   517
            if (dY > 0.15) then
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   518
                Score:= - abs(Targ.Y - EY) div 32
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   519
            else
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   520
                Score:= BadTurn
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   521
        else if (Score < 0) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   522
            Score:= BadTurn
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   523
        end
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   524
    else
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   525
        Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   526
6990
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6894
diff changeset
   527
    if BadTurn < Score then
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   528
        begin
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   529
        ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   530
        ap.Power:= 1;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   531
        ap.ExplR:= 100;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   532
        ap.ExplX:= EX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   533
        ap.ExplY:= EY;
6990
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6894
diff changeset
   534
        TestMortar:= Score
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   535
        end;
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   536
end;
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   537
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   538
function TestShotgun(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
1941
b1ef1f86148c Some AI tweaks by imcold
unc0rr
parents: 1854
diff changeset
   539
const
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   540
    MIN_RANGE =  80;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   541
    MAX_RANGE = 400;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   542
var Vx, Vy, x, y: real;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   543
    rx, ry, valueResult: LongInt;
1941
b1ef1f86148c Some AI tweaks by imcold
unc0rr
parents: 1854
diff changeset
   544
    range: integer;
375
18012da67681 AI works properly
unc0rr
parents: 374
diff changeset
   545
begin
6990
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6894
diff changeset
   546
TestShotgun:= BadTurn;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   547
ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   548
ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   549
ap.Power:= 1;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   550
x:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   551
y:= hwFloat2Float(Me^.Y);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   552
range:= Metric(trunc(x), trunc(y), Targ.X, Targ.Y);
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   553
if ( range < MIN_RANGE ) or ( range > MAX_RANGE ) then
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   554
    exit(BadTurn);
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   555
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   556
Vx:= (Targ.X - x) * 1 / 1024;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   557
Vy:= (Targ.Y - y) * 1 / 1024;
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   558
ap.Angle:= DxDy2AttackAnglef(Vx, -Vy);
70
82d93eeecebe - Many AI improvements
unc0rr
parents: 66
diff changeset
   559
repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   560
    x:= x + vX;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   561
    y:= y + vY;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   562
    rx:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   563
    ry:= trunc(y);
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   564
    if TestCollExcludingMe(Me, rx, ry, 2) then
6990
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6894
diff changeset
   565
    begin
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   566
        x:= x + vX * 8;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   567
        y:= y + vY * 8;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   568
        valueResult:= RateShotgun(Me, vX, vY, rx, ry);
5642
0ce9e01bae56 Make AI aware of damage modifiers
unc0rr
parents: 5164
diff changeset
   569
     
6990
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6894
diff changeset
   570
        if valueResult = 0 then 
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6894
diff changeset
   571
            valueResult:= - Metric(Targ.X, Targ.Y, rx, ry) div 64
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6894
diff changeset
   572
        else 
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6894
diff changeset
   573
            dec(valueResult, Level * 4000);
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6894
diff changeset
   574
        // 27/20 is reuse bonus
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   575
        exit(valueResult * 27 div 20)
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   576
    end
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   577
until (Abs(Targ.X - trunc(x)) + Abs(Targ.Y - trunc(y)) < 4)
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   578
    or (x < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   579
    or (y < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   580
    or (trunc(x) > LAND_WIDTH)
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   581
    or (trunc(y) > LAND_HEIGHT);
4157
f8898d6cca6e Fix some warnings
unc0rr
parents: 3963
diff changeset
   582
375
18012da67681 AI works properly
unc0rr
parents: 374
diff changeset
   583
TestShotgun:= BadTurn
70
82d93eeecebe - Many AI improvements
unc0rr
parents: 66
diff changeset
   584
end;
438
04bcc3fb127a Fix AI using shotgun and Desert Eagle
unc0rr
parents: 434
diff changeset
   585
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   586
function TestDesertEagle(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
6783
8d9160b85bdb Add fall damage
nemo
parents: 6782
diff changeset
   587
var Vx, Vy, x, y, t, dmgMod: real;
75
d2b737858ff7 - New First Aid powerup
unc0rr
parents: 74
diff changeset
   588
    d: Longword;
6783
8d9160b85bdb Add fall damage
nemo
parents: 6782
diff changeset
   589
    fallDmg, valueResult: LongInt;
75
d2b737858ff7 - New First Aid powerup
unc0rr
parents: 74
diff changeset
   590
begin
6783
8d9160b85bdb Add fall damage
nemo
parents: 6782
diff changeset
   591
dmgMod:= 0.01 * hwFloat2Float(cDamageModifier) * cDamagePercent;
3407
dcc129c4352e Engine:
smxx
parents: 3384
diff changeset
   592
Level:= Level; // avoid compiler hint
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   593
ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   594
ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   595
ap.Power:= 1;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   596
x:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   597
y:= hwFloat2Float(Me^.Y);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   598
if Abs(trunc(x) - Targ.X) + Abs(trunc(y) - Targ.Y) < 40 then
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   599
    begin
6990
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6894
diff changeset
   600
    TestDesertEagle:= BadTurn;
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   601
    exit(BadTurn);
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   602
    end;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   603
t:= 0.5 / sqrt(sqr(Targ.X - x)+sqr(Targ.Y-y));
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   604
Vx:= (Targ.X - x) * t;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   605
Vy:= (Targ.Y - y) * t;
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   606
ap.Angle:= DxDy2AttackAnglef(Vx, -Vy);
75
d2b737858ff7 - New First Aid powerup
unc0rr
parents: 74
diff changeset
   607
d:= 0;
1941
b1ef1f86148c Some AI tweaks by imcold
unc0rr
parents: 1854
diff changeset
   608
75
d2b737858ff7 - New First Aid powerup
unc0rr
parents: 74
diff changeset
   609
repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   610
    x:= x + vX;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   611
    y:= y + vY;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   612
    if ((trunc(x) and LAND_WIDTH_MASK) = 0)and((trunc(y) and LAND_HEIGHT_MASK) = 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   613
    and (Land[trunc(y), trunc(x)] <> 0) then
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   614
        inc(d);
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   615
until (Abs(Targ.X - trunc(x)) + Abs(Targ.Y - trunc(y)) < 4)
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   616
    or (x < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   617
    or (y < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   618
    or (trunc(x) > LAND_WIDTH)
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   619
    or (trunc(y) > LAND_HEIGHT)
4157
f8898d6cca6e Fix some warnings
unc0rr
parents: 3963
diff changeset
   620
    or (d > 200);
1941
b1ef1f86148c Some AI tweaks by imcold
unc0rr
parents: 1854
diff changeset
   621
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   622
if Abs(Targ.X - trunc(x)) + Abs(Targ.Y - trunc(y)) < 3 then
6774
237b96f06aae Try adding it to deagle too. Although the routine still doesn't consider angle, so it'll pretty much be luck. Might be a waste of time.
nemo
parents: 6772
diff changeset
   623
    begin
6783
8d9160b85bdb Add fall damage
nemo
parents: 6782
diff changeset
   624
    fallDmg:= TraceShoveFall(Me, Targ.X, Targ.Y, vX * 0.005 * 20, vY * 0.005 * 20);
8d9160b85bdb Add fall damage
nemo
parents: 6782
diff changeset
   625
    if fallDmg < 0 then
6774
237b96f06aae Try adding it to deagle too. Although the routine still doesn't consider angle, so it'll pretty much be luck. Might be a waste of time.
nemo
parents: 6772
diff changeset
   626
        valueResult:= 204800
6783
8d9160b85bdb Add fall damage
nemo
parents: 6782
diff changeset
   627
    else valueResult:= Max(0, (4 - d div 50) * trunc((7+fallDmg)*dmgMod) * 1024)
6774
237b96f06aae Try adding it to deagle too. Although the routine still doesn't consider angle, so it'll pretty much be luck. Might be a waste of time.
nemo
parents: 6772
diff changeset
   628
    end
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   629
else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   630
    valueResult:= BadTurn;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   631
TestDesertEagle:= valueResult
75
d2b737858ff7 - New First Aid powerup
unc0rr
parents: 74
diff changeset
   632
end;
438
04bcc3fb127a Fix AI using shotgun and Desert Eagle
unc0rr
parents: 434
diff changeset
   633
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   634
function TestBaseballBat(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   635
var valueResult: LongInt;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   636
    x, y: real;
79
29b477319854 - New test map
unc0rr
parents: 78
diff changeset
   637
begin
3407
dcc129c4352e Engine:
smxx
parents: 3384
diff changeset
   638
Level:= Level; // avoid compiler hint
6990
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6894
diff changeset
   639
TestBaseballBat:= BadTurn;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   640
ap.ExplR:= 0;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   641
x:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   642
y:= hwFloat2Float(Me^.Y);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   643
if (Level > 2) or (Abs(trunc(x) - Targ.X) + Abs(trunc(y) - Targ.Y) > 25) then
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   644
    exit(BadTurn);
433
9f8f22094c0e AI thinks in separate thread
unc0rr
parents: 409
diff changeset
   645
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   646
ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   647
ap.Power:= 1;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   648
if (Targ.X) - trunc(x) >= 0 then
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   649
    ap.Angle:=   cMaxAngle div 4
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   650
else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   651
    ap.Angle:= - cMaxAngle div 4;
6770
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   652
6992
b8f3d8991e92 marked a couple of functions as inline
koda
parents: 6990
diff changeset
   653
valueResult:= RateShove(Me, trunc(x) + LongWord(10*hwSignf(Targ.X - x)), trunc(y), 15, 30, 115, hwSign(Me^.dX)*0.353, -0.353, 1);
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   654
if valueResult <= 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   655
    valueResult:= BadTurn
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   656
else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   657
    inc(valueResult);
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   658
TestBaseballBat:= valueResult;
79
29b477319854 - New test map
unc0rr
parents: 78
diff changeset
   659
end;
29b477319854 - New test map
unc0rr
parents: 78
diff changeset
   660
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   661
function TestFirePunch(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
6992
b8f3d8991e92 marked a couple of functions as inline
koda
parents: 6990
diff changeset
   662
var val1: LongInt;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   663
    x, y: real;
82
2f4f3236cccc - New fort
unc0rr
parents: 80
diff changeset
   664
begin
3407
dcc129c4352e Engine:
smxx
parents: 3384
diff changeset
   665
Level:= Level; // avoid compiler hint
7134
beb16926ae5c Some improvements to pas2c
unc0rr
parents: 7132
diff changeset
   666
TestFirePunch:= BadTurn;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   667
ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   668
ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   669
ap.Power:= 1;
6782
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   670
ap.Angle:= hwSign(Me^.dX);
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   671
x:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   672
y:= hwFloat2Float(Me^.Y);
7134
beb16926ae5c Some improvements to pas2c
unc0rr
parents: 7132
diff changeset
   673
if (Abs(trunc(x) - Targ.X) < 25)
beb16926ae5c Some improvements to pas2c
unc0rr
parents: 7132
diff changeset
   674
    and (Abs(trunc(y) - 50 - Targ.Y) < 50) then
3677
7d917b587547 Engine:
smaxx
parents: 3476
diff changeset
   675
    begin
6782
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   676
// TODO - find out WTH this works.
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   677
    if TestColl(trunc(x), trunc(y) - 16, 6) and 
6992
b8f3d8991e92 marked a couple of functions as inline
koda
parents: 6990
diff changeset
   678
       (RateShove(Me, trunc(x) + LongWord(10 * hwSign(Me^.dX)), 
6782
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   679
                      trunc(y) - 40, 30, 30, 40, hwSign(Me^.dX)*0.45, -0.9,  1) = 0) then
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   680
        val1:= Succ(BadTurn)
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   681
    else
6782
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   682
        val1:= BadTurn;
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   683
    exit(val1);
6782
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   684
    end;
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   685
(*
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   686
For some silly reason, having this enabled w/ the AI 
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   687
val1:= 0;
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   688
for i:= 0 to 4 do
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   689
    begin
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   690
    t:= RateShove(Me, trunc(x) + 10 * hwSign(Targ.X - x), trunc(y) - 20 * i - 5, 10, 30, 40, hwSign(Me^.dX)*0.45, -0.9, 1);
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   691
    if (val1 < 0) or (t < 0) then val1:= BadTurn
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   692
    else if t > 0 then val1:= t;
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   693
    end;
433
9f8f22094c0e AI thinks in separate thread
unc0rr
parents: 409
diff changeset
   694
6782
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   695
val2:= 0;
82
2f4f3236cccc - New fort
unc0rr
parents: 80
diff changeset
   696
for i:= 0 to 4 do
6782
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   697
    begin
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   698
    t:= RateShove(Me, trunc(x) + 10 * hwSign(Targ.X - x), trunc(y) - 20 * i - 5, 10, 30, 40, -hwSign(Me^.dX)*0.45, -0.9, 1);
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   699
    if (val2 < 0) or (t < 0) then val2:= BadTurn
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   700
    else if t > 0 then val2:= t;
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   701
    end;
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   702
if (val1 > val2) and (val1 > 0) then 
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   703
    TestFirePunch:= val1
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   704
else if (val2 > val1) and (val2 > 0) then
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   705
    begin
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   706
    ap.Angle:= -hwSign(Me^.dX);
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   707
    TestFirePunch:= val2
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   708
    end
33009ac4de80 For reasons I can't fathom, if this portion isn't commented out, the AI completely fails w/ a weaponset of only firepunch.
nemo
parents: 6775
diff changeset
   709
else TestFirePunch:= BadTurn;*)
82
2f4f3236cccc - New fort
unc0rr
parents: 80
diff changeset
   710
end;
433
9f8f22094c0e AI thinks in separate thread
unc0rr
parents: 409
diff changeset
   711
6770
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   712
function TestWhip(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   713
var i, valueResult: LongInt;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   714
    x, y: real;
6770
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   715
begin
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   716
Level:= Level; // avoid compiler hint
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   717
ap.ExplR:= 0;
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   718
ap.Time:= 0;
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   719
ap.Power:= 1;
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   720
ap.Angle:= 0;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   721
x:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   722
y:= hwFloat2Float(Me^.Y);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   723
if (Abs(trunc(x) - Targ.X) > 25)
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   724
or (Abs(trunc(y) - 50 - Targ.Y) > 50) then
6770
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   725
    begin
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   726
    if TestColl(trunc(x), trunc(y) - 16, 6)
6992
b8f3d8991e92 marked a couple of functions as inline
koda
parents: 6990
diff changeset
   727
    and (RateShove(Me, trunc(x) + LongWord(10 * hwSign(Me^.dX)), trunc(y) - 40, 30, 30, 40, hwSign(Me^.dX), -0.8,  1) = 0) then
6770
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   728
        valueResult:= Succ(BadTurn)
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   729
    else
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   730
        valueResult:= BadTurn;
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   731
    exit(valueResult);
6770
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   732
    end;
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   733
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   734
valueResult:= 0;
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   735
for i:= 0 to 4 do
6992
b8f3d8991e92 marked a couple of functions as inline
koda
parents: 6990
diff changeset
   736
    valueResult:= valueResult + RateShove(Me, trunc(x) + LongWord(10 * hwSignf(Targ.X - x)),
b8f3d8991e92 marked a couple of functions as inline
koda
parents: 6990
diff changeset
   737
                                    trunc(y) - LongWord(20 * i) - 5, 10, 30, 40, hwSign(Me^.dX), -0.8, 1);
6770
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   738
if valueResult <= 0 then
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   739
    valueResult:= BadTurn
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   740
else
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   741
    inc(valueResult);
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   742
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   743
TestWhip:= valueResult;
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   744
end;
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   745
5645
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   746
function TestHammer(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   747
var rate: LongInt;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   748
begin
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   749
Level:= Level; // avoid compiler hint
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   750
ap.ExplR:= 0;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   751
ap.Time:= 0;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   752
ap.Power:= 1;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   753
ap.Angle:= 0;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   754
         
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   755
if (Abs(hwRound(Me^.X) + hwSign(Me^.dX) * 10 - Targ.X) + Abs(hwRound(Me^.Y) - Targ.Y) > 20) then
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   756
    rate:= 0
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   757
else
5645
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   758
    rate:= RateHammer(Me);
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   759
if rate = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   760
    rate:= BadTurn;
5645
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   761
TestHammer:= rate;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   762
end;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   763
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   764
function TestAirAttack(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
556
49675457d76e Bots aims not directly at the center of enemy hedgehog
unc0rr
parents: 554
diff changeset
   765
const cShift = 4;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   766
var bombsSpeed, X, Y, dY: real;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   767
    b: array[0..9] of boolean;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   768
    dmg: array[0..9] of LongInt;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   769
    fexit: boolean;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   770
    i, t, valueResult: LongInt;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   771
begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   772
ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   773
ap.Time:= 0;
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   774
if (Level > 3) then
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   775
    exit(BadTurn);
554
4f83b3de17c7 Only bots of 1-3 level use AirAttack weapon
unc0rr
parents: 543
diff changeset
   776
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   777
ap.Angle:= 0;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   778
ap.AttackPutX:= Targ.X;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   779
ap.AttackPutY:= Targ.Y;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   780
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   781
bombsSpeed:= hwFloat2Float(cBombsSpeed);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   782
X:= Targ.X - 135 - cShift; // hh center - cShift
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   783
X:= X - bombsSpeed * sqrt(((Targ.Y + 128) * 2) / cGravityf);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   784
Y:= -128;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   785
dY:= 0;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   786
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   787
for i:= 0 to 9 do
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   788
    begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   789
    b[i]:= true;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   790
    dmg[i]:= 0
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   791
    end;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   792
valueResult:= 0;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   793
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   794
repeat
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   795
    X:= X + bombsSpeed;
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   796
    Y:= Y + dY;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   797
    dY:= dY + cGravityf;
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   798
    fexit:= true;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   799
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   800
    for i:= 0 to 9 do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   801
        if b[i] then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   802
            begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   803
            fexit:= false;
6992
b8f3d8991e92 marked a couple of functions as inline
koda
parents: 6990
diff changeset
   804
            if TestColl(trunc(X) + LongWord(i * 30), trunc(Y), 4) then
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   805
                begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   806
                b[i]:= false;
6992
b8f3d8991e92 marked a couple of functions as inline
koda
parents: 6990
diff changeset
   807
                dmg[i]:= RateExplosion(Me, trunc(X) + LongWord(i * 30), trunc(Y), 58)
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   808
                // 58 (instead of 60) for better prediction (hh moves after explosion of one of the rockets)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   809
                end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   810
            end;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   811
until fexit or (Y > cWaterLine);
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   812
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   813
for i:= 0 to 5 do inc(valueResult, dmg[i]);
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   814
t:= valueResult;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   815
ap.AttackPutX:= Targ.X - 60;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   816
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   817
for i:= 0 to 3 do
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   818
    begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   819
    dec(t, dmg[i]);
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   820
    inc(t, dmg[i + 6]);
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   821
    if t > valueResult then
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   822
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   823
        valueResult:= t;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   824
        ap.AttackPutX:= Targ.X - 30 - cShift + i * 30
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   825
        end
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   826
    end;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   827
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   828
if valueResult <= 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   829
    valueResult:= BadTurn;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   830
TestAirAttack:= valueResult;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   831
end;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   832
3370
37f4f83fedb1 Teleport AI:
mbait
parents: 3350
diff changeset
   833
37f4f83fedb1 Teleport AI:
mbait
parents: 3350
diff changeset
   834
function TestTeleport(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
37f4f83fedb1 Teleport AI:
mbait
parents: 3350
diff changeset
   835
var
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   836
    i, failNum: longword;
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   837
    maxTop: longword;
3370
37f4f83fedb1 Teleport AI:
mbait
parents: 3350
diff changeset
   838
begin
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   839
    TestTeleport := BadTurn;
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   840
    exit(BadTurn);
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   841
    Level:= Level; // avoid compiler hint
6888
32a54322d262 Get rid of TGearsType to simplify pas2c
unc0rr
parents: 6879
diff changeset
   842
    //FillBonuses(true, [gtCase]);
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   843
    if bonuses.Count = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   844
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   845
        if Me^.Health <= 100  then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   846
            begin
3697
d5b30d6373fc remove trailing spaces from end of line
koda
parents: 3677
diff changeset
   847
            maxTop := Targ.Y - cHHRadius * 2;
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   848
            
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   849
            while not TestColl(Targ.X, maxTop, cHHRadius) and (maxTop > topY + cHHRadius * 2 + 1) do
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   850
                dec(maxTop, cHHRadius*2);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   851
            if not TestColl(Targ.X, maxTop + cHHRadius, cHHRadius) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   852
                begin
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   853
                ap.AttackPutX := Targ.X;
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   854
                ap.AttackPutY := maxTop + cHHRadius;
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   855
                TestTeleport := Targ.Y - maxTop;
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   856
                end;
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   857
            end;
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   858
        end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   859
    else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   860
        begin
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   861
        failNum := 0;
3697
d5b30d6373fc remove trailing spaces from end of line
koda
parents: 3677
diff changeset
   862
        repeat
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   863
            i := random(bonuses.Count);
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   864
            inc(failNum);
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   865
        until not TestColl(bonuses.ar[i].X, bonuses.ar[i].Y - cHHRadius - bonuses.ar[i].Radius, cHHRadius)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   866
        or (failNum = bonuses.Count*2);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   867
        
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   868
        if failNum < bonuses.Count*2 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   869
            begin
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   870
            ap.AttackPutX := bonuses.ar[i].X;
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   871
            ap.AttackPutY := bonuses.ar[i].Y - cHHRadius - bonuses.ar[i].Radius;
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   872
            TestTeleport := 0;
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   873
            end;
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   874
        end;
3370
37f4f83fedb1 Teleport AI:
mbait
parents: 3350
diff changeset
   875
end;
37f4f83fedb1 Teleport AI:
mbait
parents: 3350
diff changeset
   876
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   877
end.