hedgewars/uAIAmmoTests.pas
author nemo
Sat, 09 Jun 2012 09:53:15 -0400
changeset 7206 ce46b56ae9f5
parent 7204 522f165cd2e7
child 7208 62e36dc45098
permissions -rw-r--r--
Double sniper rifle damage (AI seems unaware of second shot, when playing). Spread out flakes along X when looping and add a little Y variation. This avoids noticeable patterns. Especially on the rarer close layer or dense flakes like rain (for Y)
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)
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   164
        until TestCollExcludingMe(Me, trunc(x), trunc(y), 5) or (t <= 0);
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   165
        
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   166
        EX:= trunc(x);
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   167
        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
   168
        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
   169
            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
   170
        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
   171
        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
   172
            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
   173
        if valueResult <= value then
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   174
            begin
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   175
            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
   176
            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
   177
            ap.ExplR:= 100;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   178
            ap.ExplX:= EX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   179
            ap.ExplY:= EY;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   180
            valueResult:= value
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   181
            end;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   182
        end
6772
13d13aefa4de small tweak. make drowning prefer higher health hogs
nemo
parents: 6771
diff changeset
   183
//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
   184
until rTime > 4250;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   185
TestBazooka:= valueResult
39
b78e7185ed13 - Increased FPS
unc0rr
parents: 37
diff changeset
   186
end;
374
95169697cc38 - UFO smokes
unc0rr
parents: 371
diff changeset
   187
4580
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   188
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
   189
var Vx, Vy, r: real;
4580
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   190
    rTime: LongInt;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   191
    EX, EY: LongInt;
4580
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   192
    valueResult: LongInt;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   193
    x, y, dX, dY, meX, meY: real;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   194
    t: LongInt;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   195
    value: LongInt;
4580
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   196
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   197
begin
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   198
meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   199
meY:= hwFloat2Float(Me^.Y);
4580
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   200
ap.Time:= 0;
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   201
rTime:= 350;
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   202
ap.ExplR:= 0;
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   203
valueResult:= BadTurn;
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   204
repeat
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   205
    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
   206
    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
   207
    Vy:= cGravityf * rTime * 0.5 - (Targ.Y - meY) / rTime;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   208
    r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   209
    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
   210
        begin
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   211
        x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   212
        y:= meY;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   213
        dX:= Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   214
        dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   215
        t:= rTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   216
        repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   217
            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
   218
            y:= y + dY;
7078
a3408d9ba5ad AI can't use cWindSpeedf since it now does a smooth transition
nemo
parents: 7041
diff changeset
   219
            dX:= dX + windSpeed;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   220
            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
   221
            dec(t)
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   222
        until TestCollExcludingMe(Me, trunc(x), trunc(y), 5) or (t <= 0);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   223
        EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   224
        EY:= trunc(y);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   225
7161
21a9c70b2070 Name the flags for fall tracking and indicating whether the explosion erases terrain.
nemo
parents: 7154
diff changeset
   226
        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
   227
        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
   228
            value:= - Metric(Targ.X, Targ.Y, EX, EY) div 64;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   229
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   230
        if valueResult <= value then
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   231
            begin
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   232
            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
   233
            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
   234
            ap.ExplR:= 0;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   235
            ap.ExplX:= EX;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   236
            ap.ExplY:= EY;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   237
            valueResult:= value
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   238
            end;
4580
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   239
     end
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   240
until (rTime > 4250);
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   241
TestSnowball:= valueResult
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   242
end;
bd43d9ac6e04 add AI routine
nemo
parents: 4578
diff changeset
   243
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
   244
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
   245
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
   246
    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
   247
    TestTime: Longword;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   248
    x, y, dY, meX, meY: real;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   249
    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
   250
begin
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   251
meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   252
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
   253
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
   254
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
   255
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
   256
repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   257
    inc(TestTime, 300);
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   258
    Vx:= (Targ.X - meX) / TestTime;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   259
    Vy:= cGravityf * (TestTime div 2) - Targ.Y - meY / TestTime;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   260
    r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   261
    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
   262
        begin
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   263
        x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   264
        y:= meY;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   265
        dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   266
        t:= TestTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   267
        repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   268
            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
   269
            y:= y + dY;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   270
            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
   271
            dec(t)
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   272
        until TestCollExcludingMe(Me, trunc(x), trunc(y), 7) or (t = 0);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   273
        EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   274
        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
   275
        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
   276
            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
   277
        else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   278
            Score:= BadTurn;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   279
                  
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   280
        if valueResult < Score then
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   281
            begin
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   282
            ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   283
            ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   284
            ap.Time:= TestTime;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   285
            ap.ExplR:= 100;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   286
            ap.ExplX:= EX;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   287
            ap.ExplY:= EY;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   288
            valueResult:= Score
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   289
            end;
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   290
        end
3022
94afd5fc5738 Adjust increment since there is no timer
nemo
parents: 3018
diff changeset
   291
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
   292
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
   293
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
   294
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   295
function TestGrenade(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
70
82d93eeecebe - Many AI improvements
unc0rr
parents: 66
diff changeset
   296
const tDelta = 24;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   297
var Vx, Vy, r: real;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   298
    Score, EX, EY, valueResult: LongInt;
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   299
    TestTime: Longword;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   300
    x, y, meX, meY, dY: real;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   301
    t: LongInt;
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   302
begin
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   303
valueResult:= BadTurn;
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   304
TestTime:= 0;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   305
ap.ExplR:= 0;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   306
meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   307
meY:= hwFloat2Float(Me^.Y);
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   308
repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   309
    inc(TestTime, 1000);
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   310
    Vx:= (Targ.X - meX) / (TestTime + tDelta);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   311
    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
   312
    r:= sqr(Vx) + sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   313
    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
   314
        begin
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   315
        x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   316
        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
   317
        dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   318
        t:= TestTime;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   319
        repeat
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   320
            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
   321
            y:= y + dY;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   322
            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
   323
            dec(t)
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   324
        until TestCollExcludingMe(Me, trunc(x), trunc(y), 5) or (t = 0);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   325
    EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   326
    EY:= trunc(y);
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   327
    if t < 50 then 
6769
44ad49a3a126 Add drowning to grenade too, try some little optimisations
nemo
parents: 6767
diff changeset
   328
        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
   329
            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
   330
        else Score:= RateExplosion(Me, EX, EY, 101)
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   331
    else 
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   332
        Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   333
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   334
    if valueResult < Score then
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   335
        begin
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   336
        ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   337
        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
   338
        ap.Time:= TestTime;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   339
        ap.ExplR:= 100;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   340
        ap.ExplX:= EX;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   341
        ap.ExplY:= EY;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   342
        valueResult:= Score
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   343
        end;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   344
    end
6772
13d13aefa4de small tweak. make drowning prefer higher health hogs
nemo
parents: 6771
diff changeset
   345
//until (Score > 204800) or (TestTime > 4000);
13d13aefa4de small tweak. make drowning prefer higher health hogs
nemo
parents: 6771
diff changeset
   346
until TestTime > 4000;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   347
TestGrenade:= valueResult
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   348
end;
375
18012da67681 AI works properly
unc0rr
parents: 374
diff changeset
   349
2978
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   350
function TestClusterBomb(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   351
const tDelta = 24;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   352
var Vx, Vy, r: real;
2978
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   353
    Score, EX, EY, valueResult: LongInt;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   354
    TestTime: Longword;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   355
    x, y, dY, meX, meY: real;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   356
    t: LongInt;
2978
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   357
begin
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   358
valueResult:= BadTurn;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   359
TestTime:= 0;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   360
ap.ExplR:= 0;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   361
meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   362
meY:= hwFloat2Float(Me^.Y);
2978
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   363
repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   364
    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
   365
    // 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
   366
    if meX<Targ.X then
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   367
        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
   368
    else
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   369
        Vx:= ((Targ.X-10) - meX) / (TestTime + tDelta);
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   370
    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
   371
    r:= sqr(Vx)+sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   372
    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
   373
        begin
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   374
        x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   375
        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
   376
        dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   377
        t:= TestTime;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   378
    repeat
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   379
        x:= x + Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   380
        y:= y + dY;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   381
        dY:= dY + cGravityf;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   382
        dec(t)
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   383
    until TestCollExcludingMe(Me, trunc(x), trunc(y), 5) or (t = 0);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   384
    EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   385
    EY:= trunc(y);
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   386
    if t < 50 then 
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   387
        Score:= RateExplosion(Me, EX, EY, 41)
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   388
    else 
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   389
        Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   390
2978
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   391
     if valueResult < Score then
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   392
        begin
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   393
        ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   394
        ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
2978
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   395
        ap.Time:= TestTime;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   396
        ap.ExplR:= 90;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   397
        ap.ExplX:= EX;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   398
        ap.ExplY:= EY;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   399
        valueResult:= Score
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   400
        end;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   401
     end
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   402
until (TestTime = 4000);
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   403
TestClusterBomb:= valueResult
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   404
end;
e71efb31dee3 Same approach for cluster bomb.
nemo
parents: 2973
diff changeset
   405
2973
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   406
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
   407
const tDelta = 24;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   408
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
   409
    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
   410
    TestTime: Longword;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   411
    x, y, dY, meX, meY: real;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   412
    t: LongInt;
2973
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   413
begin
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   414
valueResult:= BadTurn;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   415
TestTime:= 0;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   416
ap.ExplR:= 0;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   417
meX:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   418
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
   419
repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   420
    inc(TestTime, 1000);
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   421
    Vx:= (Targ.X - meX) / (TestTime + tDelta);
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   422
    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
   423
    r:= sqr(Vx)+sqr(Vy);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   424
    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
   425
        begin
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   426
        x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   427
        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
   428
        dY:= -Vy;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   429
        t:= TestTime;
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   430
        repeat
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   431
            x:= x + Vx;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   432
            y:= y + dY;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   433
            dY:= dY + cGravityf;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   434
            dec(t)
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   435
        until TestCollExcludingMe(Me, trunc(x), trunc(y), 7) or (t = 0);
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   436
        
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   437
        EX:= trunc(x);
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   438
        EY:= trunc(y);
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   439
        if t < 50 then 
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   440
            Score:= RateExplosion(Me, EX, EY, 200) + RateExplosion(Me, EX, EY + 120, 200)
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   441
        else 
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   442
            Score:= BadTurn;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   443
            
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   444
        if valueResult < Score then
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   445
            begin
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   446
            ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   447
            ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15);
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   448
            ap.Time:= TestTime;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   449
            ap.ExplR:= 300;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   450
            ap.ExplX:= EX;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   451
            ap.ExplY:= EY;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   452
            valueResult:= Score
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   453
            end;
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   454
        end
2973
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   455
until (TestTime = 4000);
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   456
TestWatermelon:= valueResult
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   457
end;
b51a0f57cd43 Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents: 2948
diff changeset
   458
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   459
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   460
    function Solve(TX, TY, MX, MY: LongInt): LongWord;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   461
    var A, B, D, T: real;
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   462
        C: LongInt;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   463
    begin
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   464
        A:= sqr(cGravityf);
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   465
        B:= - cGravityf * (TY - MY) - 1;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   466
        C:= sqr(TY - MY) + sqr(TX - MX);
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   467
        D:= sqr(B) - A * C;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   468
        if D >= 0 then
2948
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
            D:= sqrt(D) - B;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   471
            if D >= 0 then
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   472
                T:= sqrt(D * 2 / A)
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   473
            else
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   474
                T:= 0;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   475
            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
   476
            end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   477
            else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   478
                Solve:= 0
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   479
    end;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   480
    
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   481
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
   482
//const tDelta = 24;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   483
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
   484
    Score, EX, EY: LongInt;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   485
    TestTime: Longword;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   486
    x, y, dY, meX, meY: real;
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   487
begin
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   488
    TestMortar:= BadTurn;
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   489
    ap.ExplR:= 0;
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   490
    meX:= hwFloat2Float(Me^.X);
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   491
    meY:= hwFloat2Float(Me^.Y);
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   492
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   493
    if (Level > 2) then
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   494
        exit(BadTurn);
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   495
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   496
    TestTime:= Solve(Targ.X, Targ.Y, trunc(meX), trunc(meY));
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   497
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   498
    if TestTime = 0 then
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   499
        exit(BadTurn);
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   500
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   501
    Vx:= (Targ.X - meX) / TestTime;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   502
    Vy:= cGravityf * (TestTime div 2) - (Targ.Y - meY) / TestTime;
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   503
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   504
    x:= meX;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   505
    y:= meY;
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   506
    dY:= -Vy;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   507
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   508
    repeat
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   509
        x:= x + Vx;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   510
        y:= y + dY;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   511
        dY:= dY + cGravityf;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   512
        EX:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   513
        EY:= trunc(y);
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   514
    until TestCollExcludingMe(Me, EX, EY, 5) or (EY > cWaterLine);
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   515
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   516
    if (EY < cWaterLine) and (dY >= 0) then
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   517
        begin
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   518
        Score:= RateExplosion(Me, EX, EY, 91);
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   519
        if (Score = 0) then
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   520
            if (dY > 0.15) then
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   521
                Score:= - abs(Targ.Y - EY) div 32
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   522
            else
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   523
                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
   524
        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
   525
            Score:= BadTurn
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   526
        end
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   527
    else
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   528
        Score:= BadTurn;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6453
diff changeset
   529
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
   530
    if BadTurn < Score then
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   531
        begin
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   532
        ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level));
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   533
        ap.Power:= 1;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   534
        ap.ExplR:= 100;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   535
        ap.ExplX:= EX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   536
        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
   537
        TestMortar:= Score
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2695
diff changeset
   538
        end;
