hedgewars/uAIMisc.pas
author Xeli
Sat, 18 Feb 2012 16:56:04 +0100
changeset 6714 f2f93017132c
parent 6700 e04da46ee43c
child 6766 31ba56a8ec43
permissions -rw-r--r--
moved the firebutton, added the AMWidget button and removed the forwardjump widget(it's longpress on backjump now)
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: 1001
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) 2005-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: 136
diff changeset
     5
 * This program is free software; you can redistribute it and/or modify
57c2ef19f719 Relicense to GPL
unc0rr
parents: 136
diff changeset
     6
 * it under the terms of the GNU General Public License as published by
57c2ef19f719 Relicense to GPL
unc0rr
parents: 136
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: 136
diff changeset
     9
 * This program is distributed in the hope that it will be useful,
57c2ef19f719 Relicense to GPL
unc0rr
parents: 136
diff changeset
    10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
57c2ef19f719 Relicense to GPL
unc0rr
parents: 136
diff changeset
    11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
57c2ef19f719 Relicense to GPL
unc0rr
parents: 136
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: 136
diff changeset
    14
 * You should have received a copy of the GNU General Public License
57c2ef19f719 Relicense to GPL
unc0rr
parents: 136
diff changeset
    15
 * along with this program; if not, write to the Free Software
57c2ef19f719 Relicense to GPL
unc0rr
parents: 136
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
2599
c7153d2348f3 move compiler directives to standard pascal
koda
parents: 2587
diff changeset
    19
{$INCLUDE "options.inc"}
2587
0dfa56a8513c fix a segfault in the iphone simulator by moving options.inc at the beginning of the file
koda
parents: 2376
diff changeset
    20
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    21
unit uAIMisc;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    22
interface
4368
unc0rr
parents: 4367
diff changeset
    23
uses SDLh, uConsts, uFloat, uTypes;
369
2aed85310727 AI compiles, but doesn't work
unc0rr
parents: 351
diff changeset
    24
3370
37f4f83fedb1 Teleport AI:
mbait
parents: 3236
diff changeset
    25
const MAXBONUS = 1024;
37f4f83fedb1 Teleport AI:
mbait
parents: 3236
diff changeset
    26
64
9df467527ae5 - Start AI rewrite
unc0rr
parents: 53
diff changeset
    27
type TTarget = record
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    28
    Point: TPoint;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    29
    Score: LongInt;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    30
    end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    31
TTargets = record
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    32
    Count: Longword;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    33
    ar: array[0..Pred(cMaxHHs)] of TTarget;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    34
    end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    35
TJumpType = (jmpNone, jmpHJump, jmpLJump);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    36
TGoInfo = record
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    37
    Ticks: Longword;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    38
    FallPix: Longword;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    39
    JumpType: TJumpType;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    40
    end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    41
TBonus = record
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    42
    X, Y: LongInt;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    43
    Radius: LongInt;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    44
    Score: LongInt;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    45
    end;
64
9df467527ae5 - Start AI rewrite
unc0rr
parents: 53
diff changeset
    46
3038
4e48c276a468 In pascal unit is a namespace
unc0rr
parents: 3018
diff changeset
    47
procedure initModule;
4e48c276a468 In pascal unit is a namespace
unc0rr
parents: 3018
diff changeset
    48
procedure freeModule;
2716
b9ca1bfca24f complete the replacement of init/free wrappers for every unit
koda
parents: 2695
diff changeset
    49
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
    50
procedure FillTargets;
3370
37f4f83fedb1 Teleport AI:
mbait
parents: 3236
diff changeset
    51
procedure FillBonuses(isAfterAttack: boolean; filter: TGearsType = []);
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 370
diff changeset
    52
procedure AwareOfExplosion(x, y, r: LongInt);
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 370
diff changeset
    53
function RatePlace(Gear: PGear): LongInt;
2616
6e2b341dc408 AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups.
nemo
parents: 2599
diff changeset
    54
function TestCollExcludingMe(Me: PGear; x, y, r: LongInt): boolean;
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 370
diff changeset
    55
function TestColl(x, y, r: LongInt): boolean;
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 370
diff changeset
    56
function RateExplosion(Me: PGear; x, y, r: LongInt): LongInt;
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 370
diff changeset
    57
function RateShove(Me: PGear; x, y, r, power: LongInt): LongInt;
509
fd58135a4407 Bots know shotgun behavior better
unc0rr
parents: 498
diff changeset
    58
function RateShotgun(Me: PGear; x, y: LongInt): LongInt;
5645
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
    59
function RateHammer(Me: PGear): LongInt;
369
2aed85310727 AI compiles, but doesn't work
unc0rr
parents: 351
diff changeset
    60
function HHGo(Gear, AltGear: PGear; var GoInfo: TGoInfo): boolean;
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 370
diff changeset
    61
function AIrndSign(num: LongInt): LongInt;
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
    62
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
    63
var ThinkingHH: PGear;
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
    64
    Targets: TTargets;
