hedgewars/uGearsUtils.pas
author sheepluva
Tue, 02 Dec 2014 22:11:22 +0100
changeset 10609 15f2908113a1
parent 10558 b574f04c9685
child 10634 35d059bd0932
permissions -rw-r--r--
make tests use Draw.lua for now too
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
     1
(*
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
     2
 * Hedgewars, a free turn based strategy game
9998
736015b847e3 update copyright to 2014
sheepluva
parents: 9814
diff changeset
     3
 * Copyright (c) 2004-2014 Andrey Korotaev <unC0Rr@gmail.com>
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
     4
 *
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
     5
 * This program is free software; you can redistribute it and/or modify
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
     6
 * it under the terms of the GNU General Public License as published by
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
     7
 * the Free Software Foundation; version 2 of the License
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
     8
 *
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
     9
 * This program is distributed in the hope that it will be useful,
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    12
 * GNU General Public License for more details.
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    13
 *
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    14
 * You should have received a copy of the GNU General Public License
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    15
 * along with this program; if not, write to the Free Software
10108
c68cf030eded update FSF address. note: two sdl include files (by Sam Lantinga) still have the old FSF address in their copyright - but I ain't gonna touch their copyright headers
sheepluva
parents: 10105
diff changeset
    16
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    17
 *)
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    18
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    19
{$INCLUDE "options.inc"}
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    20
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    21
unit uGearsUtils;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    22
interface
9285
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
    23
uses uTypes, uFloat;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    24
6986
409dd3851309 add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents: 6888
diff changeset
    25
procedure doMakeExplosion(X, Y, Radius: LongInt; AttackingHog: PHedgehog; Mask: Longword); inline;
8330
aaefa587e277 update branch with default
koda
parents: 8026 8199
diff changeset
    26
procedure doMakeExplosion(X, Y, Radius: LongInt; AttackingHog: PHedgehog; Mask: Longword; const Tint: LongWord);
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
    27
procedure AddSplashForGear(Gear: PGear; justSkipping: boolean);
10508
1a91c1fcba0d add bounce effect to bouncy world edges
sheepluva
parents: 10506
diff changeset
    28
procedure AddBounceEffectForGear(Gear: PGear);
6986
409dd3851309 add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents: 6888
diff changeset
    29
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    30
function  ModifyDamage(dmg: Longword; Gear: PGear): Longword;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    31
procedure ApplyDamage(Gear: PGear; AttackerHog: PHedgehog; Damage: Longword; Source: TDamageSource);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    32
procedure spawnHealthTagForHH(HHGear: PGear; dmg: Longword);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    33
procedure HHHurt(Hedgehog: PHedgehog; Source: TDamageSource);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    34
procedure CheckHHDamage(Gear: PGear);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    35
procedure CalcRotationDirAngle(Gear: PGear);
8947
e906ebd59612 CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents: 8763
diff changeset
    36
procedure ResurrectHedgehog(var gear: PGear);
6986
409dd3851309 add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents: 6888
diff changeset
    37
409dd3851309 add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents: 6888
diff changeset
    38
procedure FindPlace(var Gear: PGear; withFall: boolean; Left, Right: LongInt); inline;
409dd3851309 add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents: 6888
diff changeset
    39
procedure FindPlace(var Gear: PGear; withFall: boolean; Left, Right: LongInt; skipProximity: boolean);
409dd3851309 add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents: 6888
diff changeset
    40
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    41
function  CheckGearNear(Gear: PGear; Kind: TGearType; rX, rY: LongInt): PGear;
8947
e906ebd59612 CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents: 8763
diff changeset
    42
function  CheckGearDrowning(var Gear: PGear): boolean;
7592
cf67e58313ea Move rope code to separate unit
unc0rr
parents: 7509
diff changeset
    43
procedure CheckCollision(Gear: PGear); inline;
cf67e58313ea Move rope code to separate unit
unc0rr
parents: 7509
diff changeset
    44
procedure CheckCollisionWithLand(Gear: PGear); inline;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    45
9285
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
    46
procedure AmmoShove(Ammo: PGear; Damage, Power: LongInt);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
    47
function  GearsNear(X, Y: hwFloat; Kind: TGearType; r: LongInt): PGearArrayS;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
    48
procedure SpawnBoxOfSmth;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
    49
procedure ShotgunShot(Gear: PGear);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
    50
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
    51
procedure SetAllToActive;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
    52
procedure SetAllHHToActive(Ice: boolean);
9954
bf51bc7e2808 - Fix build via pas2c
unc0rr
parents: 9950
diff changeset
    53
procedure SetAllHHToActive(); inline;
9285
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
    54
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
    55
function  GetAmmo(Hedgehog: PHedgehog): TAmmoType;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
    56
function  GetUtility(Hedgehog: PHedgehog): TAmmoType;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
    57
9473
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
    58
function WorldWrap(var Gear: PGear): boolean;
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
    59
9285
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
    60
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
    61
7719
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
    62
function MakeHedgehogsStep(Gear: PGear) : boolean;
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
    63
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    64
var doStepHandlers: array[TGearType] of TGearStepProcedure;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    65
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    66
implementation
9285
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
    67
uses uSound, uCollisions, uUtils, uConsts, uVisualGears, uAIMisc,
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    68
    uVariables, uLandGraphics, uScript, uStats, uCaptions, uTeams, uStore,
10015
4feced261c68 partial merge of the webgl branch
koda
parents: 10012 9954
diff changeset
    69
    uLocale, uTextures, uRenderUtils, uRandom, SDLh, uDebug,
9285
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
    70
    uGearsList, Math, uVisualGearsList, uGearsHandlersMess,
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
    71
    uGearsHedgehog;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    72
6986
409dd3851309 add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents: 6888
diff changeset
    73
procedure doMakeExplosion(X, Y, Radius: LongInt; AttackingHog: PHedgehog; Mask: Longword); inline;
409dd3851309 add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents: 6888
diff changeset
    74
begin
409dd3851309 add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents: 6888
diff changeset
    75
    doMakeExplosion(X, Y, Radius, AttackingHog, Mask, $FFFFFFFF);
409dd3851309 add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents: 6888
diff changeset
    76
end;
409dd3851309 add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents: 6888
diff changeset
    77
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    78
procedure doMakeExplosion(X, Y, Radius: LongInt; AttackingHog: PHedgehog; Mask: Longword; const Tint: LongWord);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    79
var Gear: PGear;
6769
44ad49a3a126 Add drowning to grenade too, try some little optimisations
nemo
parents: 6765
diff changeset
    80
    dmg, dmgBase: LongInt;
6765
8fcd2508c49f bug #336
nemo
parents: 6700
diff changeset
    81
    fX, fY, tdX, tdY: hwFloat;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    82
    vg: PVisualGear;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    83
    i, cnt: LongInt;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    84
begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    85
if Radius > 4 then AddFileLog('Explosion: at (' + inttostr(x) + ',' + inttostr(y) + ')');
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    86
if Radius > 25 then KickFlakes(Radius, X, Y);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    87
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    88
if ((Mask and EXPLNoGfx) = 0) then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    89
    begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    90
    vg:= nil;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    91
    if Radius > 50 then vg:= AddVisualGear(X, Y, vgtBigExplosion)
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    92
    else if Radius > 10 then vg:= AddVisualGear(X, Y, vgtExplosion);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    93
    if vg <> nil then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    94
        vg^.Tint:= Tint;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    95
    end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    96
if (Mask and EXPLAutoSound) <> 0 then PlaySound(sndExplosion);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    97
6765
8fcd2508c49f bug #336
nemo
parents: 6700
diff changeset
    98
(*if (Mask and EXPLAllDamageInRadius) = 0 then
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
    99
    dmgRadius:= Radius shl 1
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   100
else
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   101
    dmgRadius:= Radius;
6765
8fcd2508c49f bug #336
nemo
parents: 6700
diff changeset
   102
dmgBase:= dmgRadius + cHHRadius div 2;*)
8fcd2508c49f bug #336
nemo
parents: 6700
diff changeset
   103
dmgBase:= Radius shl 1 + cHHRadius div 2;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   104
fX:= int2hwFloat(X);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   105
fY:= int2hwFloat(Y);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   106
Gear:= GearsList;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   107
while Gear <> nil do
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   108
    begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   109
    dmg:= 0;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   110
    //dmg:= dmgRadius  + cHHRadius div 2 - hwRound(Distance(Gear^.X - int2hwFloat(X), Gear^.Y - int2hwFloat(Y)));
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   111
    //if (dmg > 1) and
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   112
    if (Gear^.State and gstNoDamage) = 0 then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   113
        begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   114
        case Gear^.Kind of
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   115
            gtHedgehog,
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   116
                gtMine,
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   117
                gtBall,
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   118
                gtMelonPiece,
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   119
                gtGrenade,
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   120
                gtClusterBomb,
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   121
            //    gtCluster, too game breaking I think
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   122
                gtSMine,
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   123
                gtCase,
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   124
                gtTarget,
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   125
                gtFlame,
7754
e81dc9bef8b8 First pass at cleaver.
nemo
parents: 7721
diff changeset
   126
                gtKnife,
8161
0b8beacff8a5 GCI2012: Remove Structure Weapon Code
deepdog
parents: 8007
diff changeset
   127
                gtExplosives: begin //,
0b8beacff8a5 GCI2012: Remove Structure Weapon Code
deepdog
parents: 8007
diff changeset
   128
                //gtStructure: begin
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   129
// Run the calcs only once we know we have a type that will need damage
6765
8fcd2508c49f bug #336
nemo
parents: 6700
diff changeset
   130
                        tdX:= Gear^.X-fX;
8fcd2508c49f bug #336
nemo
parents: 6700
diff changeset
   131
                        tdY:= Gear^.Y-fY;
7721
2b1ad418ba39 - Fix warnings and hints
unc0rr
parents: 7719
diff changeset
   132
                        if LongInt(tdX.Round + tdY.Round + 2) < dmgBase then
7272
71df899c4163 Second part of the change. Make collision check use the new mask bit.
nemo
parents: 7190
diff changeset
   133
                            dmg:= dmgBase - hwRound(Distance(tdX, tdY));
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   134
                        if dmg > 1 then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   135
                            begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   136
                            dmg:= ModifyDamage(min(dmg div 2, Radius), Gear);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   137
                            //AddFileLog('Damage: ' + inttostr(dmg));
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   138
                            if (Mask and EXPLNoDamage) = 0 then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   139
                                begin
10011
ead5e4b21671 Add check for gear kind of hedgehog on invulnerability effect. This probably fixes bug #766, is similar to change in previous r2a1483d91977 and was introduced by r7d925e82e572
nemo
parents: 10010
diff changeset
   140
                                if (Gear^.Kind <> gtHedgehog) or (Gear^.Hedgehog^.Effects[heInvulnerable] = 0) then
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   141
                                    ApplyDamage(Gear, AttackingHog, dmg, dsExplosion)
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   142
                                else
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   143
                                    Gear^.State:= Gear^.State or gstWinner;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   144
                                end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   145
                            if ((Mask and EXPLDoNotTouchAny) = 0) and (((Mask and EXPLDoNotTouchHH) = 0) or (Gear^.Kind <> gtHedgehog)) then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   146
                                begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   147
                                DeleteCI(Gear);
6765
8fcd2508c49f bug #336
nemo
parents: 6700
diff changeset
   148
                                Gear^.dX:= Gear^.dX + SignAs(_0_005 * dmg + cHHKick, tdX)/(Gear^.Density/_3);
8fcd2508c49f bug #336
nemo
parents: 6700
diff changeset
   149
                                Gear^.dY:= Gear^.dY + SignAs(_0_005 * dmg + cHHKick, tdY)/(Gear^.Density/_3);
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   150
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   151
                                Gear^.State:= (Gear^.State or gstMoving) and (not gstLoser);
7767
d1ea9b3f543e damn nots
nemo
parents: 7754
diff changeset
   152
                                if Gear^.Kind = gtKnife then Gear^.State:= Gear^.State and (not gstCollision);
10011
ead5e4b21671 Add check for gear kind of hedgehog on invulnerability effect. This probably fixes bug #766, is similar to change in previous r2a1483d91977 and was introduced by r7d925e82e572
nemo
parents: 10010
diff changeset
   153
                                if (Gear^.Kind = gtHedgehog) and (Gear^.Hedgehog^.Effects[heInvulnerable] = 0) then
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   154
                                    Gear^.State:= (Gear^.State or gstMoving) and (not gstWinner);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   155
                                Gear^.Active:= true;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   156
                                if Gear^.Kind <> gtFlame then FollowGear:= Gear
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   157
                                end;
9685
7d925e82e572 Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects - heInvulnerable is already in effects,
nemo
parents: 9561
diff changeset
   158
                            if ((Mask and EXPLPoisoned) <> 0) and (Gear^.Kind = gtHedgehog) and (Gear^.Hedgehog^.Effects[heInvulnerable] = 0) and (Gear^.State and gstHHDeath = 0) then
10012
82dd9f0c88f7 Make poison damage possibly variable (might as well since effects is a count). Scripts might find it handy.
nemo
parents: 10011
diff changeset
   159
                                Gear^.Hedgehog^.Effects[hePoisoned] := 5;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   160
                            end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   161
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   162
                        end;
