hedgewars/uAIAmmoTests.pas
author nemo
Sun, 24 Jun 2012 20:30:51 -0400
changeset 7283 322ff9418461
parent 7274 a07777b818f1
child 7348 2a69f2ed9273
permissions -rw-r--r--
oops
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;
7178
c61cfc9eb29d Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position
unc0rr
parents: 7161
diff changeset
    24
const 
c61cfc9eb29d Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position
unc0rr
parents: 7161
diff changeset
    25
    amtest_OnTurn   = $00000001; // from one position
c61cfc9eb29d Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position
unc0rr
parents: 7161
diff changeset
    26
    amtest_NoTarget = $00000002; // each pos, but no targetting
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
    27
7078
a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition
nemo
parents: 7041
diff changeset
    28
var windSpeed: real;
a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition
nemo
parents: 7041
diff changeset
    29
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
    30
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
    31
        Time: Longword;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    32
        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
    33
        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
    34
        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
    35
        end;
433
9f8f22094c0e AI thinks in separate thread
unc0rr
parents: 409
diff changeset
    36
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
    37
function TestBazooka(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
4580
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
    38
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
    39
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
    40
function TestMolotov(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
2978
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
    41
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
    42
function TestWatermelon(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
    43
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
    44
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
    45
function TestDesertEagle(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
7197
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
    46
function TestSniperRifle(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 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
    48
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
    49
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
    50
function TestAirAttack(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
3370
37f4f83fedb1 Teleport AI:
mbait
parents: 3350
diff changeset
    51
function TestTeleport(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
5645
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
    52
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
    53
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
    54
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
    55
    TAmmoTest = record
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    56
            proc: TAmmoTestProc;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    57
            flags: Longword;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    58
            end;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
    59
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
    60
const AmmoTests: array[TAmmoType] of TAmmoTest =
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    61
            (
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    62
            (proc: nil;              flags: 0), // amNothing
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    63
            (proc: @TestGrenade;     flags: 0), // amGrenade
2978
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
    64
            (proc: @TestClusterBomb; flags: 0), // amClusterBomb
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    65
            (proc: @TestBazooka;     flags: 0), // amBazooka
3080
b7fa8ad60e3b Engine:
smxx
parents: 3066
diff changeset
    66
            (proc: nil;              flags: 0), // amBee
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    67
            (proc: @TestShotgun;     flags: 0), // amShotgun
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    68
            (proc: nil;              flags: 0), // amPickHammer
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    69
            (proc: nil;              flags: 0), // amSkip
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    70
            (proc: nil;              flags: 0), // amRope
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    71
            (proc: nil;              flags: 0), // amMine
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    72
            (proc: @TestDesertEagle; flags: 0), // amDEagle
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    73
            (proc: nil;              flags: 0), // amDynamite
7178
c61cfc9eb29d Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position
unc0rr
parents: 7161
diff changeset
    74
            (proc: @TestFirePunch;   flags: amtest_NoTarget), // amFirePunch
c61cfc9eb29d Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position
unc0rr
parents: 7161
diff changeset
    75
            (proc: @TestWhip;        flags: amtest_NoTarget), // amWhip
c61cfc9eb29d Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position
unc0rr
parents: 7161
diff changeset
    76
            (proc: @TestBaseballBat; flags: amtest_NoTarget), // amBaseballBat
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    77
            (proc: nil;              flags: 0), // amParachute
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    78
            (proc: @TestAirAttack;   flags: amtest_OnTurn), // amAirAttack
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    79
            (proc: nil;              flags: 0), // amMineStrike
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    80
            (proc: nil;              flags: 0), // amBlowTorch
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    81
            (proc: nil;              flags: 0), // amGirder
3739
97cf933e5bd2 disable AI teleport
koda
parents: 3717
diff changeset
    82
            (proc: nil;              flags: 0), // amTeleport
97cf933e5bd2 disable AI teleport
koda
parents: 3717
diff changeset
    83
            //(proc: @TestTeleport;    flags: amtest_OnTurn), // amTeleport
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    84
            (proc: nil;              flags: 0), // amSwitch
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    85
            (proc: @TestMortar;      flags: 0), // amMortar
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    86
            (proc: nil;              flags: 0), // amKamikaze
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    87
            (proc: nil;              flags: 0), // amCake
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    88
            (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
    89
            (proc: @TestWatermelon;  flags: 0), // amWatermelon
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    90
            (proc: nil;              flags: 0), // amHellishBomb
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    91
            (proc: nil;              flags: 0), // amNapalm
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    92
            (proc: nil;              flags: 0), // amDrill
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    93
            (proc: nil;              flags: 0), // amBallgun
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    94
            (proc: nil;              flags: 0), // amRCPlane
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    95
            (proc: nil;              flags: 0), // amLowGravity
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    96
            (proc: nil;              flags: 0), // amExtraDamage
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    97
            (proc: nil;              flags: 0), // amInvulnerable
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    98
            (proc: nil;              flags: 0), // amExtraTime
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
    99
            (proc: nil;              flags: 0), // amLaserSight
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   100
            (proc: nil;              flags: 0), // amVampiric
7197
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   101
            (proc: @TestSniperRifle; 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
   102
            (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
   103
            (proc: @TestMolotov;     flags: 0), // amMolotov
3350
5cd02aafc612 Engine:
smxx
parents: 3342
diff changeset
   104
            (proc: nil;              flags: 0), // amBirdy
5cd02aafc612 Engine:
smxx
parents: 3342
diff changeset
   105
            (proc: nil;              flags: 0), // amPortalGun
3382
633046fa040c Gas grenade:
mbait
parents: 3372
diff changeset
   106
            (proc: nil;              flags: 0), // amPiano
3384
7eb4707d43f0 * added some comments
sheepluva
parents: 3382
diff changeset
   107
            (proc: @TestGrenade;     flags: 0), // amGasBomb
3476
1ec68b8d3bd1 Henek adds a flamethrower, updates some translations, and tweaks how fire works.
nemo
parents: 3439
diff changeset
   108
            (proc: @TestShotgun;     flags: 0), // amSineGun
3710
411f5c2b5292 Engine:
smaxx
parents: 3697
diff changeset
   109
            (proc: nil;              flags: 0), // amFlamethrower
3717
d88719b0f0dc Engine:
smaxx
parents: 3710
diff changeset
   110
            (proc: @TestGrenade;     flags: 0), // amSMine
7178
c61cfc9eb29d Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position
unc0rr
parents: 7161
diff changeset
   111
            (proc: @TestHammer;      flags: amtest_NoTarget), // amHammer
4246
e5cb885492df drillstrike! might require the drill patch to improve behavior
koda
parents: 4226
diff changeset
   112
            (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
   113
            (proc: nil;              flags: 0), // amDrillStrike
7078
a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition
nemo
parents: 7041
diff changeset
   114
            (proc: nil;              flags: 0), // amSnowball
4883
7cddc9201a1d added dummy for tardis and ugly icons for tardis and structure
Henek
parents: 4881
diff changeset
   115
            (proc: nil;              flags: 0), // amTardis
5024
1e332947147c Landgun, first pass. At sdw's request.
nemo
parents: 4976
diff changeset
   116
            (proc: nil;              flags: 0), // amStructure
7007
0ccdff4ae8e9 Initial stub for freezer
nemo
parents: 6992
diff changeset
   117
            (proc: nil;              flags: 0), // amLandGun
0ccdff4ae8e9 Initial stub for freezer
nemo
parents: 6992
diff changeset
   118
            (proc: nil;              flags: 0)  // amIceGun
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   119
            );
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   120
439
c336ed82e76d Fix bugs:
unc0rr
parents: 438
diff changeset
   121
const BadTurn = Low(LongInt) div 4;
369
2aed85310727 AI compiles, but doesn't work
unc0rr
parents: 351
diff changeset
   122
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   123
implementation
4374
bcefeeabaa33 Move some stuff from uMisc to uUtils
unC0Rr
parents: 4367
diff changeset
   124
uses uAIMisc, uVariables, uUtils;
370
c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents: 369
diff changeset
   125
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
   126
function Metric(x1, y1, x2, y2: LongInt): LongInt; inline;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   127
begin
370
c75410fe3133 - Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents: 369
diff changeset
   128
Metric:= abs(x1 - x2) + abs(y1 - y2)
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   129
end;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   130
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   131
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
   132
var Vx, Vy, r, mX, mY: real;
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 439
diff changeset
   133
    rTime: LongInt;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   134
    EX, EY: LongInt;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   135
    valueResult: LongInt;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   136
    x, y, dX, dY: real;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   137
    t: LongInt;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   138
    value: LongInt;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   139
begin
5151
cbadb9fa52fc An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster.
nemo
parents: 5150
diff changeset
   140
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
   141
mY:= hwFloat2Float(Me^.Y);
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   142
ap.Time:= 0;
375
18012da67681 AI works properly
unc0rr
parents: 374
diff changeset
   143
rTime:= 350;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   144
ap.ExplR:= 0;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   145
valueResult:= BadTurn;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   146
repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   147
    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
   148
    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
   149
    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
   150
    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
   151
    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
   152
        begin
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   153
        x:= mX;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   154
        y:= mY;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   155
        dX:= Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   156
        dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   157
        t:= rTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   158
        repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   159
            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
   160
            y:= y + dY;
7078
a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition
nemo
parents: 7041
diff changeset
   161
            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
   162
            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
   163
            dec(t)
7274
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate.
nemo
parents: 7212
diff changeset
   164
        until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or 
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate.
nemo
parents: 7212
diff changeset
   165
               ((Me <> CurrentHedgehog^.Gear) and 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
   166
        
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   167
        EX:= trunc(x);
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   168
        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
   169
        if Me^.Hedgehog^.BotLevel = 1 then
7161
21a9c70b2070 Name the flags for fall tracking and indicating whether the explosion erases terrain.
nemo
parents: 7154
diff changeset
   170
            value:= RateExplosion(Me, EX, EY, 101, afTrackFall or afErasesLand)
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
   171
        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
   172
        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
   173
            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
   174
        if valueResult <= value then
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   175
            begin
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   176
            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
   177
            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
   178
            ap.ExplR:= 100;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   179
            ap.ExplX:= EX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   180
            ap.ExplY:= EY;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   181
            valueResult:= value
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   182
            end;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   183
        end
6772
13d13aefa4de small tweak. make drowning prefer higher health hogs
nemo
parents: 6771
diff changeset
   184
//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
   185
until rTime > 4250;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   186
TestBazooka:= valueResult
39
b78e7185ed13 - Increased FPS
unc0rr
parents: 37
diff changeset
   187
end;
374
95169697cc38 - UFO smokes
unc0rr
parents: 371
diff changeset
   188
4580
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   189
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
   190
var Vx, Vy, r: real;
4580
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   191
    rTime: LongInt;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   192
    EX, EY: LongInt;
4580
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   193
    valueResult: LongInt;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   194
    x, y, dX, dY, meX, meY: real;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   195
    t: LongInt;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   196
    value: LongInt;
4580
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   197
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   198
begin
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   199
meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   200
meY:= hwFloat2Float(Me^.Y);
4580
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   201
ap.Time:= 0;
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   202
rTime:= 350;
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   203
ap.ExplR:= 0;
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   204
valueResult:= BadTurn;
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   205
repeat
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   206
    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
   207
    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
   208
    Vy:= cGravityf * rTime * 0.5 - (Targ.Y - meY) / rTime;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   209
    r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   210
    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
   211
        begin
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   212
        x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   213
        y:= meY;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   214
        dX:= Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   215
        dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   216
        t:= rTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   217
        repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   218
            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
   219
            y:= y + dY;
7078
a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition
nemo
parents: 7041
diff changeset
   220
            dX:= dX + windSpeed;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   221
            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
   222
            dec(t)
7274
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate.
nemo
parents: 7212
diff changeset
   223
        until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or 
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate.
nemo
parents: 7212
diff changeset
   224
               ((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me, trunc(x), trunc(y), 5))) or (t <= 0);
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   225
        EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   226
        EY:= trunc(y);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   227
7161
21a9c70b2070 Name the flags for fall tracking and indicating whether the explosion erases terrain.
nemo
parents: 7154
diff changeset
   228
        value:= RateShove(Me, trunc(x), trunc(y), 5, 1, trunc((abs(dX)+abs(dY))*20), -dX, -dY, afTrackFall);
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   229
        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
   230
            value:= - Metric(Targ.X, Targ.Y, EX, EY) div 64;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   231
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   232
        if valueResult <= value then
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   233
            begin
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   234
            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
   235
            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
   236
            ap.ExplR:= 0;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   237
            ap.ExplX:= EX;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   238
            ap.ExplY:= EY;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   239
            valueResult:= value
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   240
            end;
4580
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   241
     end
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   242
until (rTime > 4250);
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   243
TestSnowball:= valueResult
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   244
end;
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   245
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
   246
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
   247
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
   248
    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
   249
    TestTime: Longword;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   250
    x, y, dY, meX, meY: real;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   251
    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
   252
begin
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   253
meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   254
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
   255
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
   256
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
   257
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
   258
repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   259
    inc(TestTime, 300);
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   260
    Vx:= (Targ.X - meX) / TestTime;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   261
    Vy:= cGravityf * (TestTime div 2) - Targ.Y - meY / TestTime;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   262
    r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   263
    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
   264
        begin
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   265
        x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   266
        y:= meY;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   267
        dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   268
        t:= TestTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   269
        repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   270
            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
   271
            y:= y + dY;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   272
            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
   273
            dec(t)
7274
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate.
nemo
parents: 7212
diff changeset
   274
        until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 6)) or 
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate.
nemo
parents: 7212
diff changeset
   275
               ((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me, trunc(x), trunc(y), 6))) or (t = 0);
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   276
        EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   277
        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
   278
        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
   279
            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
   280
        else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   281
            Score:= BadTurn;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   282
                  
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   283
        if valueResult < Score then
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   284
            begin
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   285
            ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   286
            ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   287
            ap.Time:= TestTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   288
            ap.ExplR:= 100;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   289
            ap.ExplX:= EX;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   290
            ap.ExplY:= EY;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   291
            valueResult:= Score
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   292
            end;
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   293
        end
3022
94afd5fc5738 Adjust increment since there is no timer
nemo
parents: 3018
diff changeset
   294
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
   295
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
   296
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
   297
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   298
function TestGrenade(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
70
82d93eeecebe - Many AI improvements
unc0rr
parents: 66
diff changeset
   299
const tDelta = 24;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   300
var Vx, Vy, r: real;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   301
    Score, EX, EY, valueResult: LongInt;
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   302
    TestTime: Longword;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   303
    x, y, meX, meY, dY: real;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   304
    t: LongInt;
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   305
begin
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   306
valueResult:= BadTurn;
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   307
TestTime:= 0;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   308
ap.ExplR:= 0;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   309
meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   310
meY:= hwFloat2Float(Me^.Y);
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   311
repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   312
    inc(TestTime, 1000);
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   313
    Vx:= (Targ.X - meX) / (TestTime + tDelta);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   314
    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
   315
    r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   316
    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
   317
        begin
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   318
        x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   319
        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
   320
        dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   321
        t:= TestTime;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   322
        repeat
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   323
            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
   324
            y:= y + dY;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   325
            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
   326
            dec(t)
7274
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate.
nemo
parents: 7212
diff changeset
   327
        until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or 
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate.
nemo
parents: 7212
diff changeset
   328
               ((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me, trunc(x), trunc(y), 5))) or (t = 0);
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   329
    EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   330
    EY:= trunc(y);
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   331
    if t < 50 then 
6769
44ad49a3a126 Add drowning to grenade too, try some little optimisations
nemo
parents: 6767
diff changeset
   332
        if Me^.Hedgehog^.BotLevel = 1 then
7161
21a9c70b2070 Name the flags for fall tracking and indicating whether the explosion erases terrain.
nemo
parents: 7154
diff changeset
   333
            Score:= RateExplosion(Me, EX, EY, 101, afTrackFall or afErasesLand)
6769
44ad49a3a126 Add drowning to grenade too, try some little optimisations
nemo
parents: 6767
diff changeset
   334
        else Score:= RateExplosion(Me, EX, EY, 101)
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   335
    else 
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   336
        Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   337
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   338
    if valueResult < Score then
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   339
        begin
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   340
        ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   341
        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
   342
        ap.Time:= TestTime;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   343
        ap.ExplR:= 100;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   344
        ap.ExplX:= EX;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   345
        ap.ExplY:= EY;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   346
        valueResult:= Score
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   347
        end;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   348
    end
6772
13d13aefa4de small tweak. make drowning prefer higher health hogs
nemo
parents: 6771
diff changeset
   349
//until (Score > 204800) or (TestTime > 4000);
13d13aefa4de small tweak. make drowning prefer higher health hogs
nemo
parents: 6771
diff changeset
   350
until TestTime > 4000;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   351
TestGrenade:= valueResult
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   352
end;
375
18012da67681 AI works properly
unc0rr
parents: 374
diff changeset
   353
2978
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   354
function TestClusterBomb(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   355
const tDelta = 24;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   356
var Vx, Vy, r: real;
2978
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   357
    Score, EX, EY, valueResult: LongInt;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   358
    TestTime: Longword;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   359
    x, y, dY, meX, meY: real;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   360
    t: LongInt;
2978
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   361
begin
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   362
valueResult:= BadTurn;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   363
TestTime:= 0;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   364
ap.ExplR:= 0;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   365
meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   366
meY:= hwFloat2Float(Me^.Y);
2978
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   367
repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   368
    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
   369
    // 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
   370
    if meX<Targ.X then
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   371
        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
   372
    else
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   373
        Vx:= ((Targ.X-10) - meX) / (TestTime + tDelta);
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   374
    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
   375
    r:= sqr(Vx)+sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   376
    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
   377
        begin
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   378
        x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   379
        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
   380
        dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   381
        t:= TestTime;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   382
    repeat
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   383
        x:= x + Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   384
        y:= y + dY;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   385
        dY:= dY + cGravityf;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   386
        dec(t)
7274
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate.
nemo
parents: 7212
diff changeset
   387
    until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or 
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate.
nemo
parents: 7212
diff changeset
   388
           ((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me, trunc(x), trunc(y), 5))) or (t = 0);
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   389
    EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   390
    EY:= trunc(y);
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   391
    if t < 50 then 
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   392
        Score:= RateExplosion(Me, EX, EY, 41)
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   393
    else 
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   394
        Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   395
2978
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   396
     if valueResult < Score then
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   397
        begin
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   398
        ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   399
        ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
2978
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   400
        ap.Time:= TestTime;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   401
        ap.ExplR:= 90;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   402
        ap.ExplX:= EX;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   403
        ap.ExplY:= EY;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   404
        valueResult:= Score
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   405
        end;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   406
     end
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   407
until (TestTime = 4000);
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   408
TestClusterBomb:= valueResult
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   409
end;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   410
2973
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   411
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
   412
const tDelta = 24;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   413
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
   414
    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
   415
    TestTime: Longword;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   416
    x, y, dY, meX, meY: real;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   417
    t: LongInt;
2973
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   418
begin
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   419
valueResult:= BadTurn;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   420
TestTime:= 0;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   421
ap.ExplR:= 0;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   422
meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   423
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
   424
repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   425
    inc(TestTime, 1000);
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   426
    Vx:= (Targ.X - meX) / (TestTime + tDelta);
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   427
    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
   428
    r:= sqr(Vx)+sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   429
    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
   430
        begin
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   431
        x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   432
        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
   433
        dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   434
        t:= TestTime;
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   435
        repeat
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   436
            x:= x + Vx;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   437
            y:= y + dY;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   438
            dY:= dY + cGravityf;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   439
            dec(t)
7274
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate.
nemo
parents: 7212
diff changeset
   440
       until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 6)) or 
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate.
nemo
parents: 7212
diff changeset
   441
               ((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me, trunc(x), trunc(y), 6))) or (t = 0);
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   442
        
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   443
        EX:= trunc(x);
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   444
        EY:= trunc(y);
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   445
        if t < 50 then 
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   446
            Score:= RateExplosion(Me, EX, EY, 200) + RateExplosion(Me, EX, EY + 120, 200)
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   447
        else 
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   448
            Score:= BadTurn;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   449
            
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   450
        if valueResult < Score then
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   451
            begin
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   452
            ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   453
            ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   454
            ap.Time:= TestTime;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   455
            ap.ExplR:= 300;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   456
            ap.ExplX:= EX;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   457
            ap.ExplY:= EY;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   458
            valueResult:= Score
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   459
            end;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   460
        end
2973
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   461
until (TestTime = 4000);
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   462
TestWatermelon:= valueResult
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   463
end;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   464
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   465
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   466
    function Solve(TX, TY, MX, MY: LongInt): LongWord;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   467
    var A, B, D, T: real;
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   468
        C: LongInt;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   469
    begin
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   470
        A:= sqr(cGravityf);
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   471
        B:= - cGravityf * (TY - MY) - 1;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   472
        C:= sqr(TY - MY) + sqr(TX - MX);
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   473
        D:= sqr(B) - A * C;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   474
        if D >= 0 then
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   475
            begin
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   476
            D:= sqrt(D) - B;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   477
            if D >= 0 then
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   478
                T:= sqrt(D * 2 / A)
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   479
            else
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   480
                T:= 0;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   481
            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
   482
            end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   483
            else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   484
                Solve:= 0
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   485
    end;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   486
    
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   487
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
   488
//const tDelta = 24;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   489
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
   490
    Score, EX, EY: LongInt;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   491
    TestTime: Longword;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   492
    x, y, dY, meX, meY: real;
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   493
begin
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   494
    TestMortar:= BadTurn;
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   495
    ap.ExplR:= 0;
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   496
    meX:= hwFloat2Float(Me^.X);
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   497
    meY:= hwFloat2Float(Me^.Y);
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   498
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   499
    if (Level > 2) then
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   500
        exit(BadTurn);
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   501
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   502
    TestTime:= Solve(Targ.X, Targ.Y, trunc(meX), trunc(meY));
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   503
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   504
    if TestTime = 0 then
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   505
        exit(BadTurn);
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   506
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   507
    Vx:= (Targ.X - meX) / TestTime;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   508
    Vy:= cGravityf * (TestTime div 2) - (Targ.Y - meY) / TestTime;
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   509
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   510
    x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   511
    y:= meY;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   512
    dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   513
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   514
    repeat
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   515
        x:= x + Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   516
        y:= y + dY;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   517
        dY:= dY + cGravityf;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   518
        EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   519
        EY:= trunc(y);
7274
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate.
nemo
parents: 7212
diff changeset
   520
    until (((Me = CurrentHedgehog^.Gear) and TestColl(EX, EY, 4)) or 
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate.
nemo
parents: 7212
diff changeset
   521
           ((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me, EX, EY, 4))) or (EY > cWaterLine);
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   522
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   523
    if (EY < cWaterLine) and (dY >= 0) then
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   524
        begin
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   525
        Score:= RateExplosion(Me, EX, EY, 91);
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   526
        if (Score = 0) then
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   527
            if (dY > 0.15) then
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   528
                Score:= - abs(Targ.Y - EY) div 32
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   529
            else
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   530
                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
   531
        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
   532
            Score:= BadTurn
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   533
        end
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   534
    else
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   535
        Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   536
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
   537
    if BadTurn < Score then
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   538
        begin
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   539
        ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   540
        ap.Power:= 1;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   541
        ap.ExplR:= 100;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   542
        ap.ExplX:= EX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   543
        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
   544
        TestMortar:= Score
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   545
        end;
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   546
end;
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   547
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   548
function TestShotgun(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
1941
b1ef1f86148c Some AI tweaks by imcold
unc0rr
parents: 1854
diff changeset
   549
const
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   550
    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
   551
    MAX_RANGE = 400;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   552
var Vx, Vy, x, y: real;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   553
    rx, ry, valueResult: LongInt;
1941
b1ef1f86148c Some AI tweaks by imcold
unc0rr
parents: 1854
diff changeset
   554
    range: integer;
375
18012da67681 AI works properly
unc0rr
parents: 374
diff changeset
   555
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
   556
TestShotgun:= BadTurn;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   557
ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   558
ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   559
ap.Power:= 1;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   560
x:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   561
y:= hwFloat2Float(Me^.Y);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   562
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
   563
if ( range < MIN_RANGE ) or ( range > MAX_RANGE ) then
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   564
    exit(BadTurn);
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   565
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   566
Vx:= (Targ.X - x) * 1 / 1024;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   567
Vy:= (Targ.Y - y) * 1 / 1024;
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   568
ap.Angle:= DxDy2AttackAnglef(Vx, -Vy);
70
82d93eeecebe - Many AI improvements
unc0rr
parents: 66
diff changeset
   569
repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   570
    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
   571
    y:= y + vY;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   572
    rx:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   573
    ry:= trunc(y);
7274
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate.
nemo
parents: 7212
diff changeset
   574
    if ((Me = CurrentHedgehog^.Gear) and TestColl(rx, ry, 2)) or 
a07777b818f1 Try to use TestCollExcludingMe a bit less - the flag bit is a bit (heh) more accurate.
nemo
parents: 7212
diff changeset
   575
        ((Me <> CurrentHedgehog^.Gear) and 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
   576
    begin
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   577
        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
   578
        y:= y + vY * 8;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   579
        valueResult:= RateShotgun(Me, vX, vY, rx, ry);
5642
0ce9e01bae56 Make AI aware of damage modifiers
unc0rr
parents: 5164
diff changeset
   580
     
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
   581
        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
   582
            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
   583
        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
   584
            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
   585
        // 27/20 is reuse bonus
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   586
        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
   587
    end
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   588
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
   589
    or (x < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   590
    or (y < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   591
    or (trunc(x) > LAND_WIDTH)
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   592
    or (trunc(y) > LAND_HEIGHT);
4157
f8898d6cca6e Fix some warnings
unc0rr
parents: 3963
diff changeset
   593
375
18012da67681 AI works properly
unc0rr
parents: 374
diff changeset
   594
TestShotgun:= BadTurn
70
82d93eeecebe - Many AI improvements
unc0rr
parents: 66
diff changeset
   595
end;
438
04bcc3fb127a Fix AI using shotgun and Desert Eagle
unc0rr
parents: 434
diff changeset
   596
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   597
function TestDesertEagle(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
6783
8d9160b85bdb Add fall damage
nemo
parents: 6782
diff changeset
   598
var Vx, Vy, x, y, t, dmgMod: real;
75
d2b737858ff7 - New First Aid powerup
unc0rr
parents: 74
diff changeset
   599
    d: Longword;
6783
8d9160b85bdb Add fall damage
nemo
parents: 6782
diff changeset
   600
    fallDmg, valueResult: LongInt;
75
d2b737858ff7 - New First Aid powerup
unc0rr
parents: 74
diff changeset
   601
begin
6783
8d9160b85bdb Add fall damage
nemo
parents: 6782
diff changeset
   602
dmgMod:= 0.01 * hwFloat2Float(cDamageModifier) * cDamagePercent;
3407
dcc129c4352e Engine:
smxx
parents: 3384
diff changeset
   603
Level:= Level; // avoid compiler hint
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   604
ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   605
ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   606
ap.Power:= 1;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   607
x:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   608
y:= hwFloat2Float(Me^.Y);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   609
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
   610
    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
   611
    TestDesertEagle:= BadTurn;
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   612
    exit(BadTurn);
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   613
    end;
7197
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   614
t:= 2 / sqrt(sqr(Targ.X - x)+sqr(Targ.Y-y));
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   615
Vx:= (Targ.X - x) * t;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   616
Vy:= (Targ.Y - y) * t;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   617
ap.Angle:= DxDy2AttackAnglef(Vx, -Vy);
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   618
d:= 0;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   619
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   620
repeat
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   621
    x:= x + vX;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   622
    y:= y + vY;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   623
    if ((trunc(x) and LAND_WIDTH_MASK) = 0)and((trunc(y) and LAND_HEIGHT_MASK) = 0)
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   624
    and (Land[trunc(y), trunc(x)] <> 0) then
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   625
        inc(d);
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   626
until (Abs(Targ.X - trunc(x)) + Abs(Targ.Y - trunc(y)) < 5)
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   627
    or (x < 0)
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   628
    or (y < 0)
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   629
    or (trunc(x) > LAND_WIDTH)
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   630
    or (trunc(y) > LAND_HEIGHT)
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   631
    or (d > 50);
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   632
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   633
if Abs(Targ.X - trunc(x)) + Abs(Targ.Y - trunc(y)) < 5 then
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   634
    begin
7208
62e36dc45098 Ignore all objects for fall tracing with shove to avoid considering checkins as obstacles. many objects will get knocked by the kick anyway, so end result should be pretty good. Oh, and ditch the sniper rifle doubling.
nemo
parents: 7206
diff changeset
   635
    fallDmg:= TraceShoveFall(Targ.X, Targ.Y, vX * 0.00125 * 20, vY * 0.00125 * 20);
7197
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   636
    if fallDmg < 0 then
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   637
        valueResult:= 204800
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   638
    else valueResult:= Max(0, (4 - d div 50) * trunc((7+fallDmg)*dmgMod) * 1024)
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   639
    end
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   640
else
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   641
    valueResult:= BadTurn;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   642
TestDesertEagle:= valueResult
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   643
end;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   644
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   645
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   646
function TestSniperRifle(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   647
var Vx, Vy, x, y, t, dmg, dmgMod: real;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   648
    d: Longword;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   649
    fallDmg, valueResult: LongInt;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   650
begin
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   651
dmgMod:= 0.01 * hwFloat2Float(cDamageModifier) * cDamagePercent;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   652
Level:= Level; // avoid compiler hint
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   653
ap.ExplR:= 0;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   654
ap.Time:= 0;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   655
ap.Power:= 1;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   656
x:= hwFloat2Float(Me^.X);
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   657
y:= hwFloat2Float(Me^.Y);
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   658
if Abs(trunc(x) - Targ.X) + Abs(trunc(y) - Targ.Y) < 40 then
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   659
    exit(BadTurn);
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   660
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   661
dmg:= sqrt(sqr(Targ.X - x)+sqr(Targ.Y-y));
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   662
t:= 1.5 / dmg;
7208
62e36dc45098 Ignore all objects for fall tracing with shove to avoid considering checkins as obstacles. many objects will get knocked by the kick anyway, so end result should be pretty good. Oh, and ditch the sniper rifle doubling.
nemo
parents: 7206
diff changeset
   663
dmg:= dmg * 0.025; // div 40
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   664
Vx:= (Targ.X - x) * t;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   665
Vy:= (Targ.Y - y) * t;
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   666
ap.Angle:= DxDy2AttackAnglef(Vx, -Vy);
75
d2b737858ff7 - New First Aid powerup
unc0rr
parents: 74
diff changeset
   667
d:= 0;
1941
b1ef1f86148c Some AI tweaks by imcold
unc0rr
parents: 1854
diff changeset
   668
75
d2b737858ff7 - New First Aid powerup
unc0rr
parents: 74
diff changeset
   669
repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   670
    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
   671
    y:= y + vY;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   672
    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
   673
    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
   674
        inc(d);
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   675
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
   676
    or (x < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   677
    or (y < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   678
    or (trunc(x) > LAND_WIDTH)
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   679
    or (trunc(y) > LAND_HEIGHT)
7197
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   680
    or (d > 23);
1941
b1ef1f86148c Some AI tweaks by imcold
unc0rr
parents: 1854
diff changeset
   681
7197
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   682
if Abs(Targ.X - trunc(x)) + Abs(Targ.Y - trunc(y)) < 4 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
   683
    begin
7208
62e36dc45098 Ignore all objects for fall tracing with shove to avoid considering checkins as obstacles. many objects will get knocked by the kick anyway, so end result should be pretty good. Oh, and ditch the sniper rifle doubling.
nemo
parents: 7206
diff changeset
   684
    fallDmg:= TraceShoveFall(Targ.X, Targ.Y, vX * 0.00166 * dmg, vY * 0.00166 * dmg);
6783
8d9160b85bdb Add fall damage
nemo
parents: 6782
diff changeset
   685
    if fallDmg < 0 then
7197
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   686
        TestSniperRifle:= BadTurn
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   687
    else 
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   688
        TestSniperRifle:= Max(0, trunc((dmg + 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
   689
    end
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   690
else
7197
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   691
    TestSniperRifle:= BadTurn
75
d2b737858ff7 - New First Aid powerup
unc0rr
parents: 74
diff changeset
   692
end;
438
04bcc3fb127a Fix AI using shotgun and Desert Eagle
unc0rr
parents: 434
diff changeset
   693
7197
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   694
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   695
function TestBaseballBat(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
7212
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   696
var valueResult, a, v1, v2: LongInt;
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   697
    x, y: LongInt;
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   698
    dx, dy: real;
79
29b477319854 - New test map
unc0rr
parents: 78
diff changeset
   699
begin
7212
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   700
    Level:= Level; // avoid compiler hint
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   701
    ap.ExplR:= 0;
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   702
    ap.Time:= 0;
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   703
    ap.Power:= 1;
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   704
    x:= hwRound(Me^.X);
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   705
    y:= hwRound(Me^.Y);
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   706
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   707
    a:= 0;
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   708
    valueResult:= 0;
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   709
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   710
    while a <= cMaxAngle div 2 do
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   711
        begin
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   712
        dx:= sin(a / cMaxAngle * pi) * 0.5;
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   713
        dy:= cos(a / cMaxAngle * pi) * 0.5;
433
9f8f22094c0e AI thinks in separate thread
unc0rr
parents: 409
diff changeset
   714
7212
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   715
        v1:= RateShove(Me, x - 10, y
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   716
                , 33, 30, 115
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   717
                , -dx, -dy, afTrackFall);
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   718
        v2:= RateShove(Me, x + 10, y
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   719
                , 33, 30, 115
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   720
                , dx, -dy, afTrackFall);
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   721
        if (v1 > valueResult) or (v2 > valueResult) then
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   722
            if (v2 > v1) 
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   723
                or {don't encourage turning for no gain}((v2 = v1) and (not Me^.dX.isNegative)) then
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   724
                begin
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   725
                ap.Angle:= a;
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   726
                valueResult:= v2
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   727
                end
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   728
            else 
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   729
                begin
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   730
                ap.Angle:= -a;
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   731
                valueResult:= v1
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   732
                end;
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
   733
7212
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   734
        a:= a + 15 + random(cMaxAngle div 16)
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   735
        end;
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   736
   
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   737
    if valueResult <= 0 then
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   738
        valueResult:= BadTurn;
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   739
ab60dbe8fd0c TestBaseballBat
unc0rr
parents: 7210
diff changeset
   740
    TestBaseballBat:= valueResult;
79
29b477319854 - New test map
unc0rr
parents: 78
diff changeset
   741
end;
29b477319854 - New test map
unc0rr
parents: 78
diff changeset
   742
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   743
function TestFirePunch(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
7200
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   744
var valueResult, v1, v2, i: LongInt;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   745
    x, y: LongInt;
82
2f4f3236cccc - New fort
unc0rr
parents: 80
diff changeset
   746
begin
7200
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   747
    Level:= Level; // avoid compiler hint
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   748
    ap.ExplR:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   749
    ap.Time:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   750
    ap.Power:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   751
    x:= hwRound(Me^.X);
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   752
    y:= hwRound(Me^.Y);
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   753
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   754
    v1:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   755
    for i:= 0 to 8 do
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   756
        begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   757
        v1:= v1 + RateShove(Me, x - 10, y - 10 * i
7210
2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly
unc0rr
parents: 7208
diff changeset
   758
                , 18, 30, 40
7200
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   759
                , -0.45, -0.9, afTrackFall or afSetSkip);
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   760
        end;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   761
    v1:= v1 + RateShove(Me, x - 10, y - 90
7210
2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly
unc0rr
parents: 7208
diff changeset
   762
            , 18, 30, 40
7200
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   763
            , -0.45, -0.9, afTrackFall);
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   764
433
9f8f22094c0e AI thinks in separate thread
unc0rr
parents: 409
diff changeset
   765
7200
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   766
    // now try opposite direction
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   767
    v2:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   768
    for i:= 0 to 8 do
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   769
        begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   770
        v2:= v2 + RateShove(Me, x + 10, y - 10 * i
7210
2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly
unc0rr
parents: 7208
diff changeset
   771
                , 18, 30, 40
7200
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   772
                , 0.45, -0.9, afTrackFall or afSetSkip);
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   773
        end;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   774
    v2:= v2 + RateShove(Me, x + 10, y - 90
7210
2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly
unc0rr
parents: 7208
diff changeset
   775
            , 18, 30, 40
7200
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   776
            , 0.45, -0.9, afTrackFall);
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   777
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   778
    if (v2 > v1) 
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   779
        or {don't encourage turning for no gain}((v2 = v1) and (not Me^.dX.isNegative)) then
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   780
        begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   781
        ap.Angle:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   782
        valueResult:= v2
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   783
        end
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   784
    else 
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   785
        begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   786
        ap.Angle:= -1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   787
        valueResult:= v1
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   788
        end;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   789
    
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   790
    if valueResult <= 0 then
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   791
        valueResult:= BadTurn;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   792
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   793
    TestFirePunch:= valueResult;
82
2f4f3236cccc - New fort
unc0rr
parents: 80
diff changeset
   794
end;
433
9f8f22094c0e AI thinks in separate thread
unc0rr
parents: 409
diff changeset
   795
7178
c61cfc9eb29d Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position
unc0rr
parents: 7161
diff changeset
   796
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
   797
function TestWhip(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
7154
56e329edf4b8 Improve TestWhip
unc0rr
parents: 7134
diff changeset
   798
var valueResult, v1, v2: LongInt;
7200
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   799
    x, y: 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
   800
begin
7200
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   801
    Level:= Level; // avoid compiler hint
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   802
    ap.ExplR:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   803
    ap.Time:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   804
    ap.Power:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   805
    x:= hwRound(Me^.X);
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   806
    y:= hwRound(Me^.Y);
7154
56e329edf4b8 Improve TestWhip
unc0rr
parents: 7134
diff changeset
   807
7200
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   808
    // check left direction
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   809
    {first RateShove checks farthermost of two whip's AmmoShove attacks 
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   810
    to encourage distant attacks (damaged hog is excluded from view of second 
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   811
    RateShove call)}
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   812
    v1:= RateShove(Me, x - 15, y
7210
2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly
unc0rr
parents: 7208
diff changeset
   813
            , 30, 30, 25
7200
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   814
            , -1, -0.8, afTrackFall or afSetSkip);
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   815
    v1:= v1 +
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   816
        RateShove(Me, x, y
7210
2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly
unc0rr
parents: 7208
diff changeset
   817
            , 30, 30, 25
7200
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   818
            , -1, -0.8, afTrackFall);
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   819
    // now try opposite direction
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   820
    v2:= RateShove(Me, x + 15, y
7210
2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly
unc0rr
parents: 7208
diff changeset
   821
            , 30, 30, 25
7200
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   822
            , 1, -0.8, afTrackFall or afSetSkip);
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   823
    v2:= v2 +
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   824
        RateShove(Me, x, y
7210
2ff30b79d2b0 - Adjust some consts so whip and firepunch work perfectly
unc0rr
parents: 7208
diff changeset
   825
            , 30, 30, 25
7200
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   826
            , 1, -0.8, afTrackFall);
7154
56e329edf4b8 Improve TestWhip
unc0rr
parents: 7134
diff changeset
   827
7200
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   828
    if (v2 > v1) 
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   829
        or {don't encourage turning for no gain}((v2 = v1) and (not Me^.dX.isNegative)) then
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   830
        begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   831
        ap.Angle:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   832
        valueResult:= v2
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   833
        end
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   834
    else 
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   835
        begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   836
        ap.Angle:= -1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   837
        valueResult:= v1
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   838
        end;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   839
    
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   840
    if valueResult <= 0 then
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   841
        valueResult:= BadTurn
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   842
    else
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   843
        inc(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
   844
7200
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   845
    TestWhip:= 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
   846
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
   847
5645
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   848
function TestHammer(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   849
var rate: LongInt;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   850
begin
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   851
Level:= Level; // avoid compiler hint
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   852
ap.ExplR:= 0;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   853
ap.Time:= 0;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   854
ap.Power:= 1;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   855
ap.Angle:= 0;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   856
         
7178
c61cfc9eb29d Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position
unc0rr
parents: 7161
diff changeset
   857
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
   858
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
   859
    rate:= BadTurn;
5645
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   860
TestHammer:= rate;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   861
end;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   862
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   863
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
   864
const cShift = 4;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   865
var bombsSpeed, X, Y, dY: real;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   866
    b: array[0..9] of boolean;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   867
    dmg: array[0..9] of LongInt;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   868
    fexit: boolean;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   869
    i, t, valueResult: LongInt;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   870
begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   871
ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   872
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
   873
if (Level > 3) then
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   874
    exit(BadTurn);
554
4f83b3de17c7 Only bots of 1-3 level use AirAttack weapon
unc0rr
parents: 543
diff changeset
   875
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   876
ap.Angle:= 0;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   877
ap.AttackPutX:= Targ.X;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   878
ap.AttackPutY:= Targ.Y;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   879
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   880
bombsSpeed:= hwFloat2Float(cBombsSpeed);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   881
X:= Targ.X - 135 - cShift; // hh center - cShift
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   882
X:= X - bombsSpeed * sqrt(((Targ.Y + 128) * 2) / cGravityf);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   883
Y:= -128;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   884
dY:= 0;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   885
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   886
for i:= 0 to 9 do
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   887
    begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   888
    b[i]:= true;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   889
    dmg[i]:= 0
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   890
    end;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   891
valueResult:= 0;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   892
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   893
repeat
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   894
    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
   895
    Y:= Y + dY;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   896
    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
   897
    fexit:= true;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   898
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   899
    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
   900
        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
   901
            begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   902
            fexit:= false;
6992
b8f3d8991e92 marked a couple of functions as inline
koda
parents: 6990
diff changeset
   903
            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
   904
                begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   905
                b[i]:= false;
6992
b8f3d8991e92 marked a couple of functions as inline
koda
parents: 6990
diff changeset
   906
                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
   907
                // 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
   908
                end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   909
            end;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   910
until fexit or (Y > cWaterLine);
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   911
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   912
for i:= 0 to 5 do inc(valueResult, dmg[i]);
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   913
t:= valueResult;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   914
ap.AttackPutX:= Targ.X - 60;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   915
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   916
for i:= 0 to 3 do
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   917
    begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   918
    dec(t, dmg[i]);
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   919
    inc(t, dmg[i + 6]);
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   920
    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
   921
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   922
        valueResult:= t;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   923
        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
   924
        end
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   925
    end;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   926
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   927
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
   928
    valueResult:= BadTurn;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   929
TestAirAttack:= valueResult;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   930
end;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   931
3370
37f4f83fedb1 Teleport AI:
mbait
parents: 3350
diff changeset
   932
37f4f83fedb1 Teleport AI:
mbait
parents: 3350
diff changeset
   933
function TestTeleport(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
37f4f83fedb1 Teleport AI:
mbait
parents: 3350
diff changeset
   934
var
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   935
    i, failNum: longword;
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   936
    maxTop: longword;
3370
37f4f83fedb1 Teleport AI:
mbait
parents: 3350
diff changeset
   937
begin
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   938
    TestTeleport := BadTurn;
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   939
    exit(BadTurn);
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   940
    Level:= Level; // avoid compiler hint
6888
32a54322d262 Get rid of TGearsType to simplify pas2c
unc0rr
parents: 6879
diff changeset
   941
    //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
   942
    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
   943
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   944
        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
   945
            begin
3697
d5b30d6373fc remove trailing spaces from end of line
koda
parents: 3677
diff changeset
   946
            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
   947
            
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   948
            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
   949
                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
   950
            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
   951
                begin
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   952
                ap.AttackPutX := Targ.X;
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   953
                ap.AttackPutY := maxTop + cHHRadius;
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   954
                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
   955
                end;
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   956
            end;
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   957
        end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   958
    else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   959
        begin
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   960
        failNum := 0;
3697
d5b30d6373fc remove trailing spaces from end of line
koda
parents: 3677
diff changeset
   961
        repeat
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   962
            i := random(bonuses.Count);
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   963
            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
   964
        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
   965
        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
   966
        
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   967
        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
   968
            begin
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   969
            ap.AttackPutX := bonuses.ar[i].X;
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   970
            ap.AttackPutY := bonuses.ar[i].Y - cHHRadius - bonuses.ar[i].Radius;
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   971
            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
   972
            end;
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   973
        end;
3370
37f4f83fedb1 Teleport AI:
mbait
parents: 3350
diff changeset
   974
end;
37f4f83fedb1 Teleport AI:
mbait
parents: 3350
diff changeset
   975
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   976
end.