921
8dd71d960cbc If there's more hedgehogs in AI's team than in others, then it will be less afraid to give damage to friend hedgehog
unc0rr
parents: 883
diff changeset
    65
2716
b9ca1bfca24f complete the replacement of init/free wrappers for every unit
koda
parents: 2695
diff changeset
    66
    bonuses: record
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    67
        Count: Longword;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    68
        ar: array[0..Pred(MAXBONUS)] of TBonus;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    69
        end;
2716
b9ca1bfca24f complete the replacement of init/free wrappers for every unit
koda
parents: 2695
diff changeset
    70
3370
37f4f83fedb1 Teleport AI:
mbait
parents: 3236
diff changeset
    71
implementation
4403
unc0rr
parents: 4377
diff changeset
    72
uses uCollisions, uVariables, uUtils, uDebug;
3370
37f4f83fedb1 Teleport AI:
mbait
parents: 3236
diff changeset
    73
37f4f83fedb1 Teleport AI:
mbait
parents: 3236
diff changeset
    74
const KillScore = 200;
37f4f83fedb1 Teleport AI:
mbait
parents: 3236
diff changeset
    75
37f4f83fedb1 Teleport AI:
mbait
parents: 3236
diff changeset
    76
var friendlyfactor: LongInt = 300;
37f4f83fedb1 Teleport AI:
mbait
parents: 3236
diff changeset
    77
    KnownExplosion: record
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    78
        X, Y, Radius: LongInt
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
    79
        end = (X: 0; Y: 0; Radius: 0);
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    80
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
    81
procedure FillTargets;
547
b81a055f2d06 Convert teams list to array
unc0rr
parents: 542
diff changeset
    82
var i, t: Longword;
6011
519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents: 5881
diff changeset
    83
    f, e: LongInt;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    84
begin
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    85
Targets.Count:= 0;
921
8dd71d960cbc If there's more hedgehogs in AI's team than in others, then it will be less afraid to give damage to friend hedgehog
unc0rr
parents: 883
diff changeset
    86
f:= 0;
8dd71d960cbc If there's more hedgehogs in AI's team than in others, then it will be less afraid to give damage to friend hedgehog
unc0rr
parents: 883
diff changeset
    87
e:= 0;
547
b81a055f2d06 Convert teams list to array
unc0rr
parents: 542
diff changeset
    88
for t:= 0 to Pred(TeamsCount) do
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
    89
    with TeamsArray[t]^ do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
    90
        if not hasGone then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
    91
            begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
    92
            for i:= 0 to cMaxHHIndex do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
    93
                if (Hedgehogs[i].Gear <> nil)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
    94
                and (Hedgehogs[i].Gear <> ThinkingHH) then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
    95
                    begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
    96
                    with Targets.ar[Targets.Count], Hedgehogs[i] do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
    97
                        begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
    98
                        Point.X:= hwRound(Gear^.X);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
    99
                        Point.Y:= hwRound(Gear^.Y);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   100
                        if Clan <> CurrentTeam^.Clan then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   101
                            begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   102
                            Score:=  Gear^.Health;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   103
                            inc(e)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   104
                            end else
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   105
                            begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   106
                            Score:= -Gear^.Health;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   107
                            inc(f)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   108
                            end
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   109
                        end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   110
                    inc(Targets.Count)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   111
                    end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   112
            end;
921
8dd71d960cbc If there's more hedgehogs in AI's team than in others, then it will be less afraid to give damage to friend hedgehog
unc0rr
parents: 883
diff changeset
   113
8dd71d960cbc If there's more hedgehogs in AI's team than in others, then it will be less afraid to give damage to friend hedgehog
unc0rr
parents: 883
diff changeset
   114
if e > f then friendlyfactor:= 300 + (e - f) * 30
5881
099464aab4b6 fix for issue #139
nemo
parents: 5645
diff changeset
   115
else friendlyfactor:= max(30, 300 - f * 80 div max(1,e))
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   116
end;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   117
6474
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6396
diff changeset
   118
procedure AddBonus(x, y: LongInt; r: Longword; s: LongInt);
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6396
diff changeset
   119
begin
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6396
diff changeset
   120
bonuses.ar[bonuses.Count].x:= x;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6396
diff changeset
   121
bonuses.ar[bonuses.Count].y:= y;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6396
diff changeset
   122
bonuses.ar[bonuses.Count].Radius:= r;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6396
diff changeset
   123
bonuses.ar[bonuses.Count].Score:= s;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6396
diff changeset
   124
inc(bonuses.Count);
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6396
diff changeset
   125
TryDo(bonuses.Count <= MAXBONUS, 'Bonuses overflow', true)
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6396
diff changeset
   126
end;
42e9773eedfd - Improve renderer a bit, disallow nested functions
unc0rr
parents: 6396
diff changeset
   127
3370
37f4f83fedb1 Teleport AI:
mbait
parents: 3236
diff changeset
   128