9814
c740c865294d Graves should not be kicked for EXPLDoNotTouchAny
nemo
parents: 9809
diff changeset
   163
                gtGrave: if Mask and EXPLDoNotTouchAny = 0 then
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   164
// Run the calcs only once we know we have a type that will need damage
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   165
                            begin
9814
c740c865294d Graves should not be kicked for EXPLDoNotTouchAny
nemo
parents: 9809
diff changeset
   166
                            tdX:= Gear^.X-fX;
c740c865294d Graves should not be kicked for EXPLDoNotTouchAny
nemo
parents: 9809
diff changeset
   167
                            tdY:= Gear^.Y-fY;
c740c865294d Graves should not be kicked for EXPLDoNotTouchAny
nemo
parents: 9809
diff changeset
   168
                            if LongInt(tdX.Round + tdY.Round + 2) < dmgBase then
c740c865294d Graves should not be kicked for EXPLDoNotTouchAny
nemo
parents: 9809
diff changeset
   169
                                dmg:= dmgBase - hwRound(Distance(tdX, tdY));
c740c865294d Graves should not be kicked for EXPLDoNotTouchAny
nemo
parents: 9809
diff changeset
   170
                            if dmg > 1 then
c740c865294d Graves should not be kicked for EXPLDoNotTouchAny
nemo
parents: 9809
diff changeset
   171
                                begin
c740c865294d Graves should not be kicked for EXPLDoNotTouchAny
nemo
parents: 9809
diff changeset
   172
                                dmg:= ModifyDamage(min(dmg div 2, Radius), Gear);
c740c865294d Graves should not be kicked for EXPLDoNotTouchAny
nemo
parents: 9809
diff changeset
   173
                                Gear^.dY:= - _0_004 * dmg;
c740c865294d Graves should not be kicked for EXPLDoNotTouchAny
nemo
parents: 9809
diff changeset
   174
                                Gear^.Active:= true
c740c865294d Graves should not be kicked for EXPLDoNotTouchAny
nemo
parents: 9809
diff changeset
   175
                                end
c740c865294d Graves should not be kicked for EXPLDoNotTouchAny
nemo
parents: 9809
diff changeset
   176
                            end;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   177
            end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   178
        end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   179
    Gear:= Gear^.NextGear
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   180
    end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   181
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   182
if (Mask and EXPLDontDraw) = 0 then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   183
    if (GameFlags and gfSolidLand) = 0 then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   184
        begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   185
        cnt:= DrawExplosion(X, Y, Radius) div 1608; // approx 2 16x16 circles to erase per chunk
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   186
        if (cnt > 0) and (SpritesData[sprChunk].Texture <> nil) then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   187
            for i:= 0 to cnt do
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   188
                AddVisualGear(X, Y, vgtChunk)
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   189
        end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   190
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   191
uAIMisc.AwareOfExplosion(0, 0, 0)
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   192
end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   193
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   194
function ModifyDamage(dmg: Longword; Gear: PGear): Longword;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   195
var i: hwFloat;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   196
begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   197
(* Invulnerability cannot be placed in here due to still needing kicks
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   198
   Not without a new damage machine.
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   199
   King check should be in here instead of ApplyDamage since Tiy wants them kicked less
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   200
*)
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   201
i:= _1;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   202
if (CurrentHedgehog <> nil) and CurrentHedgehog^.King then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   203
    i:= _1_5;
10015
4feced261c68 partial merge of the webgl branch
koda
parents: 10012 9954
diff changeset
   204
if (Gear^.Kind = gtHedgehog) and (Gear^.Hedgehog <> nil) and
10010
2a1483d91977 well. let's fix this at least - only apply to gears that are actually hedgehogs, not just ones associated with a hedgehog (which can be pretty much any gear since damage tracking was added)
nemo
parents: 9998
diff changeset
   205
   (Gear^.Hedgehog^.King or (Gear^.Hedgehog^.Effects[heFrozen] > 0)) then
9148
78c699d8fdfd move 0.01 to the end to avoid increase damage fail on small values like fire. thanks to hedgewars wiki for noting this for fire damage.
nemo
parents: 9080
diff changeset
   206
    ModifyDamage:= hwRound(cDamageModifier * dmg * i * cDamagePercent * _0_5 * _0_01)
9149
6790f1938cd9 update changelog
sheepluva
parents: 9148
diff changeset
   207
else
10526
b43d175d1577 Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents: 10512
diff changeset
   208
    ModifyDamage:= hwRound(cDamageModifier * dmg * i * cDamagePercent * _0_01);
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   209
end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   210
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   211
procedure ApplyDamage(Gear: PGear; AttackerHog: PHedgehog; Damage: Longword; Source: TDamageSource);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   212
var s: shortstring;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   213
    vampDmg, tmpDmg, i: Longword;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   214
    vg: PVisualGear;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   215
begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   216
    if Damage = 0 then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   217
        exit; // nothing to apply
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   218
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   219
    if (Gear^.Kind = gtHedgehog) then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   220
        begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   221
        Gear^.LastDamage := AttackerHog;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   222
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   223
        Gear^.Hedgehog^.Team^.Clan^.Flawless:= false;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   224
        HHHurt(Gear^.Hedgehog, Source);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   225
        AddDamageTag(hwRound(Gear^.X), hwRound(Gear^.Y), Damage, Gear^.Hedgehog^.Team^.Clan^.Color);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   226
        tmpDmg:= min(Damage, max(0,Gear^.Health-Gear^.Damage));
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   227
        if (Gear <> CurrentHedgehog^.Gear) and (CurrentHedgehog^.Gear <> nil) and (tmpDmg >= 1) then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   228
            begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   229
            if cVampiric then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   230
                begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   231
                vampDmg:= hwRound(int2hwFloat(tmpDmg)*_0_8);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   232
                if vampDmg >= 1 then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   233
                    begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   234
                    // was considering pulsing on attack, Tiy thinks it should be permanent while in play
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   235
                    //CurrentHedgehog^.Gear^.State:= CurrentHedgehog^.Gear^.State or gstVampiric;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   236
                    inc(CurrentHedgehog^.Gear^.Health,vampDmg);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   237
                    str(vampDmg, s);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   238
                    s:= '+' + s;
10124
aabd1b75d5a3 Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents: 10116
diff changeset
   239
                    AddCaption(ansistring(s), CurrentHedgehog^.Team^.Clan^.Color, capgrpAmmoinfo);
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   240
                    RenderHealth(CurrentHedgehog^);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   241
                    RecountTeamHealth(CurrentHedgehog^.Team);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   242
                    i:= 0;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   243
                    while i < vampDmg do
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   244
                        begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   245
                        vg:= AddVisualGear(hwRound(CurrentHedgehog^.Gear^.X), hwRound(CurrentHedgehog^.Gear^.Y), vgtStraightShot);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   246
                        if vg <> nil then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   247
                            with vg^ do
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   248
                                begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   249
                                Tint:= $FF0000FF;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   250
                                State:= ord(sprHealth)
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   251
                                end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   252
                        inc(i, 5);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   253
                        end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   254
                    end
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   255
                end;
10015
4feced261c68 partial merge of the webgl branch
koda
parents: 10012 9954
diff changeset
   256
        if (GameFlags and gfKarma <> 0) and (GameFlags and gfInvulnerable = 0) and
9685
7d925e82e572 Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects - heInvulnerable is already in effects,
nemo
parents: 9561
diff changeset
   257
           (CurrentHedgehog^.Effects[heInvulnerable] = 0) then
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   258
            begin // this cannot just use Damage or it interrupts shotgun and gets you called stupid
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   259
            inc(CurrentHedgehog^.Gear^.Karma, tmpDmg);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   260
            CurrentHedgehog^.Gear^.LastDamage := CurrentHedgehog;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   261
            spawnHealthTagForHH(CurrentHedgehog^.Gear, tmpDmg);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   262
            end;
8330
aaefa587e277 update branch with default
koda
parents: 8026 8199
diff changeset
   263
        uStats.HedgehogDamaged(Gear, AttackerHog, Damage, false);
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   264
        end;
10526
b43d175d1577 Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents: 10512
diff changeset
   265
b43d175d1577 Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents: 10512
diff changeset
   266
	if AprilOne and (Gear^.Hedgehog^.Hat = 'fr_tomato') and (Damage > 2) then
b43d175d1577 Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents: 10512
diff changeset
   267
	    for i := 0 to random(min(Damage,20))+5 do
b43d175d1577 Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents: 10512
diff changeset
   268
		begin
b43d175d1577 Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents: 10512
diff changeset
   269
		vg:= AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtStraightShot);
b43d175d1577 Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents: 10512
diff changeset
   270
		if vg <> nil then
b43d175d1577 Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents: 10512
diff changeset
   271
		    with vg^ do
b43d175d1577 Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents: 10512
diff changeset
   272
			begin
b43d175d1577 Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents: 10512
diff changeset
   273
			dx:= 0.001 * (random(100)+10);
b43d175d1577 Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents: 10512
diff changeset
   274
			dy:= 0.001 * (random(100)+10);
b43d175d1577 Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents: 10512
diff changeset
   275
			tdy:= -cGravityf;
b43d175d1577 Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents: 10512
diff changeset
   276
			if random(2) = 0 then
b43d175d1577 Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents: 10512
diff changeset
   277
			    dx := -dx;
b43d175d1577 Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents: 10512
diff changeset
   278
			//if random(2) = 0 then
b43d175d1577 Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents: 10512
diff changeset
   279
			//    dy := -dy;
b43d175d1577 Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents: 10512
diff changeset
   280
			FrameTicks:= random(500) + 1000;
b43d175d1577 Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents: 10512
diff changeset
   281
			State:= ord(sprBubbles);
b43d175d1577 Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents: 10512
diff changeset
   282
			//Tint:= $bd2f03ff
b43d175d1577 Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents: 10512
diff changeset
   283
			Tint:= $ff0000ff
b43d175d1577 Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents: 10512
diff changeset
   284
			end
b43d175d1577 Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents: 10512
diff changeset
   285
	end
8199
886ed135665b Fix crashes and wtf behaviour introduced in r0b8beacff8a5
unc0rr
parents: 8161
diff changeset
   286
    end else
8161
0b8beacff8a5 GCI2012: Remove Structure Weapon Code
deepdog
parents: 8007
diff changeset
   287
    //else if Gear^.Kind <> gtStructure then // not gtHedgehog nor gtStructure
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   288
        Gear^.Hedgehog:= AttackerHog;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   289
    inc(Gear^.Damage, Damage);
8330
aaefa587e277 update branch with default
koda
parents: 8026 8199
diff changeset
   290
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   291
    ScriptCall('onGearDamage', Gear^.UID, Damage);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   292
end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   293
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   294
procedure spawnHealthTagForHH(HHGear: PGear; dmg: Longword);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   295
var tag: PVisualGear;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   296
begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   297
tag:= AddVisualGear(hwRound(HHGear^.X), hwRound(HHGear^.Y), vgtHealthTag, dmg);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   298
if (tag <> nil) then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   299
    tag^.Hedgehog:= HHGear^.Hedgehog; // the tag needs the tag to determine the text color
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   300
AllInactive:= false;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   301
HHGear^.Active:= true;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   302
end;
8330
aaefa587e277 update branch with default
koda
parents: 8026 8199
diff changeset
   303
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   304
procedure HHHurt(Hedgehog: PHedgehog; Source: TDamageSource);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   305
begin
9071
df85fad2c7f7 frozen hog impact. koda says he'll add the beam
nemo
parents: 8992
diff changeset
   306
if Hedgehog^.Effects[heFrozen] <> 0 then exit;
10526
b43d175d1577 Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents: 10512
diff changeset
   307
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   308
if (Source = dsFall) or (Source = dsExplosion) then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   309
    case random(3) of
7053
8c9dcaedc7a8 Make pas2c happier with uSound
unc0rr
parents: 7010
diff changeset
   310
        0: PlaySoundV(sndOoff1, Hedgehog^.Team^.voicepack);
8c9dcaedc7a8 Make pas2c happier with uSound
unc0rr
parents: 7010
diff changeset
   311
        1: PlaySoundV(sndOoff2, Hedgehog^.Team^.voicepack);
8c9dcaedc7a8 Make pas2c happier with uSound
unc0rr
parents: 7010
diff changeset
   312
        2: PlaySoundV(sndOoff3, Hedgehog^.Team^.voicepack);
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   313
    end
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   314
else if (Source = dsPoison) then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   315
    case random(2) of
7053
8c9dcaedc7a8 Make pas2c happier with uSound
unc0rr
parents: 7010
diff changeset
   316
        0: PlaySoundV(sndPoisonCough, Hedgehog^.Team^.voicepack);
8c9dcaedc7a8 Make pas2c happier with uSound
unc0rr
parents: 7010
diff changeset
   317
        1: PlaySoundV(sndPoisonMoan, Hedgehog^.Team^.voicepack);
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   318
    end
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   319
else
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   320
    case random(4) of
7053
8c9dcaedc7a8 Make pas2c happier with uSound
unc0rr
parents: 7010
diff changeset
   321
        0: PlaySoundV(sndOw1, Hedgehog^.Team^.voicepack);
8c9dcaedc7a8 Make pas2c happier with uSound
unc0rr
parents: 7010
diff changeset
   322
        1: PlaySoundV(sndOw2, Hedgehog^.Team^.voicepack);
8c9dcaedc7a8 Make pas2c happier with uSound
unc0rr
parents: 7010
diff changeset
   323
        2: PlaySoundV(sndOw3, Hedgehog^.Team^.voicepack);