994
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   539
end;
ea415d03968c - Bots can use mortar
unc0rr
parents: 983
diff changeset
   540
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   541
function TestShotgun(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
1941
b1ef1f86148c Some AI tweaks by imcold
unc0rr
parents: 1854
diff changeset
   542
const
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   543
    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
   544
    MAX_RANGE = 400;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   545
var Vx, Vy, x, y: real;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   546
    rx, ry, valueResult: LongInt;
1941
b1ef1f86148c Some AI tweaks by imcold
unc0rr
parents: 1854
diff changeset
   547
    range: integer;
375
18012da67681 AI works properly
unc0rr
parents: 374
diff changeset
   548
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
   549
TestShotgun:= BadTurn;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   550
ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   551
ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   552
ap.Power:= 1;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   553
x:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   554
y:= hwFloat2Float(Me^.Y);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   555
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
   556
if ( range < MIN_RANGE ) or ( range > MAX_RANGE ) then
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   557
    exit(BadTurn);
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   558
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   559
Vx:= (Targ.X - x) * 1 / 1024;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   560
Vy:= (Targ.Y - y) * 1 / 1024;
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   561
ap.Angle:= DxDy2AttackAnglef(Vx, -Vy);
70
82d93eeecebe - Many AI improvements
unc0rr
parents: 66
diff changeset
   562
repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   563
    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
   564
    y:= y + vY;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   565
    rx:= trunc(x);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   566
    ry:= trunc(y);
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   567
    if TestCollExcludingMe(Me, rx, ry, 2) then
6990
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6894
diff changeset
   568
    begin
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   569
        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
   570
        y:= y + vY * 8;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   571
        valueResult:= RateShotgun(Me, vX, vY, rx, ry);
5642
0ce9e01bae56 Make AI aware of damage modifiers
unc0rr
parents: 5164
diff changeset
   572
     
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
   573
        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
   574
            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
   575
        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
   576
            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
   577
        // 27/20 is reuse bonus
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   578
        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
   579
    end
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   580
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
   581
    or (x < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   582
    or (y < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   583
    or (trunc(x) > LAND_WIDTH)
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   584
    or (trunc(y) > LAND_HEIGHT);
4157
f8898d6cca6e Fix some warnings
unc0rr
parents: 3963
diff changeset
   585
375
18012da67681 AI works properly
unc0rr
parents: 374
diff changeset
   586
TestShotgun:= BadTurn
70
82d93eeecebe - Many AI improvements
unc0rr
parents: 66
diff changeset
   587
end;
438
04bcc3fb127a Fix AI using shotgun and Desert Eagle
unc0rr
parents: 434
diff changeset
   588
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   589
function TestDesertEagle(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
6783
8d9160b85bdb Add fall damage
nemo
parents: 6782
diff changeset
   590
var Vx, Vy, x, y, t, dmgMod: real;
75
d2b737858ff7 - New First Aid powerup
unc0rr
parents: 74
diff changeset
   591
    d: Longword;
6783
8d9160b85bdb Add fall damage
nemo
parents: 6782
diff changeset
   592
    fallDmg, valueResult: LongInt;
75
d2b737858ff7 - New First Aid powerup
unc0rr
parents: 74
diff changeset
   593
begin
6783
8d9160b85bdb Add fall damage
nemo
parents: 6782
diff changeset
   594
dmgMod:= 0.01 * hwFloat2Float(cDamageModifier) * cDamagePercent;
3407
dcc129c4352e Engine:
smxx
parents: 3384
diff changeset
   595
Level:= Level; // avoid compiler hint
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   596
ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   597
ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   598
ap.Power:= 1;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   599
x:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   600
y:= hwFloat2Float(Me^.Y);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   601
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
   602
    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
   603
    TestDesertEagle:= BadTurn;
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   604
    exit(BadTurn);
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   605
    end;
7197
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   606
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
   607
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
   608
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
   609
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
   610
d:= 0;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   611
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   612
repeat
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   613
    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
   614
    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
   615
    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
   616
    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
   617
        inc(d);
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   618
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
   619
    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
   620
    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
   621
    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
   622
    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
   623
    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
   624
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   625
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
   626
    begin
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   627
    fallDmg:= TraceShoveFall(Me, Targ.X, Targ.Y, vX * 0.00125 * 20, vY * 0.00125 * 20);
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   628
    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
   629
        valueResult:= 204800
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   630
    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
   631
    end
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   632
else
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   633
    valueResult:= BadTurn;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   634
TestDesertEagle:= valueResult
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   635
end;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   636
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   637
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   638
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
   639
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
   640
    d: Longword;
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   641
    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
   642
begin
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   643
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
   644
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
   645
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
   646
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
   647
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
   648
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
   649
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
   650
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
   651
    exit(BadTurn);
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   652
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   653
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
   654
t:= 1.5 / dmg;
7206
ce46b56ae9f5 Double sniper rifle damage (AI seems unaware of second shot, when playing). Spread out flakes along X when looping and add a little Y variation. This avoids noticeable patterns. Especially on the rarer close layer or dense flakes like rain (for Y)
nemo
parents: 7204
diff changeset
   655
dmg:= dmg * 0.05; // div 40
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   656
Vx:= (Targ.X - x) * t;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   657
Vy:= (Targ.Y - y) * t;
6894
555a8d8db228 Some more progress with pas2c
unc0rr
parents: 6888
diff changeset
   658
ap.Angle:= DxDy2AttackAnglef(Vx, -Vy);
75
d2b737858ff7 - New First Aid powerup
unc0rr
parents: 74
diff changeset
   659
d:= 0;
1941
b1ef1f86148c Some AI tweaks by imcold
unc0rr
parents: 1854
diff changeset
   660
75
d2b737858ff7 - New First Aid powerup
unc0rr
parents: 74
diff changeset
   661
repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   662
    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
   663
    y:= y + vY;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   664
    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
   665
    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
   666
        inc(d);
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   667
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
   668
    or (x < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   669
    or (y < 0)
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   670
    or (trunc(x) > LAND_WIDTH)
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   671
    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
   672
    or (d > 23);
1941
b1ef1f86148c Some AI tweaks by imcold
unc0rr
parents: 1854
diff changeset
   673
7197
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   674
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
   675
    begin
7197
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   676
    fallDmg:= TraceShoveFall(Me, Targ.X, Targ.Y, vX * 0.00166 * dmg, vY * 0.00166 * dmg);
6783
8d9160b85bdb Add fall damage
nemo
parents: 6782
diff changeset
   677
    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
   678
        TestSniperRifle:= BadTurn
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   679
    else 
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   680
        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
   681
    end
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   682
else
7197
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   683
    TestSniperRifle:= BadTurn
75
d2b737858ff7 - New First Aid powerup
unc0rr
parents: 74
diff changeset
   684
end;
438
04bcc3fb127a Fix AI using shotgun and Desert Eagle
unc0rr
parents: 434
diff changeset
   685
7197
5a9775b97c7e - TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents: 7178
diff changeset
   686
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   687
function TestBaseballBat(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   688
var valueResult: LongInt;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   689
    x, y: real;
79
29b477319854 - New test map
unc0rr
parents: 78
diff changeset
   690
begin
3407
dcc129c4352e Engine:
smxx
parents: 3384
diff changeset
   691
Level:= Level; // avoid compiler hint
6990
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6894
diff changeset
   692
TestBaseballBat:= BadTurn;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   693
ap.ExplR:= 0;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   694
x:= hwFloat2Float(Me^.X);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   695
y:= hwFloat2Float(Me^.Y);
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
   696
if (Level > 2) then
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   697
    exit(BadTurn);
433
9f8f22094c0e AI thinks in separate thread
unc0rr
parents: 409
diff changeset
   698
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   699
ap.Time:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   700
ap.Power:= 1;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   701
if (Targ.X) - trunc(x) >= 0 then
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   702
    ap.Angle:=   cMaxAngle div 4
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   703
else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   704
    ap.Angle:= - cMaxAngle div 4;
6770
7d2c6cdb816a Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents: 6769
diff changeset
   705
7161
21a9c70b2070 Name the flags for fall tracking and indicating whether the explosion erases terrain.
nemo
parents: 7154
diff changeset
   706
valueResult:= RateShove(Me, trunc(x) + LongWord(10*hwSignf(Targ.X - x)), trunc(y), 15, 30, 115, hwSign(Me^.dX)*0.353, -0.353, afTrackFall);
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   707
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
   708
    valueResult:= BadTurn
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   709
else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   710
    inc(valueResult);
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   711
TestBaseballBat:= valueResult;
79
29b477319854 - New test map
unc0rr
parents: 78
diff changeset
   712
end;
29b477319854 - New test map
unc0rr
parents: 78
diff changeset
   713
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   714
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
   715
var valueResult, v1, v2, i: LongInt;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   716
    x, y: LongInt;
82
2f4f3236cccc - New fort
unc0rr
parents: 80
diff changeset
   717
begin
7200
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   718
    Level:= Level; // avoid compiler hint
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   719
    ap.ExplR:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   720
    ap.Time:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   721
    ap.Power:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   722
    x:= hwRound(Me^.X);
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   723
    y:= hwRound(Me^.Y);
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   724
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   725
    v1:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   726
    for i:= 0 to 8 do
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   727
        begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   728
        v1:= v1 + RateShove(Me, x - 10, y - 10 * i
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   729
                , 15, 30, 40
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   730
                , -0.45, -0.9, afTrackFall or afSetSkip);
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   731
        end;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   732
    v1:= v1 + RateShove(Me, x - 10, y - 90
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   733
            , 15, 30, 40
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   734
            , -0.45, -0.9, afTrackFall);
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   735
433
9f8f22094c0e AI thinks in separate thread
unc0rr
parents: 409
diff changeset
   736
7200
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   737
    // now try opposite direction
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   738
    v2:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   739
    for i:= 0 to 8 do
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   740
        begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   741
        v2:= v2 + RateShove(Me, x + 10, y - 10 * i
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   742
                , 15, 30, 40
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   743
                , 0.45, -0.9, afTrackFall or afSetSkip);
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   744
        end;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   745
    v2:= v2 + RateShove(Me, x + 10, y - 90
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   746
            , 15, 30, 40
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   747
            , 0.45, -0.9, afTrackFall);
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   748
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   749
    if (v2 > v1) 
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   750
        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
   751
        begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   752
        ap.Angle:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   753
        valueResult:= v2
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   754
        end
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   755
    else 
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
        ap.Angle:= -1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   758
        valueResult:= v1
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   759
        end;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   760
    
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   761
    if valueResult <= 0 then
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   762
        valueResult:= BadTurn;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   763
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   764
    TestFirePunch:= valueResult;
82
2f4f3236cccc - New fort
unc0rr
parents: 80
diff changeset
   765
end;
433
9f8f22094c0e AI thinks in separate thread
unc0rr
parents: 409
diff changeset
   766
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
   767
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
   768
function TestWhip(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
7154
56e329edf4b8 Improve TestWhip
unc0rr
parents: 7134
diff changeset
   769
var valueResult, v1, v2: LongInt;
7200
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   770
    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
   771
begin
7200
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   772
    Level:= Level; // avoid compiler hint
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   773
    ap.ExplR:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   774
    ap.Time:= 0;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   775
    ap.Power:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   776
    x:= hwRound(Me^.X);
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   777
    y:= hwRound(Me^.Y);
7154
56e329edf4b8 Improve TestWhip
unc0rr
parents: 7134
diff changeset
   778
7200
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   779
    // check left direction
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   780
    {first RateShove checks farthermost of two whip's AmmoShove attacks 
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   781
    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
   782
    RateShove call)}
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   783
    v1:= RateShove(Me, x - 15, y
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   784
            , 30, 30, 40
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   785
            , -1, -0.8, afTrackFall or afSetSkip);
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   786
    v1:= v1 +
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   787
        RateShove(Me, x, y
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   788
            , 30, 30, 40
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   789
            , -1, -0.8, afTrackFall);
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   790
    // now try opposite direction
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   791
    v2:= RateShove(Me, x + 15, y
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   792
            , 30, 30, 40
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   793
            , 1, -0.8, afTrackFall or afSetSkip);
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   794
    v2:= v2 +
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   795
        RateShove(Me, x, y
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   796
            , 30, 30, 40
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   797
            , 1, -0.8, afTrackFall);
7154
56e329edf4b8 Improve TestWhip
unc0rr
parents: 7134
diff changeset
   798
7200
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   799
    if (v2 > v1) 
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   800
        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
   801
        begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   802
        ap.Angle:= 1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   803
        valueResult:= v2
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   804
        end
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   805
    else 
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   806
        begin
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   807
        ap.Angle:= -1;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   808
        valueResult:= v1
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   809
        end;
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   810
    
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   811
    if valueResult <= 0 then
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   812
        valueResult:= BadTurn
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   813
    else
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   814
        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
   815
7200
744c8a5546c6 New bright and shiny TestFirepunch which actually works
unc0rr
parents: 7197
diff changeset
   816
    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
   817
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
   818
5645
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   819
function TestHammer(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   820
var rate: LongInt;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   821
begin
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   822
Level:= Level; // avoid compiler hint
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   823
ap.ExplR:= 0;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   824
ap.Time:= 0;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   825
ap.Power:= 1;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   826
ap.Angle:= 0;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   827
         
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
   828
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
   829
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
   830
    rate:= BadTurn;
5645
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   831
TestHammer:= rate;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   832
end;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   833
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   834
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
   835
const cShift = 4;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   836
var bombsSpeed, X, Y, dY: real;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   837
    b: array[0..9] of boolean;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   838
    dmg: array[0..9] of LongInt;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   839
    fexit: boolean;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   840
    i, t, valueResult: LongInt;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   841
begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   842
ap.ExplR:= 0;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   843
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
   844
if (Level > 3) then
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   845
    exit(BadTurn);
554
4f83b3de17c7 Only bots of 1-3 level use AirAttack weapon
unc0rr
parents: 543
diff changeset
   846
7132
baf3351646f4 - Fix some AI stupidness factors
unc0rr
parents: 7078
diff changeset
   847
ap.Angle:= 0;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   848
ap.AttackPutX:= Targ.X;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   849
ap.AttackPutY:= Targ.Y;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   850
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   851
bombsSpeed:= hwFloat2Float(cBombsSpeed);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   852
X:= Targ.X - 135 - cShift; // hh center - cShift
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   853
X:= X - bombsSpeed * sqrt(((Targ.Y + 128) * 2) / cGravityf);
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   854
Y:= -128;
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   855
dY:= 0;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   856
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   857
for i:= 0 to 9 do
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   858
    begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   859
    b[i]:= true;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   860
    dmg[i]:= 0
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   861
    end;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   862
valueResult:= 0;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   863
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   864
repeat
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   865
    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
   866
    Y:= Y + dY;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   867
    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
   868
    fexit:= true;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   869
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   870
    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
   871
        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
   872
            begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   873
            fexit:= false;
6992
b8f3d8991e92 marked a couple of functions as inline
koda
parents: 6990
diff changeset
   874
            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
   875
                begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   876
                b[i]:= false;
6992
b8f3d8991e92 marked a couple of functions as inline
koda
parents: 6990
diff changeset
   877
                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
   878
                // 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
   879
                end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   880
            end;
6775
22b5fb7217db Change rest of AI tests to floats, reenable snowball
nemo
parents: 6774
diff changeset
   881
until fexit or (Y > cWaterLine);
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   882
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   883
for i:= 0 to 5 do inc(valueResult, dmg[i]);
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   884
t:= valueResult;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   885
ap.AttackPutX:= Targ.X - 60;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   886
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   887
for i:= 0 to 3 do
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   888
    begin
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   889
    dec(t, dmg[i]);
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   890
    inc(t, dmg[i + 6]);
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   891
    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
   892
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   893
        valueResult:= t;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   894
        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
   895
        end
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   896
    end;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   897
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   898
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
   899
    valueResult:= BadTurn;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2630
diff changeset
   900
TestAirAttack:= valueResult;
543
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   901
end;
465e2ec8f05f - Better randomness of placing hedgehogs on the land
unc0rr
parents: 534
diff changeset
   902
3370
37f4f83fedb1 Teleport AI:
mbait
parents: 3350
diff changeset
   903
37f4f83fedb1 Teleport AI:
mbait
parents: 3350
diff changeset
   904
function TestTeleport(Me: PGear; Targ: TPoint; Level: LongInt; var ap: TAttackParams): LongInt;
37f4f83fedb1 Teleport AI:
mbait
parents: 3350
diff changeset
   905
var
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   906
    i, failNum: longword;
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   907
    maxTop: longword;
3370
37f4f83fedb1 Teleport AI:
mbait
parents: 3350
diff changeset
   908
begin
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   909
    TestTeleport := BadTurn;
7041
76a9274f280f More definitions and mess with pascal code
unc0rr
parents: 7007
diff changeset
   910
    exit(BadTurn);
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   911
    Level:= Level; // avoid compiler hint
6888
32a54322d262 Get rid of TGearsType to simplify pas2c
unc0rr
parents: 6879
diff changeset
   912
    //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
   913
    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
   914
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   915
        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
   916
            begin
3697
d5b30d6373fc remove trailing spaces from end of line
koda
parents: 3677
diff changeset
   917
            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
   918
            
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   919
            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
   920
                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
   921
            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
   922
                begin
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   923
                ap.AttackPutX := Targ.X;
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   924
                ap.AttackPutY := maxTop + cHHRadius;
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   925
                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
   926
                end;
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   927
            end;
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   928
        end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   929
    else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   930
        begin
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   931
        failNum := 0;
3697
d5b30d6373fc remove trailing spaces from end of line
koda
parents: 3677
diff changeset
   932
        repeat
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   933
            i := random(bonuses.Count);
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   934
            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
   935
        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
   936
        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
   937
        
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   938
        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
   939
            begin
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   940
            ap.AttackPutX := bonuses.ar[i].X;
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   941
            ap.AttackPutY := bonuses.ar[i].Y - cHHRadius - bonuses.ar[i].Radius;
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   942
            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
   943
            end;
3439
a98984e4f458 Teleport AI:
mbait
parents: 3438
diff changeset
   944
        end;
3370
37f4f83fedb1 Teleport AI:
mbait
parents: 3350
diff changeset
   945
end;
37f4f83fedb1 Teleport AI:
mbait
parents: 3350
diff changeset
   946
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   947
end.