procedure FillBonuses(isAfterAttack: boolean; filter: TGearsType);
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   129
var Gear: PGear;
549
4278a80140a8 - Introduce clans (teams with same color)
unc0rr
parents: 547
diff changeset
   130
    MyClan: PClan;
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   131
begin
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   132
bonuses.Count:= 0;
4372
3836973380b9 remove some more PHedgehog casts
nemo
parents: 4368
diff changeset
   133
MyClan:= ThinkingHH^.Hedgehog^.Team^.Clan;
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   134
Gear:= GearsList;
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   135
while Gear <> nil do
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   136
    begin
5244
1b408b965c01 Don't stick to enemies when there are more than 2 clans
unc0rr
parents: 4977
diff changeset
   137
    if (filter = []) or (Gear^.Kind in filter) then
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   138
        case Gear^.Kind of
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   139
            gtCase:
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   140
            AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 33, 25);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   141
            gtFlame:
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   142
                if (Gear^.State and gsttmpFlag) <> 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   143
                    AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 20, -50);
4977
c89cca0a8785 Try to make AI aware of dud mines by clearing gstAttacking on dud, and adding some rules on mine health/damage/dud probability to AI weighting.
nemo
parents: 4976
diff changeset
   144
// avoid mines unless they are very likely to be duds, or are duds. also avoid if they are about to blow 
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   145
            gtMine:
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   146
                if ((Gear^.State and gstAttacking) = 0) and (((cMineDudPercent < 90) and (Gear^.Health <> 0))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   147
                or (isAfterAttack and (Gear^.Health = 0) and (Gear^.Damage > 30))) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   148
                    AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 50, -50)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   149
                else if (Gear^.State and gstAttacking) <> 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   150
                    AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 100, -50); // mine is on
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   151
                    
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   152
            gtExplosives:
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   153
            if isAfterAttack then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   154
                AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 75, -60+Gear^.Health);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   155
                
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   156
            gtSMine:
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   157
                AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 50, -30);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   158
                
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   159
            gtDynamite:
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   160
                AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 150, -75);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   161
                
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   162
            gtHedgehog:
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   163
                begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   164
                if Gear^.Damage >= Gear^.Health then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   165
                    AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 60, -25)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   166
                else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   167
                    if isAfterAttack and (ThinkingHH^.Hedgehog <> Gear^.Hedgehog) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   168
                        if (ClansCount > 2) or (MyClan = Gear^.Hedgehog^.Team^.Clan) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   169
                            AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 150, -3) // hedgehog-friend
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   170
                        else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   171
                            AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 100, 3)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   172
                end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   173
            end;
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   174
    Gear:= Gear^.NextGear
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   175
    end;
71
5f56c6979496 - Changed falling damage scoring
unc0rr
parents: 70
diff changeset
   176