8c9dcaedc7a8 Make pas2c happier with uSound
unc0rr
parents: 7010
diff changeset
   324
        3: PlaySoundV(sndOw4, Hedgehog^.Team^.voicepack);
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   325
    end
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   326
end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   327
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   328
procedure CheckHHDamage(Gear: PGear);
10015
4feced261c68 partial merge of the webgl branch
koda
parents: 10012 9954
diff changeset
   329
var
9809
1e32628eb167 Fix warnings
unC0Rr
parents: 9706
diff changeset
   330
    dmg: LongInt;
8003
7d8bce524daf LongInt Land width/height, mouse coords
nemo
parents: 7825
diff changeset
   331
    i: LongWord;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   332
    particle: PVisualGear;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   333
begin
9071
df85fad2c7f7 frozen hog impact. koda says he'll add the beam
nemo
parents: 8992
diff changeset
   334
if _0_4 < Gear^.dY then
df85fad2c7f7 frozen hog impact. koda says he'll add the beam
nemo
parents: 8992
diff changeset
   335
    begin
df85fad2c7f7 frozen hog impact. koda says he'll add the beam
nemo
parents: 8992
diff changeset
   336
    dmg := ModifyDamage(1 + hwRound((Gear^.dY - _0_4) * 70), Gear);
df85fad2c7f7 frozen hog impact. koda says he'll add the beam
nemo
parents: 8992
diff changeset
   337
    if Gear^.Hedgehog^.Effects[heFrozen] = 0 then
df85fad2c7f7 frozen hog impact. koda says he'll add the beam
nemo
parents: 8992
diff changeset
   338
         PlaySound(sndBump)
df85fad2c7f7 frozen hog impact. koda says he'll add the beam
nemo
parents: 8992
diff changeset
   339
    else PlaySound(sndFrozenHogImpact);
df85fad2c7f7 frozen hog impact. koda says he'll add the beam
nemo
parents: 8992
diff changeset
   340
    if dmg < 1 then
df85fad2c7f7 frozen hog impact. koda says he'll add the beam
nemo
parents: 8992
diff changeset
   341
        exit;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   342
9809
1e32628eb167 Fix warnings
unC0Rr
parents: 9706
diff changeset
   343
    for i:= min(12, 3 + dmg div 10) downto 0 do
9071
df85fad2c7f7 frozen hog impact. koda says he'll add the beam
nemo
parents: 8992
diff changeset
   344
        begin
df85fad2c7f7 frozen hog impact. koda says he'll add the beam
nemo
parents: 8992
diff changeset
   345
        particle := AddVisualGear(hwRound(Gear^.X) - 5 + Random(10), hwRound(Gear^.Y) + 12, vgtDust);
df85fad2c7f7 frozen hog impact. koda says he'll add the beam
nemo
parents: 8992
diff changeset
   346
        if particle <> nil then
df85fad2c7f7 frozen hog impact. koda says he'll add the beam
nemo
parents: 8992
diff changeset
   347
            particle^.dX := particle^.dX + (Gear^.dX.QWordValue / 21474836480);
df85fad2c7f7 frozen hog impact. koda says he'll add the beam
nemo
parents: 8992
diff changeset
   348
        end;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   349
9685
7d925e82e572 Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects - heInvulnerable is already in effects,
nemo
parents: 9561
diff changeset
   350
    if ((Gear^.Hedgehog^.Effects[heInvulnerable] <> 0)) then
9071
df85fad2c7f7 frozen hog impact. koda says he'll add the beam
nemo
parents: 8992
diff changeset
   351
        exit;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   352
9071
df85fad2c7f7 frozen hog impact. koda says he'll add the beam
nemo
parents: 8992
diff changeset
   353
    //if _0_6 < Gear^.dY then
df85fad2c7f7 frozen hog impact. koda says he'll add the beam
nemo
parents: 8992
diff changeset
   354
    //    PlaySound(sndOw4, Gear^.Hedgehog^.Team^.voicepack)
df85fad2c7f7 frozen hog impact. koda says he'll add the beam
nemo
parents: 8992
diff changeset
   355
    //else
df85fad2c7f7 frozen hog impact. koda says he'll add the beam
nemo
parents: 8992
diff changeset
   356
    //    PlaySound(sndOw1, Gear^.Hedgehog^.Team^.voicepack);
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   357
9071
df85fad2c7f7 frozen hog impact. koda says he'll add the beam
nemo
parents: 8992
diff changeset
   358
    if Gear^.LastDamage <> nil then
df85fad2c7f7 frozen hog impact. koda says he'll add the beam
nemo
parents: 8992
diff changeset
   359
        ApplyDamage(Gear, Gear^.LastDamage, dmg, dsFall)
df85fad2c7f7 frozen hog impact. koda says he'll add the beam
nemo
parents: 8992
diff changeset
   360
    else
df85fad2c7f7 frozen hog impact. koda says he'll add the beam
nemo
parents: 8992
diff changeset
   361
        ApplyDamage(Gear, CurrentHedgehog, dmg, dsFall);
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   362
    end
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   363
end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   364
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   365
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   366
procedure CalcRotationDirAngle(Gear: PGear);
8330
aaefa587e277 update branch with default
koda
parents: 8026 8199
diff changeset
   367
var
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   368
    dAngle: real;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   369
begin
7825
1b96361a7ef4 issue #445 spin math
nemo
parents: 7767
diff changeset
   370
    // Frac/Round to be kind to JS as of 2012-08-27 where there is yet no int64/uint64
1b96361a7ef4 issue #445 spin math
nemo
parents: 7767
diff changeset
   371
    //dAngle := (Gear^.dX.QWordValue + Gear^.dY.QWordValue) / $80000000;
1b96361a7ef4 issue #445 spin math
nemo
parents: 7767
diff changeset
   372
    dAngle := (Gear^.dX.Round + Gear^.dY.Round) / 2 + (Gear^.dX.Frac/$100000000+Gear^.dY.Frac/$100000000);
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   373
    if not Gear^.dX.isNegative then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   374
        Gear^.DirAngle := Gear^.DirAngle + dAngle
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   375
    else
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   376
        Gear^.DirAngle := Gear^.DirAngle - dAngle;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   377
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   378
    if Gear^.DirAngle < 0 then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   379
        Gear^.DirAngle := Gear^.DirAngle + 360
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   380
    else if 360 < Gear^.DirAngle then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   381
        Gear^.DirAngle := Gear^.DirAngle - 360
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   382
end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   383
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   384
procedure AddSplashForGear(Gear: PGear; justSkipping: boolean);
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   385
var x, y, i, distL, distR, distB, minDist, maxDrops: LongInt;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   386
    splash, particle: PVisualGear;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   387
    speed, hwTmp: hwFloat;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   388
    vi, vs, tmp: real; // impact speed and sideways speed
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   389
    isImpactH, isImpactRight: boolean;
10419
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   390
const dist2surf = 4;
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   391
begin
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   392
x:= hwRound(Gear^.X);
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   393
y:= hwRound(Gear^.Y);
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   394
10419
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   395
// find position for splash and impact speed
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   396
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   397
distB:= cWaterline - y;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   398
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   399
if WorldEdge <> weSea then
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   400
    minDist:= distB
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   401
else
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   402
    begin
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   403
    distL:= x - leftX;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   404
    distR:= rightX - x;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   405
    minDist:= min(distB, min(distL, distR));
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   406
    end;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   407
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   408
isImpactH:= (minDist <> distB);
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   409
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   410
if not isImpactH then
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   411
    begin
10417
8f66bb4dbf80 tweak splash position
sheepluva
parents: 10363
diff changeset
   412
    y:= cWaterline - dist2surf;
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   413
    speed:= hwAbs(Gear^.dY);
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   414
    end
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   415
else
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   416
    begin
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   417
    isImpactRight := minDist = distR;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   418
    if isImpactRight then
10419
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   419
        x:= rightX - dist2surf
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   420
    else
10419
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   421
        x:= leftX + dist2surf;
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   422
    speed:= hwAbs(Gear^.dX);
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   423
    end;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   424
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   425
// splash sound
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   426
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   427
if justSkipping then
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   428
    PlaySound(sndSkip)
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   429
else
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   430
    begin
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   431
    // adjust water impact sound based on gear speed and density
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   432
    hwTmp:= hwAbs(Gear^.Density * speed);
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   433
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   434
    if hwTmp > _1 then
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   435
        PlaySound(sndSplash)
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   436
    else if hwTmp > _0_5 then
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   437
        PlaySound(sndSkip)
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   438
    else
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   439
        PlaySound(sndDroplet2);
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   440
    end;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   441
10419
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   442
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   443
// splash visuals
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   444
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   445
if ((cReducedQuality and rqPlainSplash) <> 0) then
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   446
    exit;
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   447
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   448
splash:= AddVisualGear(x, y, vgtSplash);
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   449
if splash = nil then
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   450
    exit;
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   451
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   452
if not isImpactH then
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   453
    vs:= abs(hwFloat2Float(Gear^.dX))
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   454
else
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   455
    begin
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   456
    if isImpactRight then
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   457
        splash^.Angle:= -90
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   458
    else
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   459
        splash^.Angle:=  90;
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   460
    vs:= abs(hwFloat2Float(Gear^.dY));
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   461
    end;
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   462
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   463
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   464
vi:= hwFloat2Float(speed);
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   465
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   466
with splash^ do
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   467
    begin
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   468
    Scale:= abs(hwFloat2Float(Gear^.Density / _3 * speed));
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   469
    if Scale > 1 then Scale:= power(Scale,0.3333)
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   470
    else Scale:= Scale + ((1-Scale) / 2);
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   471
    if Scale > 1 then Timer:= round(min(Scale*0.0005/cGravityf,4))
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   472
    else Timer:= 1;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   473
    // Low Gravity
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   474
    FrameTicks:= FrameTicks*Timer;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   475
    end;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   476
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   477
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   478
// eject water drops
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   479
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   480
maxDrops := (hwRound(Gear^.Density) * 3) div 2 + round((vi + vs) * hwRound(Gear^.Density) * 6);
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   481
for i:= max(maxDrops div 3, min(32, Random(maxDrops))) downto 0 do
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   482
    begin
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   483
    if isImpactH then
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   484
        particle := AddVisualGear(x, y - 3 + Random(7), vgtDroplet)
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   485
    else
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   486
        particle := AddVisualGear(x - 3 + Random(7), y, vgtDroplet);
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   487
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   488
    if particle <> nil then
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   489
        with particle^ do
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   490
            begin
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   491
            // dX and dY were initialized to have a random value on creation (see uVisualGearsList)
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   492
            if isImpactH then
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   493
                begin
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   494
                tmp:= dX;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   495
                if isImpactRight then
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   496
                    dX:=  dY - vi / 5
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   497
                else
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   498
                    dX:= -dy + vi / 5;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   499
                dY:= tmp * (1 + vs / 10);
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   500
                end
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   501
            else
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   502
                begin
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   503
                dX:= dX * (1 + vs / 10);
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   504
                dY:= dY - vi / 5;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   505
                end;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   506
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   507
            if splash <> nil then
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   508
                begin
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   509
                if splash^.Scale > 1 then
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   510
                    begin
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   511
                    dX:= dX * power(splash^.Scale, 0.3333); // tone down the droplet height further
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   512
                    dY:= dY * power(splash^.Scale, 0.3333);
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   513
                    end
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   514
                else
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   515
                    begin
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   516
                    dX:= dX * splash^.Scale;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   517
                    dY:= dY * splash^.Scale;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   518
                    end;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   519
                end;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   520
            end
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   521
    end;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   522
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   523
end;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   524
10354
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   525
procedure DrownGear(Gear: PGear);
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   526
begin
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   527
Gear^.doStep := @doStepDrowningGear;
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   528
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   529
Gear^.Timer := 5000; // how long game should wait
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   530
end;
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   531
8947
e906ebd59612 CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents: 8763
diff changeset
   532
function CheckGearDrowning(var Gear: PGear): boolean;
10015
4feced261c68 partial merge of the webgl branch
koda
parents: 10012 9954
diff changeset
   533
var
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   534
    skipSpeed, skipAngle, skipDecay: hwFloat;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   535
    tmp, X, Y, dist2Water: LongInt;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   536
    isSubmersible, isDirH, isImpact, isSkip: boolean;
10124
aabd1b75d5a3 Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents: 10116
diff changeset
   537
    s: ansistring;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   538
begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   539
    // probably needs tweaking. might need to be in a case statement based upon gear type
10354
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   540
    X:= hwRound(Gear^.X);
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   541
    Y:= hwRound(Gear^.Y);
10354
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   542
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   543
    dist2Water:= cWaterLine - (Y + Gear^.Radius);
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   544
    isDirH:= false;
10354
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   545
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   546
    if WorldEdge = weSea then
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   547
        begin
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   548
        tmp:= dist2Water;
10494
0eb97cf4c78e Fix warnings given by 32-bit fpc
unC0Rr
parents: 10419
diff changeset
   549
        dist2Water:= min(dist2Water, min(X - Gear^.Radius - LongInt(leftX), LongInt(rightX) - (X + Gear^.Radius)));
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   550
        // if water on sides is closer than on bottom -> horizontal direction
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   551
        isDirH:= tmp <> dist2Water;
10354
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   552
        end;
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   553
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   554
    isImpact:= false;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   555
10354
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   556
    if dist2Water < 0 then
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   557
        begin
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   558
        // invisible gears will just be deleted
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   559
        // unless they are generic fallers, then they will be "respawned"
7389
15c3fb4882df Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents: 7372
diff changeset
   560
        if Gear^.State and gstInvisible <> 0 then
15c3fb4882df Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents: 7372
diff changeset
   561
            begin
7406
1fe2c821f9bf Try avoiding spamming the log by retaining the gears. untested.
nemo
parents: 7389
diff changeset
   562
            if Gear^.Kind = gtGenericFaller then
1fe2c821f9bf Try avoiding spamming the log by retaining the gears. untested.
nemo
parents: 7389
diff changeset
   563
                begin
1fe2c821f9bf Try avoiding spamming the log by retaining the gears. untested.
nemo
parents: 7389
diff changeset
   564
                Gear^.X:= int2hwFloat(GetRandom(rightX-leftX)+leftX);
1fe2c821f9bf Try avoiding spamming the log by retaining the gears. untested.
nemo
parents: 7389
diff changeset
   565
                Gear^.Y:= int2hwFloat(GetRandom(LAND_HEIGHT-topY)+topY);
1fe2c821f9bf Try avoiding spamming the log by retaining the gears. untested.
nemo
parents: 7389
diff changeset
   566
                Gear^.dX:= _90-(GetRandomf*_360);
1fe2c821f9bf Try avoiding spamming the log by retaining the gears. untested.
nemo
parents: 7389
diff changeset
   567
                Gear^.dY:= _90-(GetRandomf*_360)
1fe2c821f9bf Try avoiding spamming the log by retaining the gears. untested.
nemo
parents: 7389
diff changeset
   568
                end
1fe2c821f9bf Try avoiding spamming the log by retaining the gears. untested.
nemo
parents: 7389
diff changeset
   569
            else DeleteGear(Gear);
10245
3ccc054c3c3e Fix some pas2c engine warnings
unc0rr
parents: 10160
diff changeset
   570
            exit(true)
7389
15c3fb4882df Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents: 7372
diff changeset
   571
            end;
8992
5b0be812dcdb Rename submersible state, increase getaway time for attack underwater, slow down gear dx/dy underwater to simulate water resistance
nemo
parents: 8991
diff changeset
   572
        isSubmersible:= ((Gear = CurrentHedgehog^.Gear) and (CurAmmoGear <> nil) and (CurAmmoGear^.State and gstSubmersible <> 0)) or (Gear^.State and gstSubmersible <> 0);
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   573
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   574
        skipSpeed := _0_25;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   575
        skipAngle := _1_9;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   576
        skipDecay := _0_87;
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   577
10354
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   578
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   579
        // skipping
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   580
10512
25021aac078e fix underwater-skipping bug and make air-strike missiles submersible when fired from within weSea
sheepluva
parents: 10508
diff changeset
   581
        if (not isSubmersible) and (hwSqr(Gear^.dX) + hwSqr(Gear^.dY) > skipSpeed)
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   582
        and ( ((not isDirH) and (hwAbs(Gear^.dX) > skipAngle * hwAbs(Gear^.dY)))
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   583
          or (isDirH and (hwAbs(Gear^.dY) > skipAngle * hwAbs(Gear^.dX))) ) then
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   584
            begin
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   585
            isSkip:= true;
10354
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   586
            // if skipping we move the gear out of water
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   587
            if isDirH then
10354
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   588
                begin
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   589
                Gear^.dX.isNegative := (not Gear^.dX.isNegative);
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   590
                Gear^.X:= Gear^.X + Gear^.dX;
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   591
                end
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   592
            else
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   593
                begin
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   594
                Gear^.dY.isNegative := (not Gear^.dY.isNegative);
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   595
                Gear^.Y:= Gear^.Y + Gear^.dY;
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   596
                end;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   597
            Gear^.dY := Gear^.dY * skipDecay;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   598
            Gear^.dX := Gear^.dX * skipDecay;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   599
            CheckGearDrowning := false;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   600
            end
10354
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   601
        else // not skipping
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   602
            begin
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   603
            isImpact:= true;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   604
            isSkip:= false;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   605
            if not isSubmersible then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   606
                begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   607
                CheckGearDrowning := true;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   608
                Gear^.State := gstDrowning;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   609
                Gear^.RenderTimer := false;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   610
                if (Gear^.Kind <> gtSniperRifleShot) and (Gear^.Kind <> gtShotgunShot)
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   611
                and (Gear^.Kind <> gtDEagleShot) and (Gear^.Kind <> gtSineGunShot) then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   612
                    if Gear^.Kind = gtHedgehog then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   613
                        begin
7010
10a0a31804f3 Switch effects to longint for convenience of tracking ice states. I could add a new Hedgehog value, but since we have this effects list being all useless as booleans anyway...
nemo
parents: 6990
diff changeset
   614
                        if Gear^.Hedgehog^.Effects[heResurrectable] <> 0 then
8947
e906ebd59612 CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents: 8763
diff changeset
   615
                            begin
e906ebd59612 CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents: 8763
diff changeset
   616
                            // Gear could become nil after this, just exit to skip splashes
e906ebd59612 CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents: 8763
diff changeset
   617
                            ResurrectHedgehog(Gear);
10245
3ccc054c3c3e Fix some pas2c engine warnings
unc0rr
parents: 10160
diff changeset
   618
                            exit(true)
8947
e906ebd59612 CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents: 8763
diff changeset
   619
                            end
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   620
                        else
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   621
                            begin
10354
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   622
                            DrownGear(Gear);
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   623
                            Gear^.State := Gear^.State and (not gstHHDriven);
10124
aabd1b75d5a3 Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents: 10116
diff changeset
   624
                            s:= ansistring(Gear^.Hedgehog^.Name);
aabd1b75d5a3 Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents: 10116
diff changeset
   625
                            AddCaption(FormatA(GetEventString(eidDrowned), s), cWhiteColor, capgrpMessage);
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   626
                            end
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   627
                        end
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   628
                    else
10354
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   629
                        DrownGear(Gear);
10419
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   630
                    if Gear^.Kind = gtFlake then
10354
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   631
                        exit(true); // skip splashes
8990
e64a1a851b69 more drowning fixes
nemo
parents: 8989
diff changeset
   632
                end
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   633
            else // submersible
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   634
                begin
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   635
                // drown submersible grears if far below map
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   636
                if (Y > cWaterLine + cVisibleWater*4) then
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   637
                    begin
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   638
                    DrownGear(Gear);
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   639
                    exit(true); // no splashes needed
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   640
                    end;
10354
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   641
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   642
                CheckGearDrowning := false;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   643
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   644
                // check if surface was penetrated
10354
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   645
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   646
                // no penetration if center's water distance not smaller than radius
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   647
                if  abs(dist2Water + Gear^.Radius) >= Gear^.Radius then
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   648
                    isImpact:= false
6804
06bedc419d04 Try different splash sounds too
nemo
parents: 6803
diff changeset
   649
                else
10354
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   650
                    begin
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   651
                    // get distance to water of last tick
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   652
                    if isDirH then
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   653
                        begin
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   654
                        tmp:= hwRound(Gear^.X - Gear^.dX);
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   655
                        tmp:= abs(min(tmp - leftX, rightX - tmp));
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   656
                        end
10354
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   657
                    else
6803
0e70f3ea3bf8 bit of an experiment in variable splash sizes based on object/speed. not sure if it looks good yet. need to drown more stuff.
nemo
parents: 6769
diff changeset
   658
                        begin
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   659
                        tmp:= hwRound(Gear^.Y - Gear^.dY);
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   660
                        tmp:= abs(cWaterLine - tmp);
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   661
                        end;
10354
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
   662
10419
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   663
                    // there was an impact if distance was >= radius
e19a864e2fab some more splash code tweaking/fixing
sheepluva
parents: 10417
diff changeset
   664
                    isImpact:= (tmp >= Gear^.Radius)
10363
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   665
                    end;
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   666
                end; // end of submersible
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   667
            end; // end of not skipping
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   668
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   669
        // splash sound animation and droplets
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   670
        if isImpact or isSkip then
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   671
            addSplashForGear(Gear, isSkip);
fc3aa563ab01 drowning tweaks
sheepluva
parents: 10356
diff changeset
   672
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   673
        end
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   674
    else
9473
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
   675
        begin
9521
8054d9d775fd merge with latest defaul, fixing compiling with fpc, parsing and rendering with pas2c, some minor problems with compiling with clang
koda
parents: 9160 9489
diff changeset
   676
        if (not ((Gear^.Kind = gtJetpack) or (Gear^.Kind = gtBee))) then
8054d9d775fd merge with latest defaul, fixing compiling with fpc, parsing and rendering with pas2c, some minor problems with compiling with clang
koda
parents: 9160 9489
diff changeset
   677
            Gear^.State:= (Gear^.State and (not gstSubmersible));  // making it temporary for most gears is more attractive I think
9473
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
   678
        CheckGearDrowning := false
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
   679
        end
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   680
end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   681
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   682
8947
e906ebd59612 CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents: 8763
diff changeset
   683
procedure ResurrectHedgehog(var gear: PGear);
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   684
var tempTeam : PTeam;
7092
c9ca770fd7fc Add an emergency return to the timebox in the case of death of rest of team. Also add a small visual effect to AI survival
nemo
parents: 7066
diff changeset
   685
    sparkles: PVisualGear;
c9ca770fd7fc Add an emergency return to the timebox in the case of death of rest of team. Also add a small visual effect to AI survival
nemo
parents: 7066
diff changeset
   686
    gX, gY: LongInt;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   687
begin
7357
06454899d0d2 Score AI resurrection as a kill. These values will not be the same as the in-game scoring, since in-game scoring doesn't count friendlies.
nemo
parents: 7272
diff changeset
   688
    if (Gear^.LastDamage <> nil) then
06454899d0d2 Score AI resurrection as a kill. These values will not be the same as the in-game scoring, since in-game scoring doesn't count friendlies.
nemo
parents: 7272
diff changeset
   689
        uStats.HedgehogDamaged(Gear, Gear^.LastDamage, 0, true)
06454899d0d2 Score AI resurrection as a kill. These values will not be the same as the in-game scoring, since in-game scoring doesn't count friendlies.
nemo
parents: 7272
diff changeset
   690
    else
06454899d0d2 Score AI resurrection as a kill. These values will not be the same as the in-game scoring, since in-game scoring doesn't count friendlies.
nemo
parents: 7272
diff changeset
   691
        uStats.HedgehogDamaged(Gear, CurrentHedgehog, 0, true);
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   692
    AttackBar:= 0;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   693
    gear^.dX := _0;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   694
    gear^.dY := _0;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   695
    gear^.Damage := 0;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   696
    gear^.Health := gear^.Hedgehog^.InitialHealth;
7010
10a0a31804f3 Switch effects to longint for convenience of tracking ice states. I could add a new Hedgehog value, but since we have this effects list being all useless as booleans anyway...
nemo
parents: 6990
diff changeset
   697
    gear^.Hedgehog^.Effects[hePoisoned] := 0;
7176
fb4b0c6dfdbd Make watching AI v AI on ai survival a bit more entertaining
nemo
parents: 7168
diff changeset
   698
    if (CurrentHedgehog^.Effects[heResurrectable] = 0) or ((CurrentHedgehog^.Effects[heResurrectable] <> 0)
fb4b0c6dfdbd Make watching AI v AI on ai survival a bit more entertaining
nemo
parents: 7168
diff changeset
   699
          and (Gear^.Hedgehog^.Team^.Clan <> CurrentHedgehog^.Team^.Clan)) then
8330
aaefa587e277 update branch with default
koda
parents: 8026 8199
diff changeset
   700
        with CurrentHedgehog^ do
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   701
            begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   702
            inc(Team^.stats.AIKills);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   703
            FreeTexture(Team^.AIKillsTex);
10124
aabd1b75d5a3 Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents: 10116
diff changeset
   704
            Team^.AIKillsTex := RenderStringTex(ansistring(inttostr(Team^.stats.AIKills)), Team^.Clan^.Color, fnt16);
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   705
            end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   706
    tempTeam := gear^.Hedgehog^.Team;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   707
    DeleteCI(gear);
7092
c9ca770fd7fc Add an emergency return to the timebox in the case of death of rest of team. Also add a small visual effect to AI survival
nemo
parents: 7066
diff changeset
   708
    gX := hwRound(gear^.X);
c9ca770fd7fc Add an emergency return to the timebox in the case of death of rest of team. Also add a small visual effect to AI survival
nemo
parents: 7066
diff changeset
   709
    gY := hwRound(gear^.Y);
c9ca770fd7fc Add an emergency return to the timebox in the case of death of rest of team. Also add a small visual effect to AI survival
nemo
parents: 7066
diff changeset
   710
    // might need more sparkles for a column
c9ca770fd7fc Add an emergency return to the timebox in the case of death of rest of team. Also add a small visual effect to AI survival
nemo
parents: 7066
diff changeset
   711
    sparkles:= AddVisualGear(gX, gY, vgtDust, 1);
c9ca770fd7fc Add an emergency return to the timebox in the case of death of rest of team. Also add a small visual effect to AI survival
nemo
parents: 7066
diff changeset
   712
    if sparkles <> nil then
c9ca770fd7fc Add an emergency return to the timebox in the case of death of rest of team. Also add a small visual effect to AI survival
nemo
parents: 7066
diff changeset
   713
        begin