if isAfterAttack and (KnownExplosion.Radius > 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
   177
    with KnownExplosion do
74
42257fee61ae - Unicode support for team and hedgehogs names
unc0rr
parents: 71
diff changeset
   178
        AddBonus(X, Y, Radius + 10, -Radius);
71
5f56c6979496 - Changed falling damage scoring
unc0rr
parents: 70
diff changeset
   179
end;
5f56c6979496 - Changed falling damage scoring
unc0rr
parents: 70
diff changeset
   180
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 370
diff changeset
   181
procedure AwareOfExplosion(x, y, r: LongInt);
71
5f56c6979496 - Changed falling damage scoring
unc0rr
parents: 70
diff changeset
   182
begin
5f56c6979496 - Changed falling damage scoring
unc0rr
parents: 70
diff changeset
   183
KnownExplosion.X:= x;
5f56c6979496 - Changed falling damage scoring
unc0rr
parents: 70
diff changeset
   184
KnownExplosion.Y:= y;
5f56c6979496 - Changed falling damage scoring
unc0rr
parents: 70
diff changeset
   185
KnownExplosion.Radius:= r
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   186
end;
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   187
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 370
diff changeset
   188
function RatePlace(Gear: PGear): LongInt;
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 370
diff changeset
   189
var i, r: LongInt;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2616
diff changeset
   190
    rate: LongInt;
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   191
begin
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2616
diff changeset
   192
rate:= 0;
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   193
for i:= 0 to Pred(bonuses.Count) do
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   194
    with bonuses.ar[i] do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   195
        begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   196
        r:= hwRound(Distance(Gear^.X - int2hwFloat(X), Gear^.Y - int2hwFloat(Y)));
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   197
        if r < Radius then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   198
            inc(rate, Score * (Radius - r))
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   199
        end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   200
    RatePlace:= rate;
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   201
end;
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   202
2616
6e2b341dc408 AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups.
nemo
parents: 2599
diff changeset
   203
// Wrapper to test various approaches.  If it works reasonably, will just replace.
6e2b341dc408 AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups.
nemo
parents: 2599
diff changeset
   204
// Right now, converting to hwFloat is a tad inefficient since the x/y were hwFloat to begin with...
6e2b341dc408 AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups.
nemo
parents: 2599
diff changeset
   205
function TestCollExcludingMe(Me: PGear; x, y, r: LongInt): boolean;
6e2b341dc408 AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups.
nemo
parents: 2599
diff changeset
   206
var MeX, MeY: LongInt;
6e2b341dc408 AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups.
nemo
parents: 2599
diff changeset
   207
begin
6e2b341dc408 AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups.
nemo
parents: 2599
diff changeset
   208
    if ((x and LAND_WIDTH_MASK) = 0) and ((y and LAND_HEIGHT_MASK) = 0) then
6e2b341dc408 AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups.
nemo
parents: 2599
diff changeset
   209
        begin
6e2b341dc408 AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups.
nemo
parents: 2599
diff changeset
   210
        MeX:= hwRound(Me^.X);
6e2b341dc408 AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups.
nemo
parents: 2599
diff changeset
   211
        MeY:= hwRound(Me^.Y);
6e2b341dc408 AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups.
nemo
parents: 2599
diff changeset
   212
        // We are still inside the hog. Skip radius test
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   213
        if ((((x-MeX)*(x-MeX)) + ((y-MeY)*(y-MeY))) < 256) and ((Land[y, x] and $FF00) = 0) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   214
            exit(false);
2616
6e2b341dc408 AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups.
nemo
parents: 2599
diff changeset
   215
        end;
6e2b341dc408 AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups.
nemo
parents: 2599
diff changeset
   216
    exit(TestColl(x, y, r))
6e2b341dc408 AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups.
nemo
parents: 2599
diff changeset
   217
end;
6e2b341dc408 AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups.
nemo
parents: 2599
diff changeset
   218
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 370
diff changeset
   219
function TestColl(x, y, r: LongInt): boolean;
369
2aed85310727 AI compiles, but doesn't work
unc0rr
parents: 351
diff changeset
   220
var b: boolean;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   221
begin
1753
2ccba26f1aa4 Apply nemo's world resize patch
unc0rr
parents: 1519
diff changeset
   222
b:= (((x-r) and LAND_WIDTH_MASK) = 0)and(((y-r) and LAND_HEIGHT_MASK) = 0) and (Land[y-r, x-r] <> 0);
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   223
if b then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   224
    exit(true);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   225
    
1753
2ccba26f1aa4 Apply nemo's world resize patch
unc0rr
parents: 1519
diff changeset
   226
b:=(((x-r) and LAND_WIDTH_MASK) = 0)and(((y+r) and LAND_HEIGHT_MASK) = 0) and (Land[y+r, x-r] <> 0);
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 b then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   228
    exit(true);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   229
    
1753
2ccba26f1aa4 Apply nemo's world resize patch
unc0rr
parents: 1519
diff changeset
   230
b:=(((x+r) and LAND_WIDTH_MASK) = 0)and(((y-r) and LAND_HEIGHT_MASK) = 0) and (Land[y-r, x+r] <> 0);
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   231
if b then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   232
    exit(true);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   233
    
1753
2ccba26f1aa4 Apply nemo's world resize patch
unc0rr
parents: 1519
diff changeset
   234
TestColl:=(((x+r) and LAND_WIDTH_MASK) = 0)and(((y+r) and LAND_HEIGHT_MASK) = 0) and (Land[y+r, x+r] <> 0)
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   235
end;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   236
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 370
diff changeset
   237
function RateExplosion(Me: PGear; x, y, r: LongInt): LongInt;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2616
diff changeset
   238
var i, dmg, rate: LongInt;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   239
begin
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2616
diff changeset
   240
rate:= 0;
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   241
// add our virtual position
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   242
with Targets.ar[Targets.Count] do
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   243
    begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   244
    Point.x:= hwRound(Me^.X);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   245
    Point.y:= hwRound(Me^.Y);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   246
    Score:= - ThinkingHH^.Health
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   247
    end;
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   248
// rate explosion
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   249
for i:= 0 to Targets.Count do
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   250
    with Targets.ar[i] do
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   251
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   252
        dmg:= hwRound(_0_01 * cDamageModifier * min((r + cHHRadius div 2 - LongInt(DistanceI(Point.x - x, Point.y - y).Round)) div 2, r) * cDamagePercent);
5642
0ce9e01bae56 Make AI aware of damage modifiers
unc0rr
parents: 5604
diff changeset
   253
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   254
        if dmg > 0 then
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   255
            begin
509
fd58135a4407 Bots know shotgun behavior better
unc0rr
parents: 498
diff changeset
   256
            if dmg >= abs(Score) then
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   257
                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
   258
                    inc(rate, KillScore)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   259
                else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   260
                    dec(rate, KillScore * friendlyfactor div 100)
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   261
            else
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   262
                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
   263
                    inc(rate, dmg)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   264
            else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   265
                dec(rate, dmg * friendlyfactor div 100)
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   266
            end;
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   267
        end;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2616
diff changeset
   268
RateExplosion:= rate * 1024;
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   269
end;
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   270
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 370
diff changeset
   271
function RateShove(Me: PGear; x, y, r, power: LongInt): LongInt;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2616
diff changeset
   272
var i, dmg, rate: LongInt;
79
29b477319854 - New test map
unc0rr
parents: 75
diff changeset
   273
begin
3407
dcc129c4352e Engine:
smxx
parents: 3370
diff changeset
   274
Me:= Me; // avoid compiler hint
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2616
diff changeset
   275
rate:= 0;
433
9f8f22094c0e AI thinks in separate thread
unc0rr
parents: 393
diff changeset
   276
for i:= 0 to Pred(Targets.Count) do
79
29b477319854 - New test map
unc0rr
parents: 75
diff changeset
   277
    with Targets.ar[i] do
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   278
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   279
        dmg:= r - hwRound(DistanceI(Point.x - x, Point.y - y));
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   280
        dmg:= hwRound(_0_01 * cDamageModifier * dmg * cDamagePercent);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   281
        if dmg > 0 then
79
29b477319854 - New test map
unc0rr
parents: 75
diff changeset
   282
            begin
509
fd58135a4407 Bots know shotgun behavior better
unc0rr
parents: 498
diff changeset
   283
            if power >= abs(Score) then
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   284
                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
   285
                    inc(rate, KillScore)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   286
                else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   287
                    dec(rate, KillScore * friendlyfactor div 100)
79
29b477319854 - New test map
unc0rr
parents: 75
diff changeset
   288
            else
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   289
                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
   290
                    inc(rate, power)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   291
                else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   292
                    dec(rate, power * friendlyfactor div 100)
79
29b477319854 - New test map
unc0rr
parents: 75
diff changeset
   293
            end;
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   294
        end;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2616
diff changeset
   295
RateShove:= rate * 1024
79
29b477319854 - New test map
unc0rr
parents: 75
diff changeset
   296
end;
29b477319854 - New test map
unc0rr
parents: 75
diff changeset
   297
509
fd58135a4407 Bots know shotgun behavior better
unc0rr
parents: 498
diff changeset
   298
function RateShotgun(Me: PGear; x, y: LongInt): LongInt;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2616
diff changeset
   299
var i, dmg, rate: LongInt;
509
fd58135a4407 Bots know shotgun behavior better
unc0rr
parents: 498
diff changeset
   300
begin
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2616
diff changeset
   301
rate:= 0;
509
fd58135a4407 Bots know shotgun behavior better
unc0rr
parents: 498
diff changeset
   302
// add our virtual position
fd58135a4407 Bots know shotgun behavior better
unc0rr
parents: 498
diff changeset
   303
with Targets.ar[Targets.Count] do
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   304
    begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   305
    Point.x:= hwRound(Me^.X);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   306
    Point.y:= hwRound(Me^.Y);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   307
    Score:= - ThinkingHH^.Health
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   308
    end;
509
fd58135a4407 Bots know shotgun behavior better
unc0rr
parents: 498
diff changeset
   309
// rate shot
fd58135a4407 Bots know shotgun behavior better
unc0rr
parents: 498
diff changeset
   310
for i:= 0 to Targets.Count do
fd58135a4407 Bots know shotgun behavior better
unc0rr
parents: 498
diff changeset
   311
    with Targets.ar[i] do
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   312
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   313
        dmg:= min(cHHRadius + cShotgunRadius + 4 - hwRound(DistanceI(Point.x - x, Point.y - y)), 25);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   314
        dmg:= hwRound(_0_01 * cDamageModifier * dmg * cDamagePercent);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   315
        if dmg > 0 then
509
fd58135a4407 Bots know shotgun behavior better
unc0rr
parents: 498
diff changeset
   316
            begin
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   317
                if dmg >= abs(Score) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   318
                    dmg := KillScore;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   319
                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
   320
                    inc(rate, dmg)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   321
                else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   322
                    dec(rate, dmg * friendlyfactor div 100);
509
fd58135a4407 Bots know shotgun behavior better
unc0rr
parents: 498
diff changeset
   323
            end;
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   324
        end;        
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2616
diff changeset
   325
RateShotgun:= rate * 1024;
509
fd58135a4407 Bots know shotgun behavior better
unc0rr
parents: 498
diff changeset
   326
end;
fd58135a4407 Bots know shotgun behavior better
unc0rr
parents: 498
diff changeset
   327
5645
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   328
function RateHammer(Me: PGear): LongInt;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   329
var x, y, i, r, rate: LongInt;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   330
begin
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   331
// hammer hit shift against attecker hog is 10
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   332
x:= hwRound(Me^.X) + hwSign(Me^.dX) * 10;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   333
y:= hwRound(Me^.Y);
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   334
rate:= 0;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   335
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   336
for i:= 0 to Pred(Targets.Count) do
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   337
    with Targets.ar[i] do
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   338
        begin
5645
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   339
         // hammer hit radius is 8, shift is 10
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   340
        r:= hwRound(DistanceI(Point.x - x, Point.y - y));
5645
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   341
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   342
        if r <= 18 then
5645
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   343
            if Score > 0 then 
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   344
                inc(rate, Score div 3)
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   345
            else 
5645
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   346
                inc(rate, Score div 3 * friendlyfactor div 100)
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   347
        end;
5645
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   348
RateHammer:= rate * 1024;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   349
end;
b434ba5d064e Implement TestHammer which makes sense
unc0rr
parents: 5642
diff changeset
   350
369
2aed85310727 AI compiles, but doesn't work
unc0rr
parents: 351
diff changeset
   351
function HHJump(Gear: PGear; JumpType: TJumpType; var GoInfo: TGoInfo): boolean;
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 370
diff changeset
   352
var bX, bY: LongInt;
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2616
diff changeset
   353
    bRes: boolean;
80
3c3dc6a148ca - Fixed bug with hedgehog under water using rope
unc0rr
parents: 79
diff changeset
   354
begin
2695
ed789a7ef68d makes freepascal code compatible with OBJFPC mode
koda
parents: 2616
diff changeset
   355
bRes:= false;
80
3c3dc6a148ca - Fixed bug with hedgehog under water using rope
unc0rr
parents: 79
diff changeset
   356
GoInfo.Ticks:= 0;
3c3dc6a148ca - Fixed bug with hedgehog under water using rope
unc0rr
parents: 79
diff changeset
   357
GoInfo.JumpType:= jmpNone;
369
2aed85310727 AI compiles, but doesn't work
unc0rr
parents: 351
diff changeset
   358
bX:= hwRound(Gear^.X);
2aed85310727 AI compiles, but doesn't work
unc0rr
parents: 351
diff changeset
   359
bY:= hwRound(Gear^.Y);
80
3c3dc6a148ca - Fixed bug with hedgehog under water using rope
unc0rr
parents: 79
diff changeset
   360
case JumpType of
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   361
    jmpNone:
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   362
    exit(bRes);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   363
    
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   364
    jmpHJump:
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   365
    if TestCollisionYwithGear(Gear, -1) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   366
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   367
        Gear^.dY:= -_0_2;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   368
        SetLittle(Gear^.dX);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   369
        Gear^.State:= Gear^.State or gstMoving or gstHHJumping;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   370
        end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   371
    else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   372
        exit(bRes);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   373
        
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   374
    jmpLJump:
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   375
    begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   376
    if TestCollisionYwithGear(Gear, -1) <> 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   377
          if not TestCollisionXwithXYShift(Gear, _0, -2, hwSign(Gear^.dX)) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   378
            Gear^.Y:= Gear^.Y - int2hwFloat(2)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   379
        else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   380
            if not TestCollisionXwithXYShift(Gear, _0, -1, hwSign(Gear^.dX)) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   381
                Gear^.Y:= Gear^.Y - _1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   382
        if not (TestCollisionXwithGear(Gear, hwSign(Gear^.dX))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   383
        or (TestCollisionYwithGear(Gear, -1) <> 0)) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   384
            begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   385
            Gear^.dY:= -_0_15;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   386
            Gear^.dX:= SignAs(_0_15, Gear^.dX);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   387
            Gear^.State:= Gear^.State or gstMoving or gstHHJumping
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   388
            end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   389
        else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   390
            exit(bRes)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   391
    end
80
3c3dc6a148ca - Fixed bug with hedgehog under water using rope
unc0rr
parents: 79
diff changeset
   392
    end;
2376
ece7b87f1334 Strip trailing spaces
nemo
parents: 1941
diff changeset
   393
80
3c3dc6a148ca - Fixed bug with hedgehog under water using rope
unc0rr
parents: 79
diff changeset
   394
repeat
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   395
    if not (hwRound(Gear^.Y) + cHHRadius < cWaterLine) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   396
        exit(bRes);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   397
    if (Gear^.State and gstMoving) <> 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   398
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   399
        if (GoInfo.Ticks = 350) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   400
            if (not (hwAbs(Gear^.dX) > cLittle)) and (Gear^.dY < -_0_02) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   401
                begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   402
                Gear^.dY:= -_0_25;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   403
                Gear^.dX:= SignAs(_0_02, Gear^.dX)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   404
                end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   405
    if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) then SetLittle(Gear^.dX);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   406
        Gear^.X:= Gear^.X + Gear^.dX;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   407
    inc(GoInfo.Ticks);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   408
    Gear^.dY:= Gear^.dY + cGravity;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   409
    if Gear^.dY > _0_4 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   410
        exit(bRes);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   411
    if (Gear^.dY.isNegative)and (TestCollisionYwithGear(Gear, -1) <> 0) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   412
        Gear^.dY:= _0;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   413
    Gear^.Y:= Gear^.Y + Gear^.dY;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   414
    if (not Gear^.dY.isNegative)and (TestCollisionYwithGear(Gear, 1) <> 0) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   415
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   416
        Gear^.State:= Gear^.State and not (gstMoving or gstHHJumping);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   417
        Gear^.dY:= _0;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   418
        case JumpType of
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   419
            jmpHJump:
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   420
            if bY - hwRound(Gear^.Y) > 5 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   421
                begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   422
                bRes:= true;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   423
                GoInfo.JumpType:= jmpHJump;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   424
                inc(GoInfo.Ticks, 300 + 300) // 300 before jump, 300 after
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   425
                end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   426
            jmpLJump: if abs(bX - hwRound(Gear^.X)) > 30 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   427
                begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   428
                bRes:= true;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   429
                GoInfo.JumpType:= jmpLJump;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   430
                inc(GoInfo.Ticks, 300 + 300) // 300 before jump, 300 after
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   431
                end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   432
                end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   433
            exit(bRes)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   434
            end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   435
        end;