c9ca770fd7fc Add an emergency return to the timebox in the case of death of rest of team. Also add a small visual effect to AI survival
nemo
parents: 7066
diff changeset
   714
        sparkles^.Tint:= tempTeam^.Clan^.Color shl 8 or $FF;
c9ca770fd7fc Add an emergency return to the timebox in the case of death of rest of team. Also add a small visual effect to AI survival
nemo
parents: 7066
diff changeset
   715
        //sparkles^.Angle:= random(360);
c9ca770fd7fc Add an emergency return to the timebox in the case of death of rest of team. Also add a small visual effect to AI survival
nemo
parents: 7066
diff changeset
   716
        end;
8330
aaefa587e277 update branch with default
koda
parents: 8026 8199
diff changeset
   717
    FindPlace(gear, false, 0, LAND_WIDTH, true);
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   718
    if gear <> nil then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   719
        begin
7092
c9ca770fd7fc Add an emergency return to the timebox in the case of death of rest of team. Also add a small visual effect to AI survival
nemo
parents: 7066
diff changeset
   720
        AddVisualGear(hwRound(gear^.X), hwRound(gear^.Y), vgtExplosion);
7168
8defaabce92e warp sound when AI survival hog respawns. attempt at a bit of a crate spawn animation (moar sparkles and a quick fadein)
nemo
parents: 7092
diff changeset
   721
        PlaySound(sndWarp);
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   722
        RenderHealth(gear^.Hedgehog^);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   723
        ScriptCall('onGearResurrect', gear^.uid);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   724
        gear^.State := gstWait;
8947
e906ebd59612 CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents: 8763
diff changeset
   725
        end;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   726
    RecountTeamHealth(tempTeam);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   727
end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   728
7190
aa8d68817c32 Make it AI survival almost definitely impossible by adding a 3rd pass to FindGear. 1st pass normal, 2nd pass allow close to objects, 3rd pass, allow overlapping objects.
nemo
parents: 7176
diff changeset
   729
function CountNonZeroz(x, y, r, c: LongInt; mask: LongWord): LongInt;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   730
var i: LongInt;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   731
    count: LongInt = 0;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   732
begin
6990
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6986
diff changeset
   733
    if (y and LAND_HEIGHT_MASK) = 0 then
10272
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   734
        for i:= max(x - r, 0) to min(x + r, LAND_WIDTH - 1) do
7190
aa8d68817c32 Make it AI survival almost definitely impossible by adding a 3rd pass to FindGear. 1st pass normal, 2nd pass allow close to objects, 3rd pass, allow overlapping objects.
nemo
parents: 7176
diff changeset
   735
            if Land[y, i] and mask <> 0 then
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   736
            begin
6990
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6986
diff changeset
   737
                inc(count);
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6986
diff changeset
   738
                if count = c then
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6986
diff changeset
   739
                begin
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6986
diff changeset
   740
                    CountNonZeroz:= count;
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6986
diff changeset
   741
                    exit
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6986
diff changeset
   742
                end;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   743
            end;
6990
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6986
diff changeset
   744
    CountNonZeroz:= count;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   745
end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   746
10272
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   747
function isSteadyPosition(x, y, r, c: LongInt; mask: Longword): boolean;
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   748
var cnt, i: LongInt;
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   749
begin
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   750
    cnt:= 0;
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   751
    isSteadyPosition:= false;
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   752
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   753
    if ((y and LAND_HEIGHT_MASK) = 0) and (x - r >= 0) and (x + r < LAND_WIDTH) then
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   754
    begin
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   755
        for i:= r - c + 2 to r do
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   756
        begin
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   757
            if (Land[y, x - i] and mask <> 0) then inc(cnt);
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   758
            if (Land[y, x + i] and mask <> 0) then inc(cnt);
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   759
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   760
            if cnt >= c then
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   761
            begin
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   762
                isSteadyPosition:= true;
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   763
                exit
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   764
            end;
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   765
        end;
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   766
    end;
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   767
end;
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   768
6888
32a54322d262 Get rid of TGearsType to simplify pas2c
unc0rr
parents: 6804
diff changeset
   769
32a54322d262 Get rid of TGearsType to simplify pas2c
unc0rr
parents: 6804
diff changeset
   770
function NoGearsToAvoid(mX, mY: LongInt; rX, rY: LongInt): boolean;
32a54322d262 Get rid of TGearsType to simplify pas2c
unc0rr
parents: 6804
diff changeset
   771
var t: PGear;
32a54322d262 Get rid of TGearsType to simplify pas2c
unc0rr
parents: 6804
diff changeset
   772
begin
6990
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6986
diff changeset
   773
NoGearsToAvoid:= false;
6888
32a54322d262 Get rid of TGearsType to simplify pas2c
unc0rr
parents: 6804
diff changeset
   774
t:= GearsList;
32a54322d262 Get rid of TGearsType to simplify pas2c
unc0rr
parents: 6804
diff changeset
   775
rX:= sqr(rX);
32a54322d262 Get rid of TGearsType to simplify pas2c
unc0rr
parents: 6804
diff changeset
   776
rY:= sqr(rY);
32a54322d262 Get rid of TGearsType to simplify pas2c
unc0rr
parents: 6804
diff changeset
   777
while t <> nil do
32a54322d262 Get rid of TGearsType to simplify pas2c
unc0rr
parents: 6804
diff changeset
   778
    begin
32a54322d262 Get rid of TGearsType to simplify pas2c
unc0rr
parents: 6804
diff changeset
   779
    if t^.Kind <= gtExplosives then
32a54322d262 Get rid of TGearsType to simplify pas2c
unc0rr
parents: 6804
diff changeset
   780
        if not (hwSqr(int2hwFloat(mX) - t^.X) / rX + hwSqr(int2hwFloat(mY) - t^.Y) / rY > _1) then
6990
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6986
diff changeset
   781
            exit;
6888
32a54322d262 Get rid of TGearsType to simplify pas2c
unc0rr
parents: 6804
diff changeset
   782
    t:= t^.NextGear
32a54322d262 Get rid of TGearsType to simplify pas2c
unc0rr
parents: 6804
diff changeset
   783
    end;
32a54322d262 Get rid of TGearsType to simplify pas2c
unc0rr
parents: 6804
diff changeset
   784
NoGearsToAvoid:= true
32a54322d262 Get rid of TGearsType to simplify pas2c
unc0rr
parents: 6804
diff changeset
   785
end;
32a54322d262 Get rid of TGearsType to simplify pas2c
unc0rr
parents: 6804
diff changeset
   786
6986
409dd3851309 add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents: 6888
diff changeset
   787
procedure FindPlace(var Gear: PGear; withFall: boolean; Left, Right: LongInt); inline;
409dd3851309 add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents: 6888
diff changeset
   788
begin
409dd3851309 add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents: 6888
diff changeset
   789
    FindPlace(Gear, withFall, Left, Right, false);
409dd3851309 add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents: 6888
diff changeset
   790
end;
6888
32a54322d262 Get rid of TGearsType to simplify pas2c
unc0rr
parents: 6804
diff changeset
   791
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   792
procedure FindPlace(var Gear: PGear; withFall: boolean; Left, Right: LongInt; skipProximity: boolean);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   793
var x: LongInt;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   794
    y, sy: LongInt;
8007
b07ce9dfc6bb Make FindPlace more flexible on large maps.
nemo
parents: 8003
diff changeset
   795
    ar: array[0..1023] of TPoint;
b07ce9dfc6bb Make FindPlace more flexible on large maps.
nemo
parents: 8003
diff changeset
   796
    ar2: array[0..2047] of TPoint;
8026
4a4f21070479 merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents: 8007
diff changeset
   797
    temp: TPoint;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   798
    cnt, cnt2: Longword;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   799
    delta: LongInt;
7190
aa8d68817c32 Make it AI survival almost definitely impossible by adding a 3rd pass to FindGear. 1st pass normal, 2nd pass allow close to objects, 3rd pass, allow overlapping objects.
nemo
parents: 7176
diff changeset
   800
    ignoreNearObjects, ignoreOverlap, tryAgain: boolean;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   801
begin
7190
aa8d68817c32 Make it AI survival almost definitely impossible by adding a 3rd pass to FindGear. 1st pass normal, 2nd pass allow close to objects, 3rd pass, allow overlapping objects.
nemo
parents: 7176
diff changeset
   802
ignoreNearObjects:= false; // try not skipping proximity at first
aa8d68817c32 Make it AI survival almost definitely impossible by adding a 3rd pass to FindGear. 1st pass normal, 2nd pass allow close to objects, 3rd pass, allow overlapping objects.
nemo
parents: 7176
diff changeset
   803
ignoreOverlap:= false; // this not only skips proximity, but allows overlapping objects (barrels, mines, hogs, crates).  Saving it for a 3rd pass.  With this active, winning AI Survival goes back to virtual impossibility
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   804
tryAgain:= true;
10015
4feced261c68 partial merge of the webgl branch
koda
parents: 10012 9954
diff changeset
   805
if WorldEdge <> weNone then
9477
0463f747e839 Make a few more gears honour world edge checks
nemo
parents: 9473
diff changeset
   806
    begin
9809
1e32628eb167 Fix warnings
unC0Rr
parents: 9706
diff changeset
   807
    Left:= max(Left, LongInt(leftX) + Gear^.Radius);
9477
0463f747e839 Make a few more gears honour world edge checks
nemo
parents: 9473
diff changeset
   808
    Right:= min(Right,rightX-Gear^.Radius)
0463f747e839 Make a few more gears honour world edge checks
nemo
parents: 9473
diff changeset
   809
    end;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   810
while tryAgain do
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   811
    begin
8007
b07ce9dfc6bb Make FindPlace more flexible on large maps.
nemo
parents: 8003
diff changeset
   812
    delta:= LAND_WIDTH div 16;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   813
    cnt2:= 0;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   814
    repeat
8007
b07ce9dfc6bb Make FindPlace more flexible on large maps.
nemo
parents: 8003
diff changeset
   815
        x:= Left + max(LAND_WIDTH div 2048, LongInt(GetRandom(Delta)));
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   816
        repeat
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   817
            inc(x, Delta);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   818
            cnt:= 0;
9809
1e32628eb167 Fix warnings
unC0Rr
parents: 9706
diff changeset
   819
            y:= min(1024, topY) - Gear^.Radius shl 1;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   820
            while y < cWaterLine do
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   821
                begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   822
                repeat
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   823
                    inc(y, 2);
7190
aa8d68817c32 Make it AI survival almost definitely impossible by adding a 3rd pass to FindGear. 1st pass normal, 2nd pass allow close to objects, 3rd pass, allow overlapping objects.
nemo
parents: 7176
diff changeset
   824
                until (y >= cWaterLine) or
10015
4feced261c68 partial merge of the webgl branch
koda
parents: 10012 9954
diff changeset
   825
                        ((not ignoreOverlap) and (CountNonZeroz(x, y, Gear^.Radius - 1, 1, $FFFF) = 0)) or
8751
4609823efc94 More flagging of Land values. Also use less than for tests of non-terrain, instead of "and $FF00 = 0". Saves a couple of ops, which actually matters a small amount in a few places.
nemo
parents: 8632
diff changeset
   826
                        (ignoreOverlap and (CountNonZeroz(x, y, Gear^.Radius - 1, 1, lfLandMask) = 0));
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   827
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   828
                sy:= y;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   829
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   830
                repeat
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   831
                    inc(y);
7190
aa8d68817c32 Make it AI survival almost definitely impossible by adding a 3rd pass to FindGear. 1st pass normal, 2nd pass allow close to objects, 3rd pass, allow overlapping objects.
nemo
parents: 7176
diff changeset
   832
                until (y >= cWaterLine) or
10015
4feced261c68 partial merge of the webgl branch
koda
parents: 10012 9954
diff changeset
   833
                        ((not ignoreOverlap) and (CountNonZeroz(x, y, Gear^.Radius - 1, 1, $FFFF) <> 0)) or
4feced261c68 partial merge of the webgl branch
koda
parents: 10012 9954
diff changeset
   834
                        (ignoreOverlap and (CountNonZeroz(x, y, Gear^.Radius - 1, 1, lfLandMask) <> 0));
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   835
10272
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   836
                if (y - sy > Gear^.Radius * 2) and (y < cWaterLine)
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   837
                    and (((Gear^.Kind = gtExplosives)
10272
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   838
                        and (ignoreNearObjects or NoGearsToAvoid(x, y - Gear^.Radius, 60, 60))
10274
07adc8b6288c Fallback to old heuristic if not pit position
unc0rr
parents: 10272
diff changeset
   839
                        and (isSteadyPosition(x, y+1, Gear^.Radius - 1, 3, $FFFF)
07adc8b6288c Fallback to old heuristic if not pit position
unc0rr
parents: 10272
diff changeset
   840
                         or (CountNonZeroz(x, y+1, Gear^.Radius - 1, Gear^.Radius+1, $FFFF) > Gear^.Radius)
07adc8b6288c Fallback to old heuristic if not pit position
unc0rr
parents: 10272
diff changeset
   841
                            ))
10272
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   842
                    or
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   843
                        ((Gear^.Kind <> gtExplosives)
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   844
                        and (ignoreNearObjects or NoGearsToAvoid(x, y - Gear^.Radius, 110, 110))
31ee88c9b4d0 Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents: 10245
diff changeset
   845
                        )) then