369
2aed85310727 AI compiles, but doesn't work
unc0rr
parents: 351
diff changeset
   436
until false
80
3c3dc6a148ca - Fixed bug with hedgehog under water using rope
unc0rr
parents: 79
diff changeset
   437
end;
3c3dc6a148ca - Fixed bug with hedgehog under water using rope
unc0rr
parents: 79
diff changeset
   438
369
2aed85310727 AI compiles, but doesn't work
unc0rr
parents: 351
diff changeset
   439
function HHGo(Gear, AltGear: PGear; var GoInfo: TGoInfo): boolean;
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 370
diff changeset
   440
var pX, pY: LongInt;
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   441
begin
80
3c3dc6a148ca - Fixed bug with hedgehog under water using rope
unc0rr
parents: 79
diff changeset
   442
AltGear^:= Gear^;
3c3dc6a148ca - Fixed bug with hedgehog under water using rope
unc0rr
parents: 79
diff changeset
   443
75
d2b737858ff7 - New First Aid powerup
unc0rr
parents: 74
diff changeset
   444
GoInfo.Ticks:= 0;
80
3c3dc6a148ca - Fixed bug with hedgehog under water using rope
unc0rr
parents: 79
diff changeset
   445
GoInfo.FallPix:= 0;
3c3dc6a148ca - Fixed bug with hedgehog under water using rope
unc0rr
parents: 79
diff changeset
   446
GoInfo.JumpType:= jmpNone;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   447
repeat
369
2aed85310727 AI compiles, but doesn't work
unc0rr
parents: 351
diff changeset
   448
pX:= hwRound(Gear^.X);
2aed85310727 AI compiles, but doesn't work
unc0rr
parents: 351
diff changeset
   449
pY:= hwRound(Gear^.Y);
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   450
if pY + cHHRadius >= cWaterLine then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   451
    exit(false);
542
ec26095f1bed - Get rid of ammoProp_AttackInFall and gstFalling
unc0rr
parents: 509
diff changeset
   452
if (Gear^.State and gstMoving) <> 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
   453
    begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   454
    inc(GoInfo.Ticks);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   455
    Gear^.dY:= Gear^.dY + cGravity;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   456
    if Gear^.dY > _0_4 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   457
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   458
        Goinfo.FallPix:= 0;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   459
        HHJump(AltGear, jmpLJump, GoInfo); // try ljump instead of fall with damage
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   460
        exit(false)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   461
        end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   462
    Gear^.Y:= Gear^.Y + Gear^.dY;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   463
    if hwRound(Gear^.Y) > pY then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   464
        inc(GoInfo.FallPix);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   465
    if TestCollisionYwithGear(Gear, 1) <> 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   466
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   467
        inc(GoInfo.Ticks, 410);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   468
        Gear^.State:= Gear^.State and not (gstMoving or gstHHJumping);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   469
        Gear^.dY:= _0;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   470
        HHJump(AltGear, jmpLJump, GoInfo); // try ljump instead of fall
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   471
        exit(true)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   472
        end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   473
    continue
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   474
    end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   475
    if (Gear^.Message and gmLeft  )<>0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   476
        Gear^.dX:= -cLittle
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
        if (Gear^.Message and gmRight )<>0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   479
             Gear^.dX:=  cLittle
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   480
        else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   481
                exit(false);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   482
    if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   483
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   484
        if not (TestCollisionXwithXYShift(Gear, _0, -6, hwSign(Gear^.dX))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   485
        or (TestCollisionYwithGear(Gear, -1) <> 0)) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   486
            Gear^.Y:= Gear^.Y - _1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   487
            
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   488
        if not (TestCollisionXwithXYShift(Gear, _0, -5, hwSign(Gear^.dX))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   489
        or (TestCollisionYwithGear(Gear, -1) <> 0)) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   490
            Gear^.Y:= Gear^.Y - _1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   491
            
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   492
        if not (TestCollisionXwithXYShift(Gear, _0, -4, hwSign(Gear^.dX))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   493
        or (TestCollisionYwithGear(Gear, -1) <> 0)) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   494
            Gear^.Y:= Gear^.Y - _1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   495
            
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   496
        if not (TestCollisionXwithXYShift(Gear, _0, -3, hwSign(Gear^.dX))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   497
        or (TestCollisionYwithGear(Gear, -1) <> 0)) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   498
            Gear^.Y:= Gear^.Y - _1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   499
        if not (TestCollisionXwithXYShift(Gear, _0, -2, hwSign(Gear^.dX))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   500
        or (TestCollisionYwithGear(Gear, -1) <> 0)) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   501
            Gear^.Y:= Gear^.Y - _1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   502
            
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   503
        if not (TestCollisionXwithXYShift(Gear, _0, -1, hwSign(Gear^.dX))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   504
        or (TestCollisionYwithGear(Gear, -1) <> 0)) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   505
            Gear^.Y:= Gear^.Y - _1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   506
        end;