6888
32a54322d262 Get rid of TGearsType to simplify pas2c
unc0rr
parents: 6804
diff changeset
   846
                    begin
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   847
                    ar[cnt].X:= x;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   848
                    if withFall then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   849
                        ar[cnt].Y:= sy + Gear^.Radius
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   850
                    else
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   851
                        ar[cnt].Y:= y - Gear^.Radius;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   852
                    inc(cnt)
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   853
                    end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   854
7603
e9c3c67b5dfd reducing this value is sufficient to ensure crates drop just below top border or a girder
nemo
parents: 7599
diff changeset
   855
                inc(y, 10)
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   856
                end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   857
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   858
            if cnt > 0 then
10015
4feced261c68 partial merge of the webgl branch
koda
parents: 10012 9954
diff changeset
   859
                begin
4feced261c68 partial merge of the webgl branch
koda
parents: 10012 9954
diff changeset
   860
                temp := ar[GetRandom(cnt)];
4feced261c68 partial merge of the webgl branch
koda
parents: 10012 9954
diff changeset
   861
                with temp do
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   862
                    begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   863
                    ar2[cnt2].x:= x;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   864
                    ar2[cnt2].y:= y;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   865
                    inc(cnt2)
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   866
                    end
10015
4feced261c68 partial merge of the webgl branch
koda
parents: 10012 9954
diff changeset
   867
                end
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   868
        until (x + Delta > Right);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   869
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   870
        dec(Delta, 60)
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   871
    until (cnt2 > 0) or (Delta < 70);
7190
aa8d68817c32 Make it AI survival almost definitely impossible by adding a 3rd pass to FindGear. 1st pass normal, 2nd pass allow close to objects, 3rd pass, allow overlapping objects.
nemo
parents: 7176
diff changeset
   872
    // if either of these has not been tried, do another pass
aa8d68817c32 Make it AI survival almost definitely impossible by adding a 3rd pass to FindGear. 1st pass normal, 2nd pass allow close to objects, 3rd pass, allow overlapping objects.
nemo
parents: 7176
diff changeset
   873
    if (cnt2 = 0) and skipProximity and (not ignoreOverlap) then
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   874
        tryAgain:= true
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   875
    else tryAgain:= false;
7190
aa8d68817c32 Make it AI survival almost definitely impossible by adding a 3rd pass to FindGear. 1st pass normal, 2nd pass allow close to objects, 3rd pass, allow overlapping objects.
nemo
parents: 7176
diff changeset
   876
    if ignoreNearObjects then ignoreOverlap:= true;
aa8d68817c32 Make it AI survival almost definitely impossible by adding a 3rd pass to FindGear. 1st pass normal, 2nd pass allow close to objects, 3rd pass, allow overlapping objects.
nemo
parents: 7176
diff changeset
   877
    ignoreNearObjects:= true;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   878
    end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   879
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   880
if cnt2 > 0 then
8026
4a4f21070479 merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents: 8007
diff changeset
   881
    begin
4a4f21070479 merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents: 8007
diff changeset
   882
    temp := ar2[GetRandom(cnt2)];
4a4f21070479 merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents: 8007
diff changeset
   883
    with temp do
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   884
        begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   885
        Gear^.X:= int2hwFloat(x);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   886
        Gear^.Y:= int2hwFloat(y);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   887
        AddFileLog('Assigned Gear coordinates (' + inttostr(x) + ',' + inttostr(y) + ')');
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   888
        end
8026
4a4f21070479 merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents: 8007
diff changeset
   889
    end
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   890
    else
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   891
    begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   892
    OutError('Can''t find place for Gear', false);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   893
    if Gear^.Kind = gtHedgehog then
7010
10a0a31804f3 Switch effects to longint for convenience of tracking ice states. I could add a new Hedgehog value, but since we have this effects list being all useless as booleans anyway...
nemo
parents: 6990
diff changeset
   894
        Gear^.Hedgehog^.Effects[heResurrectable] := 0;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   895
    DeleteGear(Gear);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   896
    Gear:= nil
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   897
    end
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   898
end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   899
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   900
function CheckGearNear(Gear: PGear; Kind: TGearType; rX, rY: LongInt): PGear;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   901
var t: PGear;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   902
begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   903
t:= GearsList;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   904
rX:= sqr(rX);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   905
rY:= sqr(rY);
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   906
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   907
while t <> nil do
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   908
    begin
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   909
    if (t <> Gear) and (t^.Kind = Kind) then
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   910
        if not((hwSqr(Gear^.X - t^.X) / rX + hwSqr(Gear^.Y - t^.Y) / rY) > _1) then
6990
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6986
diff changeset
   911
        begin
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6986
diff changeset
   912
            CheckGearNear:= t;
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6986
diff changeset
   913
            exit;
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents: 6986
diff changeset
   914
        end;
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   915
    t:= t^.NextGear
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   916
    end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   917
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   918
CheckGearNear:= nil
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   919
end;
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
   920
7592
cf67e58313ea Move rope code to separate unit
unc0rr
parents: 7509
diff changeset
   921
procedure CheckCollision(Gear: PGear); inline;
cf67e58313ea Move rope code to separate unit
unc0rr
parents: 7509
diff changeset
   922
begin
9706
5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents: 9685
diff changeset
   923
    if (TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) <> 0)
7592
cf67e58313ea Move rope code to separate unit
unc0rr
parents: 7509
diff changeset
   924
    or (TestCollisionYwithGear(Gear, hwSign(Gear^.dY)) <> 0) then
cf67e58313ea Move rope code to separate unit
unc0rr
parents: 7509
diff changeset
   925
        Gear^.State := Gear^.State or gstCollision
cf67e58313ea Move rope code to separate unit
unc0rr
parents: 7509
diff changeset
   926
    else
cf67e58313ea Move rope code to separate unit
unc0rr
parents: 7509
diff changeset
   927
        Gear^.State := Gear^.State and (not gstCollision)
cf67e58313ea Move rope code to separate unit
unc0rr
parents: 7509
diff changeset
   928
end;
cf67e58313ea Move rope code to separate unit
unc0rr
parents: 7509
diff changeset
   929
cf67e58313ea Move rope code to separate unit
unc0rr
parents: 7509
diff changeset
   930
procedure CheckCollisionWithLand(Gear: PGear); inline;
cf67e58313ea Move rope code to separate unit
unc0rr
parents: 7509
diff changeset
   931
begin
9706
5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents: 9685
diff changeset
   932
    if (TestCollisionX(Gear, hwSign(Gear^.dX)) <> 0)
5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents: 9685
diff changeset
   933
    or (TestCollisionY(Gear, hwSign(Gear^.dY)) <> 0) then
7592
cf67e58313ea Move rope code to separate unit
unc0rr
parents: 7509
diff changeset
   934
        Gear^.State := Gear^.State or gstCollision
8330
aaefa587e277 update branch with default
koda
parents: 8026 8199
diff changeset
   935
    else
7592
cf67e58313ea Move rope code to separate unit
unc0rr
parents: 7509
diff changeset
   936
        Gear^.State := Gear^.State and (not gstCollision)
cf67e58313ea Move rope code to separate unit
unc0rr
parents: 7509
diff changeset
   937
end;
cf67e58313ea Move rope code to separate unit
unc0rr
parents: 7509
diff changeset
   938
7719
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   939
function MakeHedgehogsStep(Gear: PGear) : boolean;
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   940
begin
9706
5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents: 9685
diff changeset
   941
    if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) <> 0 then if (TestCollisionYwithGear(Gear, -1) = 0) then
7719
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   942
        begin
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   943
        Gear^.Y:= Gear^.Y - _1;
9706
5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents: 9685
diff changeset
   944
    if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) <> 0 then if (TestCollisionYwithGear(Gear, -1) = 0) then
7719
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   945
        begin
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   946
        Gear^.Y:= Gear^.Y - _1;
9706
5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents: 9685
diff changeset
   947
    if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) <> 0 then if (TestCollisionYwithGear(Gear, -1) = 0) then
7719
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   948
        begin
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   949
        Gear^.Y:= Gear^.Y - _1;
9706
5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents: 9685
diff changeset
   950
    if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) <> 0 then if (TestCollisionYwithGear(Gear, -1) = 0) then
7719
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   951
        begin
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   952
        Gear^.Y:= Gear^.Y - _1;
9706
5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents: 9685
diff changeset
   953
    if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) <> 0 then if (TestCollisionYwithGear(Gear, -1) = 0) then
7719
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   954
        begin
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   955
        Gear^.Y:= Gear^.Y - _1;
9706
5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents: 9685
diff changeset
   956
    if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) <> 0 then if (TestCollisionYwithGear(Gear, -1) = 0) then
7719
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   957
        begin
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   958
        Gear^.Y:= Gear^.Y - _1;
9706
5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents: 9685
diff changeset
   959
        if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) <> 0 then
7719
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   960
            Gear^.Y:= Gear^.Y + _6
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   961
        end else Gear^.Y:= Gear^.Y + _5 else
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   962
        end else Gear^.Y:= Gear^.Y + _4 else
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   963
        end else Gear^.Y:= Gear^.Y + _3 else
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   964
        end else Gear^.Y:= Gear^.Y + _2 else
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   965
        end else Gear^.Y:= Gear^.Y + _1
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   966
        end;
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   967
9706
5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents: 9685
diff changeset
   968
    if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) = 0 then
7719
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   969
        begin
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   970
        Gear^.X:= Gear^.X + SignAs(_1, Gear^.dX);
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   971
        MakeHedgehogsStep:= true
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   972
        end else
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   973
        MakeHedgehogsStep:= false;
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   974
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   975
    if TestCollisionYwithGear(Gear, 1) = 0 then
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   976
        begin
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   977
        Gear^.Y:= Gear^.Y + _1;
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   978
    if TestCollisionYwithGear(Gear, 1) = 0 then
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   979
        begin
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   980
        Gear^.Y:= Gear^.Y + _1;
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   981
    if TestCollisionYwithGear(Gear, 1) = 0 then
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   982
        begin
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   983
        Gear^.Y:= Gear^.Y + _1;
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   984
    if TestCollisionYwithGear(Gear, 1) = 0 then
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   985
        begin
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   986
        Gear^.Y:= Gear^.Y + _1;
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   987
    if TestCollisionYwithGear(Gear, 1) = 0 then
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   988
        begin
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   989
        Gear^.Y:= Gear^.Y + _1;
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   990
    if TestCollisionYwithGear(Gear, 1) = 0 then
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   991
        begin
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   992
        Gear^.Y:= Gear^.Y + _1;
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   993
    if TestCollisionYwithGear(Gear, 1) = 0 then
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   994
        begin
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   995
        Gear^.Y:= Gear^.Y - _6;
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   996
        Gear^.dY:= _0;
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   997
        Gear^.State:= Gear^.State or gstMoving;
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   998
        exit
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
   999
        end;
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
  1000
        end
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
  1001
        end
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
  1002
        end
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
  1003
        end
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
  1004
        end
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
  1005
        end;
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
  1006
end;
eeae1cb6b6bf Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents: 7627
diff changeset
  1007
9285
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1008
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1009
procedure ShotgunShot(Gear: PGear);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1010
var t: PGear;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1011
    dmg, r, dist: LongInt;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1012
    dx, dy: hwFloat;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1013
begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1014
Gear^.Radius:= cShotgunRadius;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1015
t:= GearsList;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1016
while t <> nil do
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1017
    begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1018
    case t^.Kind of
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1019
        gtHedgehog,
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1020
            gtMine,
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1021
            gtSMine,
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1022
            gtKnife,
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1023
            gtCase,
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1024
            gtTarget,
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1025
            gtExplosives: begin//,
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1026
//            gtStructure: begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1027
//addFileLog('ShotgunShot radius: ' + inttostr(Gear^.Radius) + ', t^.Radius = ' + inttostr(t^.Radius) + ', distance = ' + inttostr(dist) + ', dmg = ' + inttostr(dmg));
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1028
                    dmg:= 0;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1029
                    r:= Gear^.Radius + t^.Radius;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1030
                    dx:= Gear^.X-t^.X;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1031
                    dx.isNegative:= false;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1032
                    dy:= Gear^.Y-t^.Y;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1033
                    dy.isNegative:= false;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1034
                    if r-hwRound(dx+dy) > 0 then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1035
                        begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1036
                        dist:= hwRound(Distance(dx, dy));
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1037
                        dmg:= ModifyDamage(min(r - dist, 25), t);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1038
                        end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1039
                    if dmg > 0 then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1040
                        begin
10558
b574f04c9685 fix invulnerability check for shotgun
nemo
parents: 10526
diff changeset
  1041
                        if (t^.Kind <> gtHedgehog) or (t^.Hedgehog^.Effects[heInvulnerable] = 0) then