66
9643d75baf1e Many AI improvements, bots do think in separate thread
unc0rr
parents: 64
diff changeset
   507
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   508
    if not TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   509
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   510
        Gear^.X:= Gear^.X + int2hwFloat(hwSign(Gear^.dX));
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   511
        inc(GoInfo.Ticks, cHHStepTicks)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   512
        end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   513
        
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   514
    if TestCollisionYwithGear(Gear, 1) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   515
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   516
        Gear^.Y:= Gear^.Y + _1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   517
        
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   518
    if TestCollisionYwithGear(Gear, 1) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   519
          begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   520
        Gear^.Y:= Gear^.Y + _1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   521
        
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   522
    if TestCollisionYwithGear(Gear, 1) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   523
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   524
        Gear^.Y:= Gear^.Y + _1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   525
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   526
    if TestCollisionYwithGear(Gear, 1) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   527
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   528
        Gear^.Y:= Gear^.Y + _1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   529
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   530
    if TestCollisionYwithGear(Gear, 1) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   531
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   532
        Gear^.Y:= Gear^.Y + _1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   533
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   534
    if TestCollisionYwithGear(Gear, 1) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   535
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   536
        Gear^.Y:= Gear^.Y + _1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   537
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   538
    if TestCollisionYwithGear(Gear, 1) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   539
        begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   540
        Gear^.Y:= Gear^.Y - _6;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   541
        Gear^.dY:= _0;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   542
        Gear^.State:= Gear^.State or gstMoving
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   543
        end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   544
    end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   545
    end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   546
    end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   547
    end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   548
    end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   549
    end;