9285
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1042
                            ApplyDamage(t, Gear^.Hedgehog, dmg, dsBullet)
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1043
                        else
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1044
                            Gear^.State:= Gear^.State or gstWinner;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1045
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1046
                        DeleteCI(t);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1047
                        t^.dX:= t^.dX + Gear^.dX * dmg * _0_01 + SignAs(cHHKick, Gear^.dX);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1048
                        t^.dY:= t^.dY + Gear^.dY * dmg * _0_01;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1049
                        t^.State:= t^.State or gstMoving;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1050
                        if t^.Kind = gtKnife then t^.State:= t^.State and (not gstCollision);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1051
                        t^.Active:= true;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1052
                        FollowGear:= t
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1053
                        end
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1054
                    end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1055
            gtGrave: begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1056
                    dmg:= 0;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1057
                    r:= Gear^.Radius + t^.Radius;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1058
                    dx:= Gear^.X-t^.X;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1059
                    dx.isNegative:= false;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1060
                    dy:= Gear^.Y-t^.Y;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1061
                    dy.isNegative:= false;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1062
                    if r-hwRound(dx+dy) > 0 then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1063
                        begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1064
                        dist:= hwRound(Distance(dx, dy));
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1065
                        dmg:= ModifyDamage(min(r - dist, 25), t);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1066
                        end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1067
                    if dmg > 0 then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1068
                        begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1069
                        t^.dY:= - _0_1;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1070
                        t^.Active:= true
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1071
                        end
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1072
                    end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1073
        end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1074
    t:= t^.NextGear
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1075
    end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1076
if (GameFlags and gfSolidLand) = 0 then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1077
    DrawExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), cShotgunRadius)
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1078
end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1079
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1080
procedure AmmoShove(Ammo: PGear; Damage, Power: LongInt);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1081
var t: PGearArray;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1082
    Gear: PGear;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1083
    i, j, tmpDmg: LongInt;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1084
    VGear: PVisualGear;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1085
begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1086
t:= CheckGearsCollision(Ammo);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1087
// Just to avoid hogs on rope dodging fire.
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1088
if (CurAmmoGear <> nil) and ((CurAmmoGear^.Kind = gtRope) or (CurAmmoGear^.Kind = gtJetpack) or (CurAmmoGear^.Kind = gtBirdy))
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1089
and (CurrentHedgehog^.Gear <> nil) and (CurrentHedgehog^.Gear^.CollisionIndex = -1)
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1090
and (sqr(hwRound(Ammo^.X) - hwRound(CurrentHedgehog^.Gear^.X)) + sqr(hwRound(Ammo^.Y) - hwRound(CurrentHedgehog^.Gear^.Y)) <= sqr(cHHRadius + Ammo^.Radius)) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1091
    begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1092
    t^.ar[t^.Count]:= CurrentHedgehog^.Gear;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1093
    inc(t^.Count)
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1094
    end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1095
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1096
i:= t^.Count;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1097
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1098
if (Ammo^.Kind = gtFlame) and (i > 0) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1099
    Ammo^.Health:= 0;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1100
while i > 0 do
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1101
    begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1102
    dec(i);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1103
    Gear:= t^.ar[i];
10015
4feced261c68 partial merge of the webgl branch
koda
parents: 10012 9954
diff changeset
  1104
    if ((Ammo^.Kind = gtFlame) or (Ammo^.Kind = gtBlowTorch)) and
9285
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1105
       (Gear^.Kind = gtHedgehog) and (Gear^.Hedgehog^.Effects[heFrozen] > 255) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1106
        Gear^.Hedgehog^.Effects[heFrozen]:= max(255,Gear^.Hedgehog^.Effects[heFrozen]-10000);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1107
    tmpDmg:= ModifyDamage(Damage, Gear);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1108
    if (Gear^.State and gstNoDamage) = 0 then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1109
        begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1110
10015
4feced261c68 partial merge of the webgl branch
koda
parents: 10012 9954
diff changeset
  1111
        if (Ammo^.Kind = gtDEagleShot) or (Ammo^.Kind = gtSniperRifleShot) then
9285
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1112
            begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1113
            VGear := AddVisualGear(hwround(Ammo^.X), hwround(Ammo^.Y), vgtBulletHit);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1114
            if VGear <> nil then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1115
                VGear^.Angle := DxDy2Angle(-Ammo^.dX, Ammo^.dY);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1116
            end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1117
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1118
        if (Gear^.Kind = gtHedgehog) and (Ammo^.State and gsttmpFlag <> 0) and (Ammo^.Kind = gtShover) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1119
            Gear^.FlightTime:= 1;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1120
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1121
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1122
        case Gear^.Kind of
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1123
            gtHedgehog,
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1124
            gtMine,
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1125
            gtSMine,
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1126
            gtKnife,
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1127
            gtTarget,
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1128
            gtCase,
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1129
            gtExplosives: //,
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1130
            //gtStructure:
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1131
            begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1132
            if (Ammo^.Kind = gtDrill) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1133
                begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1134
                Ammo^.Timer:= 0;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1135
                exit;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1136
                end;
10011
ead5e4b21671 Add check for gear kind of hedgehog on invulnerability effect. This probably fixes bug #766, is similar to change in previous r2a1483d91977 and was introduced by r7d925e82e572
nemo
parents: 10010
diff changeset
  1137
            if (Gear^.Kind <> gtHedgehog) or (Gear^.Hedgehog^.Effects[heInvulnerable] = 0) then
9285
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1138
                begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1139
                if (Ammo^.Kind = gtKnife) and (tmpDmg > 0) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1140
                    for j:= 1 to max(1,min(3,tmpDmg div 5)) do
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1141
                        begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1142
                        VGear:= AddVisualGear(hwRound(Ammo^.X-((Ammo^.X-Gear^.X)/_2)), hwRound(Ammo^.Y-((Ammo^.Y-Gear^.Y)/_2)), vgtStraightShot);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1143
                        if VGear <> nil then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1144
                            with VGear^ do
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1145
                                begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1146
                                Tint:= $FFCC00FF;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1147
                                Angle:= random(360);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1148
                                dx:= 0.0005 * (random(100));
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1149
                                dy:= 0.0005 * (random(100));
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1150
                                if random(2) = 0 then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1151
                                    dx := -dx;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1152
                                if random(2) = 0 then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1153
                                    dy := -dy;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1154
                                FrameTicks:= 600+random(200);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1155
                                State:= ord(sprStar)
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1156
                                end
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1157
                        end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1158
                ApplyDamage(Gear, Ammo^.Hedgehog, tmpDmg, dsShove)
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1159
                end
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1160
            else
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1161
                Gear^.State:= Gear^.State or gstWinner;
10015
4feced261c68 partial merge of the webgl branch
koda
parents: 10012 9954
diff changeset
  1162
            if (Gear^.Kind = gtExplosives) and (Ammo^.Kind = gtBlowtorch) then
9285
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1163
                begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1164
                if (Ammo^.Hedgehog^.Gear <> nil) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1165
                    Ammo^.Hedgehog^.Gear^.State:= Ammo^.Hedgehog^.Gear^.State and (not gstNotKickable);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1166
                ApplyDamage(Gear, Ammo^.Hedgehog, tmpDmg * 100, dsUnknown); // crank up damage for explosives + blowtorch
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1167
                end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1168
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1169
            if (Gear^.Kind = gtHedgehog) and (Gear^.Hedgehog^.King or (Gear^.Hedgehog^.Effects[heFrozen] > 0)) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1170
                begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1171
                Gear^.dX:= Ammo^.dX * Power * _0_005;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1172
                Gear^.dY:= Ammo^.dY * Power * _0_005
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1173
                end
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1174
            else if ((Ammo^.Kind <> gtFlame) or (Gear^.Kind = gtHedgehog)) and (Power <> 0) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1175
                begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1176
                Gear^.dX:= Ammo^.dX * Power * _0_01;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1177
                Gear^.dY:= Ammo^.dY * Power * _0_01
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1178
                end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1179
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1180
            if (not isZero(Gear^.dX)) or (not isZero(Gear^.dY)) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1181
                begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1182
                Gear^.Active:= true;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1183
                DeleteCI(Gear);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1184
                Gear^.State:= Gear^.State or gstMoving;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1185
                if Gear^.Kind = gtKnife then Gear^.State:= Gear^.State and (not gstCollision);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1186
                // move the gear upwards a bit to throw it over tiny obstacles at start
9706
5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents: 9685
diff changeset
  1187
                if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) <> 0 then
9285
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1188
                    begin
9706
5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents: 9685
diff changeset
  1189
                    if (TestCollisionXwithXYShift(Gear, _0, -3, hwSign(Gear^.dX)) = 0) and
5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents: 9685
diff changeset
  1190
                       (TestCollisionYwithGear(Gear, -1) = 0) then
9285
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1191
                        Gear^.Y:= Gear^.Y - _1;
9706
5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents: 9685
diff changeset
  1192
                    if (TestCollisionXwithXYShift(Gear, _0, -2, hwSign(Gear^.dX)) = 0) and
5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents: 9685
diff changeset
  1193
                       (TestCollisionYwithGear(Gear, -1) = 0) then
9285
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1194
                        Gear^.Y:= Gear^.Y - _1;
9706
5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents: 9685
diff changeset
  1195
                    if (TestCollisionXwithXYShift(Gear, _0, -1, hwSign(Gear^.dX)) = 0) and
5178d2263521 return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents: 9685
diff changeset
  1196
                       (TestCollisionYwithGear(Gear, -1) = 0) then
9285
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1197
                        Gear^.Y:= Gear^.Y - _1;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1198
                    end
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1199
                end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1200
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1201
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1202
            if (Ammo^.Kind <> gtFlame) or ((Ammo^.State and gsttmpFlag) = 0) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1203
                FollowGear:= Gear
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1204
            end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1205
        end
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1206
        end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1207
    end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1208
if i <> 0 then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1209
    SetAllToActive
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1210
end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1211
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1212
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1213
function CountGears(Kind: TGearType): Longword;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1214
var t: PGear;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1215
    count: Longword = 0;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1216
begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1217
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1218
t:= GearsList;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1219
while t <> nil do
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1220
    begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1221
    if t^.Kind = Kind then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1222
        inc(count);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1223
    t:= t^.NextGear
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1224
    end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1225
CountGears:= count;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1226
end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1227
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1228
procedure SetAllToActive;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1229
var t: PGear;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1230
begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1231
AllInactive:= false;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1232
t:= GearsList;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1233
while t <> nil do
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1234
    begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1235
    t^.Active:= true;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1236
    t:= t^.NextGear
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1237
    end
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1238
end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1239
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1240
procedure SetAllHHToActive; inline;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1241
begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1242
SetAllHHToActive(true)
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1243
end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1244
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1245
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1246
procedure SetAllHHToActive(Ice: boolean);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1247
var t: PGear;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1248
begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1249
AllInactive:= false;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1250
t:= GearsList;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1251
while t <> nil do
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1252
    begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1253
    if (t^.Kind = gtHedgehog) or (t^.Kind = gtExplosives) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1254
        begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1255
        if (t^.Kind = gtHedgehog) and Ice then CheckIce(t);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1256
        t^.Active:= true
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1257
        end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1258
    t:= t^.NextGear
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1259
    end
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1260
end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1261
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1262
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1263
var GearsNearArray : TPGearArray;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1264
function GearsNear(X, Y: hwFloat; Kind: TGearType; r: LongInt): PGearArrayS;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1265
var
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1266
    t: PGear;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1267
    s: Longword;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1268
begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1269
    r:= r*r;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1270
    s:= 0;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1271
    SetLength(GearsNearArray, s);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1272
    t := GearsList;
10015
4feced261c68 partial merge of the webgl branch
koda
parents: 10012 9954
diff changeset
  1273
    while t <> nil do
9285
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1274
        begin
10015
4feced261c68 partial merge of the webgl branch
koda
parents: 10012 9954
diff changeset
  1275
        if (t^.Kind = Kind)
9285
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1276
            and ((X - t^.X)*(X - t^.X) + (Y - t^.Y)*(Y-t^.Y) < int2hwFloat(r)) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1277
            begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1278
            inc(s);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1279
            SetLength(GearsNearArray, s);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1280
            GearsNearArray[s - 1] := t;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1281
            end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1282
        t := t^.NextGear;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1283
    end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1284
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1285
    GearsNear.size:= s;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1286
    GearsNear.ar:= @GearsNearArray
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1287
end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1288
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1289
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1290
procedure SpawnBoxOfSmth;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1291
var t, aTot, uTot, a, h: LongInt;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1292
    i: TAmmoType;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1293
begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1294
if (PlacingHogs) or
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1295
    (cCaseFactor = 0)
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1296
    or (CountGears(gtCase) >= 5)
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1297
    or (GetRandom(cCaseFactor) <> 0) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1298
       exit;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1299
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1300
FollowGear:= nil;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1301
aTot:= 0;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1302
uTot:= 0;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1303
for i:= Low(TAmmoType) to High(TAmmoType) do
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1304
    if (Ammoz[i].Ammo.Propz and ammoprop_Utility) = 0 then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1305
        inc(aTot, Ammoz[i].Probability)
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1306
    else
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1307
        inc(uTot, Ammoz[i].Probability);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1308
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1309
t:=0;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1310
a:=aTot;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1311
h:= 1;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1312
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1313
if (aTot+uTot) <> 0 then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1314
    if ((GameFlags and gfInvulnerable) = 0) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1315
        begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1316
        h:= cHealthCaseProb * 100;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1317
        t:= GetRandom(10000);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1318
        a:= (10000-h)*aTot div (aTot+uTot)
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1319
        end
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1320
    else
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1321
        begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1322
        t:= GetRandom(aTot+uTot);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1323
        h:= 0
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1324
        end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1325
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1326
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1327
if t<h then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1328
    begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1329
    FollowGear:= AddGear(0, 0, gtCase, 0, _0, _0, 0);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1330
    FollowGear^.Health:= cHealthCaseAmount;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1331
    FollowGear^.Pos:= posCaseHealth;
10506
325f7bb60580 fix health crate collision
sheepluva
parents: 10494
diff changeset
  1332
    // health crate is smaller than the other crates
325f7bb60580 fix health crate collision
sheepluva
parents: 10494
diff changeset
  1333
    FollowGear^.Radius := cCaseHealthRadius;
9285
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1334
    AddCaption(GetEventString(eidNewHealthPack), cWhiteColor, capgrpAmmoInfo);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1335
    end
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1336
else if (t<a+h) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1337
    begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1338
    t:= aTot;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1339
    if (t > 0) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1340
        begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1341
        FollowGear:= AddGear(0, 0, gtCase, 0, _0, _0, 0);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1342
        t:= GetRandom(t);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1343
        i:= Low(TAmmoType);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1344
        FollowGear^.Pos:= posCaseAmmo;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1345
        FollowGear^.AmmoType:= i;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1346
        AddCaption(GetEventString(eidNewAmmoPack), cWhiteColor, capgrpAmmoInfo);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1347
        end
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1348
    end
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1349
else
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1350
    begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1351
    t:= uTot;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1352
    if (t > 0) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1353
        begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1354
        FollowGear:= AddGear(0, 0, gtCase, 0, _0, _0, 0);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1355
        t:= GetRandom(t);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1356
        i:= Low(TAmmoType);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1357
        FollowGear^.Pos:= posCaseUtility;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1358
        FollowGear^.AmmoType:= i;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1359
        AddCaption(GetEventString(eidNewUtilityPack), cWhiteColor, capgrpAmmoInfo);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1360
        end
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1361
    end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1362
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1363
// handles case of no ammo or utility crates - considered also placing booleans in uAmmos and altering probabilities
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1364
if (FollowGear <> nil) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1365
    begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1366
    FindPlace(FollowGear, true, 0, LAND_WIDTH);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1367
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1368
    if (FollowGear <> nil) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1369
        AddVoice(sndReinforce, CurrentTeam^.voicepack)
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1370
    end
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1371
end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1372
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1373
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1374
function GetAmmo(Hedgehog: PHedgehog): TAmmoType;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1375
var t, aTot: LongInt;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1376
    i: TAmmoType;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1377
begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1378
Hedgehog:= Hedgehog; // avoid hint
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1379
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1380
aTot:= 0;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1381
for i:= Low(TAmmoType) to High(TAmmoType) do
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1382
    if (Ammoz[i].Ammo.Propz and ammoprop_Utility) = 0 then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1383
        inc(aTot, Ammoz[i].Probability);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1384
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1385
t:= aTot;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1386
i:= Low(TAmmoType);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1387
if (t > 0) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1388
    begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1389
    t:= GetRandom(t);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1390
    while t >= 0 do
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1391
        begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1392
        inc(i);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1393
        if (Ammoz[i].Ammo.Propz and ammoprop_Utility) = 0 then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1394
            dec(t, Ammoz[i].Probability)
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1395
        end
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1396
    end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1397
GetAmmo:= i
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1398
end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1399
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1400
function GetUtility(Hedgehog: PHedgehog): TAmmoType;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1401
var t, uTot: LongInt;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1402
    i: TAmmoType;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1403
begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1404
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1405
uTot:= 0;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1406
for i:= Low(TAmmoType) to High(TAmmoType) do
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1407
    if ((Ammoz[i].Ammo.Propz and ammoprop_Utility) <> 0)
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1408
    and ((Hedgehog^.Team^.HedgehogsNumber > 1) or (Ammoz[i].Ammo.AmmoType <> amSwitch)) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1409
        inc(uTot, Ammoz[i].Probability);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1410
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1411
t:= uTot;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1412
i:= Low(TAmmoType);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1413
if (t > 0) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1414
    begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1415
    t:= GetRandom(t);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1416
    while t >= 0 do
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1417
        begin
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1418
        inc(i);
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1419
        if ((Ammoz[i].Ammo.Propz and ammoprop_Utility) <> 0) and ((Hedgehog^.Team^.HedgehogsNumber > 1)
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1420
        or (Ammoz[i].Ammo.AmmoType <> amSwitch)) then
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1421
            dec(t, Ammoz[i].Probability)
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1422
        end
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1423
    end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1424
GetUtility:= i
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1425
end;
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1426
9473
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1427
(*
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1428
Intended to check Gear X/Y against the map left/right edges and apply one of the world modes
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1429
* Normal - infinite world, do nothing
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1430
* Wrap (entering left edge exits at same height on right edge)
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1431
* Bounce (striking edge is treated as a 100% elasticity bounce)
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1432
* From the depths (same as from sky, but from sea, with submersible flag set)
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1433
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1434
Trying to make the checks a little broader than on first pass to catch things that don't move normally.
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1435
*)
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1436
function WorldWrap(var Gear: PGear): boolean;
10354
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
  1437
//var tdx: hwFloat;
9473
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1438
begin
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1439
WorldWrap:= false;
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1440
if WorldEdge = weNone then exit(false);
10160
4608f10ae65f - Make world wrap edges not depend on gear radius
unc0rr
parents: 10124
diff changeset
  1441
if (hwRound(Gear^.X) < LongInt(leftX)) or
4608f10ae65f - Make world wrap edges not depend on gear radius
unc0rr
parents: 10124
diff changeset
  1442
   (hwRound(Gear^.X) > LongInt(rightX)) then
9473
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1443
    begin
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1444
    if WorldEdge = weWrap then
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1445
        begin
10160
4608f10ae65f - Make world wrap edges not depend on gear radius
unc0rr
parents: 10124
diff changeset
  1446
        if (hwRound(Gear^.X) < LongInt(leftX)) then
4608f10ae65f - Make world wrap edges not depend on gear radius
unc0rr
parents: 10124
diff changeset
  1447
             Gear^.X:= Gear^.X + int2hwfloat(rightX - leftX)
4608f10ae65f - Make world wrap edges not depend on gear radius
unc0rr
parents: 10124
diff changeset
  1448
        else Gear^.X:= Gear^.X - int2hwfloat(rightX - leftX);
9557
a5005b7ca305 differentiate borders a bit
nemo
parents: 9522
diff changeset
  1449
        LeftImpactTimer:= 150;
a5005b7ca305 differentiate borders a bit
nemo
parents: 9522
diff changeset
  1450
        RightImpactTimer:= 150
9473
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1451
        end
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1452
    else if WorldEdge = weBounce then
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1453
        begin
9809
1e32628eb167 Fix warnings
unC0Rr
parents: 9706
diff changeset
  1454
        if (hwRound(Gear^.X) - Gear^.Radius < LongInt(leftX)) then
9473
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1455
            begin
9557
a5005b7ca305 differentiate borders a bit
nemo
parents: 9522
diff changeset
  1456
            LeftImpactTimer:= 333;
9473
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1457
            Gear^.dX.isNegative:= false;
9809
1e32628eb167 Fix warnings
unC0Rr
parents: 9706
diff changeset
  1458
            Gear^.X:= int2hwfloat(LongInt(leftX) + Gear^.Radius)
9473
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1459
            end
10015
4feced261c68 partial merge of the webgl branch
koda
parents: 10012 9954
diff changeset
  1460
        else
9473
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1461
            begin
9557
a5005b7ca305 differentiate borders a bit
nemo
parents: 9522
diff changeset
  1462
            RightImpactTimer:= 333;
9473
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1463
            Gear^.dX.isNegative:= true;
9485
3dee8a3b0406 add shotgun wrap, revert 100px offset. Problematic w/ things that rely on Land.
nemo
parents: 9479
diff changeset
  1464
            Gear^.X:= int2hwfloat(rightX-Gear^.Radius)
9557
a5005b7ca305 differentiate borders a bit
nemo
parents: 9522
diff changeset
  1465
            end;
9561
aab34634a17b call bounce sound less often
nemo
parents: 9557
diff changeset
  1466
        if (Gear^.Radius > 2) and (Gear^.dX.QWordValue > _0_001.QWordValue) then
10508
1a91c1fcba0d add bounce effect to bouncy world edges
sheepluva
parents: 10506
diff changeset
  1467
            AddBounceEffectForGear(Gear);
10354
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
  1468
        end{
9473
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1469
    else if WorldEdge = weSea then
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1470
        begin
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1471
        if (hwRound(Gear^.Y) > cWaterLine) and (Gear^.State and gstSubmersible <> 0) then
9521
8054d9d775fd merge with latest defaul, fixing compiling with fpc, parsing and rendering with pas2c, some minor problems with compiling with clang
koda
parents: 9160 9489
diff changeset
  1472
            Gear^.State:= Gear^.State and (not gstSubmersible)
9473
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1473
        else
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1474
            begin
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1475
            Gear^.State:= Gear^.State or gstSubmersible;
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1476
            Gear^.X:= int2hwFloat(PlayWidth)*int2hwFloat(min(max(0,hwRound(Gear^.Y)),PlayHeight))/PlayHeight;
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1477
            Gear^.Y:= int2hwFloat(cWaterLine+cVisibleWater+Gear^.Radius*2);
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1478
            tdx:= Gear^.dX;
9522
a386e1cdc468 tiny tweak to silly mode
nemo
parents: 9489
diff changeset
  1479
            Gear^.dX:= -Gear^.dY;
9473
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1480
            Gear^.dY:= tdx;
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1481
            Gear^.dY.isNegative:= true
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1482
            end
10354
56bd029245fc WIP: weSea tweaks, functional and visual
sheepluva
parents: 10274
diff changeset
  1483
        end};
9473
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1484
(*
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1485
* Window in the sky (Gear moved high into the sky, Y is used to determine X) [unfortunately, not a safe thing to do. shame, I thought aerial bombardment would be kinda neat
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1486
This one would be really easy to freeze game unless it was flagged unfortunately.
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1487
10015
4feced261c68 partial merge of the webgl branch
koda
parents: 10012 9954
diff changeset
  1488
    else
9473
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1489
        begin
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1490
        Gear^.X:= int2hwFloat(PlayWidth)*int2hwFloat(min(max(0,hwRound(Gear^.Y)),PlayHeight))/PlayHeight;
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1491
        Gear^.Y:= -_2048-_256-_256;
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1492
        tdx:= Gear^.dX;
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1493
        Gear^.dX:= Gear^.dY;
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1494
        Gear^.dY:= tdx;
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1495
        Gear^.dY.isNegative:= false
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1496
        end
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1497
*)
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1498
    WorldWrap:= true
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1499
    end;
a51a69094c24 partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents: 9285
diff changeset
  1500
end;
9285
8e8b908970c2 Refactoring: get rid of GSHandlers.inc
unc0rr
parents: 9283
diff changeset
  1501
10508
1a91c1fcba0d add bounce effect to bouncy world edges
sheepluva
parents: 10506
diff changeset
  1502
procedure AddBounceEffectForGear(Gear: PGear);
1a91c1fcba0d add bounce effect to bouncy world edges
sheepluva
parents: 10506
diff changeset
  1503
var boing: PVisualGear;
1a91c1fcba0d add bounce effect to bouncy world edges
sheepluva
parents: 10506
diff changeset
  1504
begin
1a91c1fcba0d add bounce effect to bouncy world edges
sheepluva
parents: 10506
diff changeset
  1505
    boing:= AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtStraightShot, 0, false, 1);
1a91c1fcba0d add bounce effect to bouncy world edges
sheepluva
parents: 10506
diff changeset
  1506
    if boing <> nil then
1a91c1fcba0d add bounce effect to bouncy world edges
sheepluva
parents: 10506
diff changeset
  1507
        with boing^ do
1a91c1fcba0d add bounce effect to bouncy world edges
sheepluva
parents: 10506
diff changeset
  1508
            begin
1a91c1fcba0d add bounce effect to bouncy world edges
sheepluva
parents: 10506
diff changeset
  1509
            Angle:= random(360);
1a91c1fcba0d add bounce effect to bouncy world edges
sheepluva
parents: 10506
diff changeset
  1510
            dx:= 0;
1a91c1fcba0d add bounce effect to bouncy world edges
sheepluva
parents: 10506
diff changeset
  1511
            dy:= 0;
1a91c1fcba0d add bounce effect to bouncy world edges
sheepluva
parents: 10506
diff changeset
  1512
            FrameTicks:= 200;
1a91c1fcba0d add bounce effect to bouncy world edges
sheepluva
parents: 10506
diff changeset
  1513
            Scale:= hwFloat2Float(Gear^.Density * hwAbs(Gear^.dY) + hwAbs(Gear^.dX)) / 1.5;
1a91c1fcba0d add bounce effect to bouncy world edges
sheepluva
parents: 10506
diff changeset
  1514
            State:= ord(sprBoing)
1a91c1fcba0d add bounce effect to bouncy world edges
sheepluva
parents: 10506
diff changeset
  1515
            end;
1a91c1fcba0d add bounce effect to bouncy world edges
sheepluva
parents: 10506
diff changeset
  1516
    PlaySound(sndMelonImpact, true)
1a91c1fcba0d add bounce effect to bouncy world edges
sheepluva
parents: 10506
diff changeset
  1517
end;
1a91c1fcba0d add bounce effect to bouncy world edges
sheepluva
parents: 10506
diff changeset
  1518
6581
e510d1245bd7 fix line endings
nemo
parents: 6580
diff changeset
  1519
end.