542
ec26095f1bed - Get rid of ammoProp_AttackInFall and gstFalling
unc0rr
parents: 509
diff changeset
   550
if (pX <> hwRound(Gear^.X)) and ((Gear^.State and gstMoving) = 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
   551
    exit(true);
542
ec26095f1bed - Get rid of ammoProp_AttackInFall and gstFalling
unc0rr
parents: 509
diff changeset
   552
until (pX = hwRound(Gear^.X)) and (pY = hwRound(Gear^.Y)) and ((Gear^.State and gstMoving) = 0);
375
18012da67681 AI works properly
unc0rr
parents: 371
diff changeset
   553
HHJump(AltGear, jmpHJump, GoInfo);
5425
862c194a1a1c Remove unneeded variable
unc0rr
parents: 5422
diff changeset
   554
HHGo:= false;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   555
end;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   556
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 370
diff changeset
   557
function AIrndSign(num: LongInt): LongInt;
136
89970b70b076 Implement bot levels
unc0rr
parents: 108
diff changeset
   558
begin
6580
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   559
if random(2) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   560
    AIrndSign:=   num
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   561
else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents: 6474
diff changeset
   562
    AIrndSign:= - num
2376
ece7b87f1334 Strip trailing spaces
nemo
parents: 1941
diff changeset
   563
end;
136
89970b70b076 Implement bot levels
unc0rr
parents: 108
diff changeset
   564
3038
4e48c276a468 In pascal unit is a namespace
unc0rr
parents: 3018
diff changeset
   565
procedure initModule;
2716
b9ca1bfca24f complete the replacement of init/free wrappers for every unit
koda
parents: 2695
diff changeset
   566
begin
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   567
    friendlyfactor:= 300;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   568
    KnownExplosion.X:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   569
    KnownExplosion.Y:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2716
diff changeset
   570
    KnownExplosion.Radius:= 0;
2716
b9ca1bfca24f complete the replacement of init/free wrappers for every unit
koda
parents: 2695
diff changeset
   571
end;
b9ca1bfca24f complete the replacement of init/free wrappers for every unit
koda
parents: 2695
diff changeset
   572
3038
4e48c276a468 In pascal unit is a namespace
unc0rr
parents: 3018
diff changeset
   573
procedure freeModule;
2716
b9ca1bfca24f complete the replacement of init/free wrappers for every unit
koda
parents: 2695
diff changeset
   574
begin
b9ca1bfca24f complete the replacement of init/free wrappers for every unit
koda
parents: 2695
diff changeset
   575
b9ca1bfca24f complete the replacement of init/free wrappers for every unit
koda
parents: 2695
diff changeset
   576
end;
b9ca1bfca24f complete the replacement of init/free wrappers for every unit
koda
parents: 2695
diff changeset
   577
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   578
end.