author | koda |
Sat, 27 Nov 2010 23:29:07 +0100 | |
changeset 4358 | 0445d807193e |
parent 4344 | 23ab3bdbf218 |
child 4357 | a1fcfc341a52 |
permissions | -rw-r--r-- |
4 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
3236
4ab3917d7d44
Update (c) lines to 2010 as unc0rr requested - they all had varying values so I just took the first year mentioned, then tacked on -2010
nemo
parents:
3232
diff
changeset
|
3 |
* Copyright (c) 2004-2010 Andrey Korotaev <unC0Rr@gmail.com> |
4 | 4 |
* |
183 | 5 |
* This program is free software; you can redistribute it and/or modify |
6 |
* it under the terms of the GNU General Public License as published by |
|
7 |
* the Free Software Foundation; version 2 of the License |
|
4 | 8 |
* |
183 | 9 |
* This program is distributed in the hope that it will be useful, |
10 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
11 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
12 |
* GNU General Public License for more details. |
|
4 | 13 |
* |
183 | 14 |
* You should have received a copy of the GNU General Public License |
15 |
* along with this program; if not, write to the Free Software |
|
16 |
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA |
|
4 | 17 |
*) |
18 |
||
2622 | 19 |
{$INCLUDE "options.inc"} |
20 |
||
4 | 21 |
unit uGears; |
22 |
interface |
|
3032 | 23 |
uses SDLh, uConsts, uFloat, Math; |
4 | 24 |
|
3697 | 25 |
|
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
26 |
type |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
27 |
PGear = ^TGear; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
28 |
TGearStepProcedure = procedure (Gear: PGear); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
29 |
TGear = record |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
30 |
NextGear, PrevGear: PGear; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
31 |
Active: Boolean; |
3072
b18038b3a0f4
I don't know why I'm bothering. Sheepluva has a whole new approach in the works.
nemo
parents:
3065
diff
changeset
|
32 |
AdvBounce: Longword; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
33 |
Invulnerable: Boolean; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
34 |
RenderTimer: Boolean; |
3836
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3832
diff
changeset
|
35 |
AmmoType : TAmmoType; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
36 |
State : Longword; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
37 |
X : hwFloat; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
38 |
Y : hwFloat; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
39 |
dX: hwFloat; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
40 |
dY: hwFloat; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
41 |
Kind: TGearType; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
42 |
Pos: Longword; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
43 |
doStep: TGearStepProcedure; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
44 |
Radius: LongInt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
45 |
Angle, Power : Longword; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
46 |
DirAngle: real; |
3030 | 47 |
Timer : LongWord; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
48 |
Elasticity: hwFloat; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
49 |
Friction : hwFloat; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
50 |
Message, MsgParam : Longword; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
51 |
Hedgehog: pointer; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
52 |
Health, Damage, Karma: LongInt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
53 |
CollisionIndex: LongInt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
54 |
Tag: LongInt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
55 |
Tex: PTexture; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
56 |
Z: Longword; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
57 |
IntersectGear: PGear; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
58 |
FlightTime: Longword; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
59 |
uid: Longword; |
3136 | 60 |
ImpactSound: TSound; // first sound, others have to be after it in the sounds def. |
3180
724e094a8912
fix fpc 2.2.4 type related warning with unclear origin
sheepluva
parents:
3172
diff
changeset
|
61 |
nImpactSounds: Word; // count of ImpactSounds |
3480
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
62 |
SoundChannel: LongInt; |
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
63 |
PortalCounter: LongWord // Hopefully temporary, but avoids infinite portal loops in a guaranteed fashion. |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
64 |
end; |
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
65 |
TPGearArray = Array of PGear; |
4 | 66 |
|
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
67 |
var AllInactive: boolean; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
68 |
PrvInactive: boolean; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
69 |
CurAmmoGear: PGear; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
70 |
GearsList: PGear; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
71 |
KilledHHs: Longword; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
72 |
SuddenDeathDmg: Boolean; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
73 |
SpeechType: Longword; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
74 |
SpeechText: shortstring; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
75 |
TrainingTargetGear: PGear; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2699
diff
changeset
|
76 |
skipFlag: boolean; |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2760
diff
changeset
|
77 |
PlacingHogs: boolean; // a convenience flag to indicate placement of hogs is still in progress |
2940 | 78 |
StepSoundTimer: LongInt; |
79 |
StepSoundChannel: LongInt; |
|
3697 | 80 |
|
3038 | 81 |
procedure initModule; |
82 |
procedure freeModule; |
|
371 | 83 |
function AddGear(X, Y: LongInt; Kind: TGearType; State: Longword; dX, dY: hwFloat; Timer: LongWord): PGear; |
3750
3aa85b5f3318
SpawnCustomCrateAt: spawn crate at random position for x=y=0, also let it return the gear, and luabindings the gear uid
burp
parents:
3749
diff
changeset
|
84 |
function SpawnCustomCrateAt(x, y: LongInt; crate: TCrateType; content: Longword ): PGear; |
3768 | 85 |
procedure ResurrectHedgehog(gear: PGear); |
4 | 86 |
procedure ProcessGears; |
3396
e5b3e5f2818e
More portal changes. Allows for a multishoot utility. Hopefully not breaking anything.
nemo
parents:
3390
diff
changeset
|
87 |
procedure EndTurnCleanup; |
3682 | 88 |
procedure ApplyDamage(Gear: PGear; Damage: Longword; Source: TDamageSource); |
4 | 89 |
procedure SetAllToActive; |
90 |
procedure SetAllHHToActive; |
|
956 | 91 |
procedure DrawGears; |
4 | 92 |
procedure FreeGearsList; |
10 | 93 |
procedure AddMiscGears; |
4 | 94 |
procedure AssignHHCoords; |
3405 | 95 |
function GearByUID(uid : Longword) : PGear; |
294 | 96 |
procedure InsertGearToList(Gear: PGear); |
97 |
procedure RemoveGearFromList(Gear: PGear); |
|
3405 | 98 |
function ModifyDamage(dmg: Longword; Gear: PGear): Longword; |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2760
diff
changeset
|
99 |
procedure FindPlace(var Gear: PGear; withFall: boolean; Left, Right: LongInt); |
3672
f225b94a4411
shrink confirmation button, double tap resets zoom and centers hog
koda
parents:
3615
diff
changeset
|
100 |
function GetLaunchX(at: TAmmoType; dir: LongInt; angle: LongInt): LongInt; |
f225b94a4411
shrink confirmation button, double tap resets zoom and centers hog
koda
parents:
3615
diff
changeset
|
101 |
function GetLaunchY(at: TAmmoType; angle: LongInt): LongInt; |
4 | 102 |
|
103 |
implementation |
|
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
104 |
uses uWorld, uMisc, uStore, uConsole, uSound, uTeams, uRandom, uCollisions, uLand, uIO, uLandGraphics, |
4034
634a8c8682de
add some phone rumbling to big explosions, airbomb and sinegun
koda
parents:
4024
diff
changeset
|
105 |
uAIMisc, uLocale, uAI, uAmmos, uStats, uVisualGears, uScript, GLunit, uMobile; |
789 | 106 |
|
1207
ceaab010269e
Some adjusting... it still doesn't solve problem fully
unc0rr
parents:
1200
diff
changeset
|
107 |
const MAXROPEPOINTS = 384; |
68 | 108 |
var RopePoints: record |
4 | 109 |
Count: Longword; |
776
8fc7e59d9cb4
Convert the rest of rotated sprites to be rotated by OpenGL
unc0rr
parents:
775
diff
changeset
|
110 |
HookAngle: GLfloat; |
789 | 111 |
ar: array[0..MAXROPEPOINTS] of record |
351 | 112 |
X, Y: hwFloat; |
113 |
dLen: hwFloat; |
|
4 | 114 |
b: boolean; |
115 |
end; |
|
2391 | 116 |
rounded: array[0..MAXROPEPOINTS + 2] of TVertex2f; |
2362 | 117 |
end; |
3697 | 118 |
|
1515 | 119 |
procedure DeleteGear(Gear: PGear); forward; |
371 | 120 |
procedure doMakeExplosion(X, Y, Radius: LongInt; Mask: LongWord); forward; |
3475 | 121 |
procedure doMakeExplosion(X, Y, Radius: LongInt; Mask, Tint: LongWord); forward; |
371 | 122 |
procedure AmmoShove(Ammo: PGear; Damage, Power: LongInt); forward; |
1433 | 123 |
//procedure AmmoFlameWork(Ammo: PGear); forward; |
4034
634a8c8682de
add some phone rumbling to big explosions, airbomb and sinegun
koda
parents:
4024
diff
changeset
|
124 |
function GearsNear(X, Y: hwFloat; Kind: TGearType; r: LongInt): TPGearArray; forward; |
371 | 125 |
function CheckGearNear(Gear: PGear; Kind: TGearType; rX, rY: LongInt): PGear; forward; |
15 | 126 |
procedure SpawnBoxOfSmth; forward; |
32
78bff13b11c0
With this patch the game doesn't crash when gaming by net
unc0rr
parents:
24
diff
changeset
|
127 |
procedure AfterAttack; forward; |
302 | 128 |
procedure HedgehogStep(Gear: PGear); forward; |
1528 | 129 |
procedure doStepHedgehogMoving(Gear: PGear); forward; |
303
1659c4aad5ab
Now blow torch angle can be changed during blowing :)
unc0rr
parents:
302
diff
changeset
|
130 |
procedure HedgehogChAngle(Gear: PGear); forward; |
506 | 131 |
procedure ShotgunShot(Gear: PGear); forward; |
1689 | 132 |
procedure PickUp(HH, Gear: PGear); forward; |
1964 | 133 |
procedure HHSetWeapon(Gear: PGear); forward; |
2941
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2940
diff
changeset
|
134 |
procedure doStepCase(Gear: PGear); forward; |
1964 | 135 |
|
3483 | 136 |
function GetLaunchX(at: TAmmoType; dir: LongInt; angle: LongInt): LongInt; |
137 |
begin |
|
3499 | 138 |
if (Ammoz[at].ejectX <> 0) or (Ammoz[at].ejectY <> 0) then |
139 |
GetLaunchX:= sign(dir) * (8 + hwRound(AngleSin(angle) * Ammoz[at].ejectX) + hwRound(AngleCos(angle) * Ammoz[at].ejectY)) |
|
140 |
else |
|
141 |
GetLaunchX:= 0 |
|
3483 | 142 |
end; |
143 |
||
144 |
function GetLaunchY(at: TAmmoType; angle: LongInt): LongInt; |
|
145 |
begin |
|
3499 | 146 |
if (Ammoz[at].ejectX <> 0) or (Ammoz[at].ejectY <> 0) then |
147 |
GetLaunchY:= hwRound(AngleSin(angle) * Ammoz[at].ejectY) - hwRound(AngleCos(angle) * Ammoz[at].ejectX) - 2 |
|
148 |
else |
|
149 |
GetLaunchY:= 0 |
|
3483 | 150 |
end; |
4 | 151 |
|
2599 | 152 |
{$INCLUDE "GSHandlers.inc"} |
153 |
{$INCLUDE "HHHandlers.inc"} |
|
4 | 154 |
|
155 |
const doStepHandlers: array[TGearType] of TGearStepProcedure = ( |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
156 |
@doStepBomb, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
157 |
@doStepHedgehog, |
4168 | 158 |
@doStepShell, |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
159 |
@doStepGrave, |
3080 | 160 |
@doStepBee, |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
161 |
@doStepShotgunShot, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
162 |
@doStepPickHammer, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
163 |
@doStepRope, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
164 |
@doStepMine, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
165 |
@doStepCase, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
166 |
@doStepDEagleShot, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
167 |
@doStepDynamite, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
168 |
@doStepBomb, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
169 |
@doStepCluster, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
170 |
@doStepShover, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
171 |
@doStepFlame, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
172 |
@doStepFirePunch, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
173 |
@doStepActionTimer, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
174 |
@doStepActionTimer, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
175 |
@doStepActionTimer, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
176 |
@doStepParachute, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
177 |
@doStepAirAttack, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
178 |
@doStepAirBomb, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
179 |
@doStepBlowTorch, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
180 |
@doStepGirder, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
181 |
@doStepTeleport, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
182 |
@doStepSwitcher, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
183 |
@doStepTarget, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
184 |
@doStepMortar, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
185 |
@doStepWhip, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
186 |
@doStepKamikaze, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
187 |
@doStepCake, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
188 |
@doStepSeduction, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
189 |
@doStepWatermelon, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
190 |
@doStepCluster, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
191 |
@doStepBomb, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
192 |
@doStepWaterUp, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
193 |
@doStepDrill, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
194 |
@doStepBallgun, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
195 |
@doStepBomb, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
196 |
@doStepRCPlane, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
197 |
@doStepSniperRifleShot, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
198 |
@doStepJetpack, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
199 |
@doStepMolotov, |
2983 | 200 |
@doStepCase, |
3032 | 201 |
@doStepBirdy, |
3342
b4f01613dcd7
Some initial stubs for portal just so Tiy will quit nagging. Also let folks know what approximation of physics I plan to try, here.
nemo
parents:
3337
diff
changeset
|
202 |
@doStepEggWork, |
3428 | 203 |
@doStepPortalShot, |
3382 | 204 |
@doStepPiano, |
3384 | 205 |
@doStepBomb, |
3476
1ec68b8d3bd1
Henek adds a flamethrower, updates some translations, and tweaks how fire works.
nemo
parents:
3475
diff
changeset
|
206 |
@doStepSineGunShot, |
3710 | 207 |
@doStepFlamethrower, |
3712 | 208 |
@doStepSMine, |
3717 | 209 |
@doStepPoisonCloud, |
3720 | 210 |
@doStepHammer, |
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
211 |
@doStepHammerHit, |
4313
0690067bc5ff
made napalm use napalmbombs instead of just dropping fire
Henek
parents:
4299
diff
changeset
|
212 |
@doStepResurrector, |
0690067bc5ff
made napalm use napalmbombs instead of just dropping fire
Henek
parents:
4299
diff
changeset
|
213 |
@doStepNapalmBomb |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
214 |
); |
4 | 215 |
|
294 | 216 |
procedure InsertGearToList(Gear: PGear); |
803 | 217 |
var tmp, ptmp: PGear; |
294 | 218 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
219 |
tmp:= GearsList; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
220 |
ptmp:= GearsList; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
221 |
while (tmp <> nil) and (tmp^.Z <= Gear^.Z) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
222 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
223 |
ptmp:= tmp; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
224 |
tmp:= tmp^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
225 |
end; |
3697 | 226 |
|
3442 | 227 |
if ptmp <> tmp then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
228 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
229 |
Gear^.NextGear:= ptmp^.NextGear; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
230 |
Gear^.PrevGear:= ptmp; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
231 |
if ptmp^.NextGear <> nil then ptmp^.NextGear^.PrevGear:= Gear; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
232 |
ptmp^.NextGear:= Gear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
233 |
end |
3442 | 234 |
else |
235 |
begin |
|
236 |
Gear^.NextGear:= GearsList; |
|
237 |
if Gear^.NextGear <> nil then Gear^.NextGear^.PrevGear:= Gear; |
|
238 |
GearsList:= Gear; |
|
239 |
end; |
|
294 | 240 |
end; |
241 |
||
242 |
procedure RemoveGearFromList(Gear: PGear); |
|
243 |
begin |
|
351 | 244 |
if Gear^.NextGear <> nil then Gear^.NextGear^.PrevGear:= Gear^.PrevGear; |
1505 | 245 |
if Gear^.PrevGear <> nil then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
246 |
Gear^.PrevGear^.NextGear:= Gear^.NextGear |
1505 | 247 |
else |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
248 |
GearsList:= Gear^.NextGear |
294 | 249 |
end; |
250 |
||
3443
14d12df0d363
finishing the gtHealthTag -> vgtHealthTag, no segfaults and hogzombies no more, hopefully
sheepluva
parents:
3442
diff
changeset
|
251 |
procedure spawnHealthTagForHH(HHGear: PGear; dmg: Longword); |
14d12df0d363
finishing the gtHealthTag -> vgtHealthTag, no segfaults and hogzombies no more, hopefully
sheepluva
parents:
3442
diff
changeset
|
252 |
var tag: PVisualGear; |
14d12df0d363
finishing the gtHealthTag -> vgtHealthTag, no segfaults and hogzombies no more, hopefully
sheepluva
parents:
3442
diff
changeset
|
253 |
begin |
3459
c552aa44108d
hey sheepluva, how about just this? lets you have an anonymous one too.
nemo
parents:
3453
diff
changeset
|
254 |
tag:= AddVisualGear(hwRound(HHGear^.X), hwRound(HHGear^.Y), vgtHealthTag, dmg); |
c552aa44108d
hey sheepluva, how about just this? lets you have an anonymous one too.
nemo
parents:
3453
diff
changeset
|
255 |
if (tag <> nil) then |
3450 | 256 |
tag^.Hedgehog:= PHedgehog(HHGear^.Hedgehog); // the tag needs the tag to determine the text color |
3443
14d12df0d363
finishing the gtHealthTag -> vgtHealthTag, no segfaults and hogzombies no more, hopefully
sheepluva
parents:
3442
diff
changeset
|
257 |
AllInactive:= false; |
14d12df0d363
finishing the gtHealthTag -> vgtHealthTag, no segfaults and hogzombies no more, hopefully
sheepluva
parents:
3442
diff
changeset
|
258 |
HHGear^.Active:= true; |
14d12df0d363
finishing the gtHealthTag -> vgtHealthTag, no segfaults and hogzombies no more, hopefully
sheepluva
parents:
3442
diff
changeset
|
259 |
end; |
14d12df0d363
finishing the gtHealthTag -> vgtHealthTag, no segfaults and hogzombies no more, hopefully
sheepluva
parents:
3442
diff
changeset
|
260 |
|
371 | 261 |
function AddGear(X, Y: LongInt; Kind: TGearType; State: Longword; dX, dY: hwFloat; Timer: LongWord): PGear; |
79 | 262 |
const Counter: Longword = 0; |
2695 | 263 |
var gear: PGear; |
4 | 264 |
begin |
79 | 265 |
inc(Counter); |
1495 | 266 |
{$IFDEF DEBUGFILE} |
3337 | 267 |
AddFileLog('AddGear: #' + inttostr(Counter) + ' (' + inttostr(x) + ',' + inttostr(y) + '), d(' + floattostr(dX) + ',' + floattostr(dY) + ') type = ' + EnumToStr(Kind)); |
1495 | 268 |
{$ENDIF} |
269 |
||
2695 | 270 |
New(gear); |
271 |
FillChar(gear^, sizeof(TGear), 0); |
|
272 |
gear^.X:= int2hwFloat(X); |
|
273 |
gear^.Y:= int2hwFloat(Y); |
|
274 |
gear^.Kind := Kind; |
|
275 |
gear^.State:= State; |
|
276 |
gear^.Active:= true; |
|
277 |
gear^.dX:= dX; |
|
278 |
gear^.dY:= dY; |
|
279 |
gear^.doStep:= doStepHandlers[Kind]; |
|
280 |
gear^.CollisionIndex:= -1; |
|
281 |
gear^.Timer:= Timer; |
|
282 |
gear^.Z:= cUsualZ; |
|
283 |
gear^.FlightTime:= 0; |
|
284 |
gear^.uid:= Counter; |
|
2745 | 285 |
gear^.SoundChannel:= -1; |
3094
97c8406acc85
making collision/impact sounds a gear property + adding random melon+hellish sound, feel free to hate me :D
sheepluva
parents:
3086
diff
changeset
|
286 |
gear^.ImpactSound:= sndNone; |
3136 | 287 |
gear^.nImpactSounds:= 0; |
505
fcba7d7aea0d
Fix old bug with grenade(bomd, etc..) not colliding with attacking hedgehog
unc0rr
parents:
503
diff
changeset
|
288 |
|
4 | 289 |
if CurrentTeam <> nil then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
290 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
291 |
gear^.Hedgehog:= CurrentHedgehog; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
292 |
gear^.IntersectGear:= CurrentHedgehog^.Gear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
293 |
end; |
802
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
789
diff
changeset
|
294 |
|
4 | 295 |
case Kind of |
4168 | 296 |
gtBomb, |
3382 | 297 |
gtClusterBomb, |
298 |
gtGasBomb: begin |
|
3094
97c8406acc85
making collision/impact sounds a gear property + adding random melon+hellish sound, feel free to hate me :D
sheepluva
parents:
3086
diff
changeset
|
299 |
gear^.ImpactSound:= sndGrenadeImpact; |
3136 | 300 |
gear^.nImpactSounds:= 1; |
3072
b18038b3a0f4
I don't know why I'm bothering. Sheepluva has a whole new approach in the works.
nemo
parents:
3065
diff
changeset
|
301 |
gear^.AdvBounce:= 1; |
4299 | 302 |
gear^.Radius:= 5; |
3475 | 303 |
gear^.Elasticity:= _0_8; |
304 |
gear^.Friction:= _0_8; |
|
2695 | 305 |
gear^.RenderTimer:= true; |
306 |
if gear^.Timer = 0 then gear^.Timer:= 3000 |
|
4 | 307 |
end; |
1261 | 308 |
gtWatermelon: begin |
3094
97c8406acc85
making collision/impact sounds a gear property + adding random melon+hellish sound, feel free to hate me :D
sheepluva
parents:
3086
diff
changeset
|
309 |
gear^.ImpactSound:= sndMelonImpact; |
3136 | 310 |
gear^.nImpactSounds:= 1; |
3072
b18038b3a0f4
I don't know why I'm bothering. Sheepluva has a whole new approach in the works.
nemo
parents:
3065
diff
changeset
|
311 |
gear^.AdvBounce:= 1; |
4299 | 312 |
gear^.Radius:= 6; |
2695 | 313 |
gear^.Elasticity:= _0_8; |
314 |
gear^.Friction:= _0_995; |
|
315 |
gear^.RenderTimer:= true; |
|
316 |
if gear^.Timer = 0 then gear^.Timer:= 3000 |
|
1261 | 317 |
end; |
4 | 318 |
gtHedgehog: begin |
3072
b18038b3a0f4
I don't know why I'm bothering. Sheepluva has a whole new approach in the works.
nemo
parents:
3065
diff
changeset
|
319 |
gear^.AdvBounce:= 1; |
2695 | 320 |
gear^.Radius:= cHHRadius; |
321 |
gear^.Elasticity:= _0_35; |
|
322 |
gear^.Friction:= _0_999; |
|
323 |
gear^.Angle:= cMaxAngle div 2; |
|
324 |
gear^.Z:= cHHZ; |
|
3768 | 325 |
if (GameFlags and gfAISurvival) <> 0 then |
326 |
if PHedgehog(gear^.Hedgehog)^.BotLevel > 0 then |
|
327 |
PHedgehog(gear^.Hedgehog)^.Effects[heResurrectable] := true; |
|
4 | 328 |
end; |
4168 | 329 |
gtShell: begin |
2695 | 330 |
gear^.Radius:= 4; |
4 | 331 |
end; |
332 |
gtGrave: begin |
|
3094
97c8406acc85
making collision/impact sounds a gear property + adding random melon+hellish sound, feel free to hate me :D
sheepluva
parents:
3086
diff
changeset
|
333 |
gear^.ImpactSound:= sndGraveImpact; |
3136 | 334 |
gear^.nImpactSounds:= 1; |
2695 | 335 |
gear^.Radius:= 10; |
336 |
gear^.Elasticity:= _0_6; |
|
4 | 337 |
end; |
3080 | 338 |
gtBee: begin |
2695 | 339 |
gear^.Radius:= 5; |
340 |
gear^.Timer:= 500; |
|
341 |
gear^.RenderTimer:= true; |
|
3039 | 342 |
gear^.Elasticity:= _0_9; |
343 |
gear^.Tag:= getRandom(32); |
|
4 | 344 |
end; |
345 |
gtShotgunShot: begin |
|
2695 | 346 |
gear^.Timer:= 900; |
347 |
gear^.Radius:= 2 |
|
4 | 348 |
end; |
349 |
gtPickHammer: begin |
|
2695 | 350 |
gear^.Radius:= 10; |
351 |
gear^.Timer:= 4000 |
|
4 | 352 |
end; |
3720 | 353 |
gtHammerHit: begin |
354 |
gear^.Radius:= 8; |
|
355 |
gear^.Timer:= 125 |
|
356 |
end; |
|
4 | 357 |
gtRope: begin |
2695 | 358 |
gear^.Radius:= 3; |
359 |
gear^.Friction:= _450; |
|
4 | 360 |
RopePoints.Count:= 0; |
361 |
end; |
|
10 | 362 |
gtMine: begin |
2882 | 363 |
gear^.Health:= 10; |
2695 | 364 |
gear^.State:= gear^.State or gstMoving; |
365 |
gear^.Radius:= 2; |
|
366 |
gear^.Elasticity:= _0_55; |
|
367 |
gear^.Friction:= _0_995; |
|
2031
b6f3e56fb100
david_ac's game scheme options for mine delay/quantity, tweaks to sniper rifle
nemo
parents:
2028
diff
changeset
|
368 |
if cMinesTime < 0 then |
4248 | 369 |
gear^.Timer:= getrandom(51)*100 |
2031
b6f3e56fb100
david_ac's game scheme options for mine delay/quantity, tweaks to sniper rifle
nemo
parents:
2028
diff
changeset
|
370 |
else |
4248 | 371 |
gear^.Timer:= cMinesTime*1000; |
10 | 372 |
end; |
3710 | 373 |
gtSMine: begin |
374 |
gear^.Health:= 10; |
|
375 |
gear^.State:= gear^.State or gstMoving; |
|
376 |
gear^.Radius:= 2; |
|
377 |
gear^.Elasticity:= _0_55; |
|
378 |
gear^.Friction:= _0_995; |
|
379 |
gear^.Timer:= 500; |
|
380 |
end; |
|
14
81f125629b25
- Mine checks whether a hedgehog is near less frequently
unc0rr
parents:
10
diff
changeset
|
381 |
gtCase: begin |
3094
97c8406acc85
making collision/impact sounds a gear property + adding random melon+hellish sound, feel free to hate me :D
sheepluva
parents:
3086
diff
changeset
|
382 |
gear^.ImpactSound:= sndGraveImpact; |
3136 | 383 |
gear^.nImpactSounds:= 1; |
2695 | 384 |
gear^.Radius:= 16; |
385 |
gear^.Elasticity:= _0_3 |
|
14
81f125629b25
- Mine checks whether a hedgehog is near less frequently
unc0rr
parents:
10
diff
changeset
|
386 |
end; |
2911 | 387 |
gtExplosives: begin |
3094
97c8406acc85
making collision/impact sounds a gear property + adding random melon+hellish sound, feel free to hate me :D
sheepluva
parents:
3086
diff
changeset
|
388 |
gear^.ImpactSound:= sndGrenadeImpact; |
3136 | 389 |
gear^.nImpactSounds:= 1; |
2911 | 390 |
gear^.Radius:= 16; |
2933 | 391 |
gear^.Elasticity:= _0_4; |
2938 | 392 |
gear^.Friction:= _0_995; |
2911 | 393 |
gear^.Health:= cBarrelHealth |
394 |
end; |
|
37 | 395 |
gtDEagleShot: begin |
2695 | 396 |
gear^.Radius:= 1; |
397 |
gear^.Health:= 50 |
|
37 | 398 |
end; |
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
399 |
gtSniperRifleShot: begin |
2695 | 400 |
gear^.Radius:= 1; |
401 |
gear^.Health:= 50 |
|
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
402 |
end; |
39 | 403 |
gtDynamite: begin |
2695 | 404 |
gear^.Radius:= 3; |
405 |
gear^.Elasticity:= _0_55; |
|
406 |
gear^.Friction:= _0_03; |
|
407 |
gear^.Timer:= 5000; |
|
39 | 408 |
end; |
2204
526f8165acce
Smaxx' idea of timers, reworked just a tad. Might need variable for offset, but seems ok for now
nemo
parents:
2186
diff
changeset
|
409 |
gtCluster: begin |
2695 | 410 |
gear^.Radius:= 2; |
411 |
gear^.RenderTimer:= true |
|
2204
526f8165acce
Smaxx' idea of timers, reworked just a tad. Might need variable for offset, but seems ok for now
nemo
parents:
2186
diff
changeset
|
412 |
end; |
2695 | 413 |
gtShover: gear^.Radius:= 20; |
79 | 414 |
gtFlame: begin |
2695 | 415 |
gear^.Tag:= GetRandom(32); |
416 |
gear^.Radius:= 1; |
|
417 |
gear^.Health:= 5; |
|
418 |
if (gear^.dY.QWordValue = 0) and (gear^.dX.QWordValue = 0) then |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
419 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
420 |
gear^.dY:= (getrandom - _0_8) * _0_03; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
421 |
gear^.dX:= (getrandom - _0_5) * _0_4 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
422 |
end |
79 | 423 |
end; |
82 | 424 |
gtFirePunch: begin |
2695 | 425 |
gear^.Radius:= 15; |
426 |
gear^.Tag:= Y |
|
82 | 427 |
end; |
302 | 428 |
gtAirBomb: begin |
2695 | 429 |
gear^.Radius:= 5; |
302 | 430 |
end; |
431 |
gtBlowTorch: begin |
|
2695 | 432 |
gear^.Radius:= cHHRadius + cBlowTorchC; |
433 |
gear^.Timer:= 7500 |
|
302 | 434 |
end; |
540 | 435 |
gtSwitcher: begin |
2695 | 436 |
gear^.Z:= cCurrHHZ |
540 | 437 |
end; |
593 | 438 |
gtTarget: begin |
3271 | 439 |
gear^.ImpactSound:= sndGrenadeImpact; |
440 |
gear^.nImpactSounds:= 1; |
|
2695 | 441 |
gear^.Radius:= 10; |
442 |
gear^.Elasticity:= _0_3; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
443 |
gear^.Timer:= 0 |
593 | 444 |
end; |
924 | 445 |
gtMortar: begin |
2695 | 446 |
gear^.Radius:= 4; |
447 |
gear^.Elasticity:= _0_2; |
|
448 |
gear^.Friction:= _0_08 |
|
924 | 449 |
end; |
2695 | 450 |
gtWhip: gear^.Radius:= 20; |
3717 | 451 |
gtHammer: gear^.Radius:= 20; |
984 | 452 |
gtKamikaze: begin |
2695 | 453 |
gear^.Health:= 2048; |
454 |
gear^.Radius:= 20 |
|
984 | 455 |
end; |
1089 | 456 |
gtCake: begin |
2695 | 457 |
gear^.Health:= 2048; |
458 |
gear^.Radius:= 7; |
|
459 |
gear^.Z:= cOnHHZ; |
|
460 |
gear^.RenderTimer:= true; |
|
3508
a7ca07614a2d
correct cake sit-down animation so that it doesn't sit down in mid-air anymore
sheepluva
parents:
3499
diff
changeset
|
461 |
gear^.DirAngle:= -90 * hwSign(Gear^.dX); |
2695 | 462 |
if not dX.isNegative then gear^.Angle:= 1 else gear^.Angle:= 3 |
1089 | 463 |
end; |
1263 | 464 |
gtHellishBomb: begin |
3136 | 465 |
gear^.ImpactSound:= sndHellishImpact1; |
466 |
gear^.nImpactSounds:= 4; |
|
3072
b18038b3a0f4
I don't know why I'm bothering. Sheepluva has a whole new approach in the works.
nemo
parents:
3065
diff
changeset
|
467 |
gear^.AdvBounce:= 1; |
2695 | 468 |
gear^.Radius:= 4; |
469 |
gear^.Elasticity:= _0_5; |
|
470 |
gear^.Friction:= _0_96; |
|
471 |
gear^.RenderTimer:= true; |
|
472 |
gear^.Timer:= 5000 |
|
1263 | 473 |
end; |
1573 | 474 |
gtDrill: begin |
2695 | 475 |
gear^.Timer:= 5000; |
476 |
gear^.Radius:= 4 |
|
1573 | 477 |
end; |
1601 | 478 |
gtBall: begin |
3094
97c8406acc85
making collision/impact sounds a gear property + adding random melon+hellish sound, feel free to hate me :D
sheepluva
parents:
3086
diff
changeset
|
479 |
gear^.ImpactSound:= sndGrenadeImpact; |
3136 | 480 |
gear^.nImpactSounds:= 1; |
3072
b18038b3a0f4
I don't know why I'm bothering. Sheepluva has a whole new approach in the works.
nemo
parents:
3065
diff
changeset
|
481 |
gear^.AdvBounce:= 1; |
2695 | 482 |
gear^.Radius:= 5; |
483 |
gear^.Tag:= random(8); |
|
484 |
gear^.Timer:= 5000; |
|
485 |
gear^.Elasticity:= _0_7; |
|
486 |
gear^.Friction:= _0_995; |
|
1601 | 487 |
end; |
488 |
gtBallgun: begin |
|
2695 | 489 |
gear^.Timer:= 5001; |
1601 | 490 |
end; |
1689 | 491 |
gtRCPlane: begin |
2695 | 492 |
gear^.Timer:= 15000; |
493 |
gear^.Health:= 3; |
|
494 |
gear^.Radius:= 8 |
|
1689 | 495 |
end; |
2177
c045698e044f
Initial attempt at jetpack. Pluses, more like lunar lander (takes fall damage). Minuses, can't seem to cancel it or use alt weapon
nemo
parents:
2168
diff
changeset
|
496 |
gtJetpack: begin |
2695 | 497 |
gear^.Health:= 2000; |
4260
472fd2fc1f31
Also switch saucer from updating every N ticks to updating as-needed.
nemo
parents:
4258
diff
changeset
|
498 |
gear^.Damage:= 100 |
2177
c045698e044f
Initial attempt at jetpack. Pluses, more like lunar lander (takes fall damage). Minuses, can't seem to cancel it or use alt weapon
nemo
parents:
2168
diff
changeset
|
499 |
end; |
3697 | 500 |
gtMolotov: begin |
2968
f59631c3c1c0
Fix iluvu flag (indexed), shrink molotov radius a bit to try and reduce fail
nemo
parents:
2964
diff
changeset
|
501 |
gear^.Radius:= 6; |
2488 | 502 |
end; |
2983 | 503 |
gtBirdy: begin |
504 |
gear^.Radius:= 16; // todo: check |
|
3149 | 505 |
gear^.Timer:= 0; |
3115 | 506 |
gear^.Health := 2000; |
3065 | 507 |
gear^.FlightTime := 2; |
2983 | 508 |
end; |
3697 | 509 |
gtEgg: begin |
3065 | 510 |
gear^.Radius:= 4; |
511 |
gear^.Elasticity:= _0_6; |
|
512 |
gear^.Friction:= _0_96; |
|
513 |
if gear^.Timer = 0 then gear^.Timer:= 3000 |
|
514 |
end; |
|
3342
b4f01613dcd7
Some initial stubs for portal just so Tiy will quit nagging. Also let folks know what approximation of physics I plan to try, here.
nemo
parents:
3337
diff
changeset
|
515 |
gtPortal: begin |
b4f01613dcd7
Some initial stubs for portal just so Tiy will quit nagging. Also let folks know what approximation of physics I plan to try, here.
nemo
parents:
3337
diff
changeset
|
516 |
gear^.ImpactSound:= sndMelonImpact; |
b4f01613dcd7
Some initial stubs for portal just so Tiy will quit nagging. Also let folks know what approximation of physics I plan to try, here.
nemo
parents:
3337
diff
changeset
|
517 |
gear^.nImpactSounds:= 1; |
b4f01613dcd7
Some initial stubs for portal just so Tiy will quit nagging. Also let folks know what approximation of physics I plan to try, here.
nemo
parents:
3337
diff
changeset
|
518 |
gear^.AdvBounce:= 0; |
b4f01613dcd7
Some initial stubs for portal just so Tiy will quit nagging. Also let folks know what approximation of physics I plan to try, here.
nemo
parents:
3337
diff
changeset
|
519 |
gear^.Radius:= 16; |
3388
ab9352a4ddcc
Fix portal graphic name, continuing work on portal movement
nemo
parents:
3387
diff
changeset
|
520 |
gear^.Tag:= 0; |
3428 | 521 |
gear^.Timer:= 15000; |
522 |
gear^.RenderTimer:= false; |
|
523 |
gear^.Health:= 100; |
|
3342
b4f01613dcd7
Some initial stubs for portal just so Tiy will quit nagging. Also let folks know what approximation of physics I plan to try, here.
nemo
parents:
3337
diff
changeset
|
524 |
end; |
3350 | 525 |
gtPiano: begin |
526 |
gear^.Radius:= 32 |
|
527 |
end; |
|
3384 | 528 |
gtSineGunShot: begin |
529 |
gear^.Radius:= 5; |
|
530 |
gear^.Health:= 6000; |
|
531 |
end; |
|
3476
1ec68b8d3bd1
Henek adds a flamethrower, updates some translations, and tweaks how fire works.
nemo
parents:
3475
diff
changeset
|
532 |
gtFlamethrower: begin |
3485 | 533 |
gear^.Tag:= 10; |
534 |
gear^.Timer:= 10; |
|
535 |
gear^.Health:= 500; |
|
4258 | 536 |
gear^.Damage:= 100; |
3476
1ec68b8d3bd1
Henek adds a flamethrower, updates some translations, and tweaks how fire works.
nemo
parents:
3475
diff
changeset
|
537 |
end; |
3712 | 538 |
gtPoisonCloud: begin |
539 |
gear^.Timer:= 5000; |
|
3976 | 540 |
gear^.dY:= int2hwfloat(-4 + longint(getRandom(8))) / 1000; |
3712 | 541 |
end; |
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
542 |
gtResurrector: begin |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
543 |
gear^.Radius := 100; |
4265
039b08012887
distribute health evenly amongst graves instead of randomly - avoid situation where a grave stays dead
nemo
parents:
4260
diff
changeset
|
544 |
gear^.Tag := 0 |
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
545 |
end; |
4153
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
546 |
gtWaterUp: begin |
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
547 |
gear^.Tag := 47; |
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
548 |
end; |
4313
0690067bc5ff
made napalm use napalmbombs instead of just dropping fire
Henek
parents:
4299
diff
changeset
|
549 |
gtNapalmBomb: begin |
0690067bc5ff
made napalm use napalmbombs instead of just dropping fire
Henek
parents:
4299
diff
changeset
|
550 |
gear^.Timer:= 1000; |
0690067bc5ff
made napalm use napalmbombs instead of just dropping fire
Henek
parents:
4299
diff
changeset
|
551 |
gear^.Radius:= 5; |
0690067bc5ff
made napalm use napalmbombs instead of just dropping fire
Henek
parents:
4299
diff
changeset
|
552 |
end; |
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
553 |
end; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
554 |
|
2695 | 555 |
InsertGearToList(gear); |
556 |
AddGear:= gear; |
|
2786 | 557 |
|
2792 | 558 |
ScriptCall('onGearAdd', gear^.uid); |
4 | 559 |
end; |
560 |
||
1515 | 561 |
procedure DeleteGear(Gear: PGear); |
48 | 562 |
var team: PTeam; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
563 |
t,i: Longword; |
2760
420fe0344e5f
... or. just move the king check to after the gear nil
nemo
parents:
2759
diff
changeset
|
564 |
k: boolean; |
4 | 565 |
begin |
2786 | 566 |
|
2792 | 567 |
ScriptCall('onGearDelete', gear^.uid); |
2786 | 568 |
|
503 | 569 |
DeleteCI(Gear); |
762 | 570 |
|
571 |
if Gear^.Tex <> nil then |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
572 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
573 |
FreeTexture(Gear^.Tex); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
574 |
Gear^.Tex:= nil |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
575 |
end; |
762 | 576 |
|
3422
41ae3c48faa0
* some changes/cleanups to portal, still much to do :/ * reverted nemo's temporary loop fix * notice: small loops possible again, so take care :P, bigger onces should be interrupted
sheepluva
parents:
3415
diff
changeset
|
577 |
// make sure that portals have their link removed before deletion |
3428 | 578 |
if (Gear^.Kind = gtPortal) then |
3432
83cef0f08a86
* get rid of some fpc hints (redundant/superfluous includes)
sheepluva
parents:
3429
diff
changeset
|
579 |
begin |
3428 | 580 |
if (Gear^.IntersectGear <> nil) then |
3472
b1832a3761e6
portal-link-bugfix: make sure deleted portals don't reset links other than those to themselves
sheepluva
parents:
3471
diff
changeset
|
581 |
if (Gear^.IntersectGear^.IntersectGear = Gear) then |
b1832a3761e6
portal-link-bugfix: make sure deleted portals don't reset links other than those to themselves
sheepluva
parents:
3471
diff
changeset
|
582 |
Gear^.IntersectGear^.IntersectGear:= nil; |
3432
83cef0f08a86
* get rid of some fpc hints (redundant/superfluous includes)
sheepluva
parents:
3429
diff
changeset
|
583 |
end |
3422
41ae3c48faa0
* some changes/cleanups to portal, still much to do :/ * reverted nemo's temporary loop fix * notice: small loops possible again, so take care :P, bigger onces should be interrupted
sheepluva
parents:
3415
diff
changeset
|
584 |
else if Gear^.Kind = gtHedgehog then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
585 |
if (CurAmmoGear <> nil) and (CurrentHedgehog^.Gear = Gear) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
586 |
begin |
3894 | 587 |
Gear^.Message:= gmDestroy; |
588 |
CurAmmoGear^.Message:= gmDestroy; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
589 |
exit |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
590 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
591 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
592 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
593 |
if (hwRound(Gear^.Y) >= cWaterLine) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
594 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
595 |
t:= max(Gear^.Damage, Gear^.Health); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
596 |
Gear^.Damage:= t; |
3399 | 597 |
if (cWaterOpacity < $FF) and (hwRound(Gear^.Y) < cWaterLine + 256) then |
3461
0781275649e9
revert the restoration of non-vgt health gears. desyncs continued with it, and furthermore, occur in r3489 too
nemo
parents:
3460
diff
changeset
|
598 |
spawnHealthTagForHH(Gear, t); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
599 |
uStats.HedgehogDamaged(Gear) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
600 |
end; |
2376 | 601 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
602 |
team:= PHedgehog(Gear^.Hedgehog)^.Team; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
603 |
if CurrentHedgehog^.Gear = Gear then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
604 |
FreeActionsList; // to avoid ThinkThread on drawned gear |
2376 | 605 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
606 |
PHedgehog(Gear^.Hedgehog)^.Gear:= nil; |
2726 | 607 |
if PHedgehog(Gear^.Hedgehog)^.King then |
2758
033aa644578f
Add one king per team instead of clan, kill off clan if all kings are dead. untested.
nemo
parents:
2745
diff
changeset
|
608 |
begin |
033aa644578f
Add one king per team instead of clan, kill off clan if all kings are dead. untested.
nemo
parents:
2745
diff
changeset
|
609 |
// are there any other kings left? Just doing nil check. Presumably a mortally wounded king will get reaped soon enough |
2760
420fe0344e5f
... or. just move the king check to after the gear nil
nemo
parents:
2759
diff
changeset
|
610 |
k:= false; |
2726 | 611 |
for i:= 0 to Pred(team^.Clan^.TeamsNumber) do |
2760
420fe0344e5f
... or. just move the king check to after the gear nil
nemo
parents:
2759
diff
changeset
|
612 |
if (team^.Clan^.Teams[i]^.Hedgehogs[0].Gear <> nil) then k:= true; |
420fe0344e5f
... or. just move the king check to after the gear nil
nemo
parents:
2759
diff
changeset
|
613 |
if not k then |
2758
033aa644578f
Add one king per team instead of clan, kill off clan if all kings are dead. untested.
nemo
parents:
2745
diff
changeset
|
614 |
for i:= 0 to Pred(team^.Clan^.TeamsNumber) do |
4037 | 615 |
begin |
616 |
team^.Clan^.Teams[i]^.hasGone:= true; |
|
2758
033aa644578f
Add one king per team instead of clan, kill off clan if all kings are dead. untested.
nemo
parents:
2745
diff
changeset
|
617 |
TeamGoneEffect(team^.Clan^.Teams[i]^) |
4037 | 618 |
end |
2758
033aa644578f
Add one king per team instead of clan, kill off clan if all kings are dead. untested.
nemo
parents:
2745
diff
changeset
|
619 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
620 |
inc(KilledHHs); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
621 |
RecountTeamHealth(team) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
622 |
end; |
1495 | 623 |
{$IFDEF DEBUGFILE} |
3337 | 624 |
with Gear^ do AddFileLog('Delete: #' + inttostr(uid) + ' (' + inttostr(hwRound(x)) + ',' + inttostr(hwRound(y)) + '), d(' + floattostr(dX) + ',' + floattostr(dY) + ') type = ' + EnumToStr(Kind)); |
1495 | 625 |
{$ENDIF} |
626 |
||
82 | 627 |
if CurAmmoGear = Gear then CurAmmoGear:= nil; |
4 | 628 |
if FollowGear = Gear then FollowGear:= nil; |
294 | 629 |
RemoveGearFromList(Gear); |
1515 | 630 |
Dispose(Gear) |
4 | 631 |
end; |
632 |
||
633 |
function CheckNoDamage: boolean; // returns TRUE in case of no damaged hhs |
|
634 |
var Gear: PGear; |
|
1849 | 635 |
dmg: LongInt; |
4 | 636 |
begin |
351 | 637 |
CheckNoDamage:= true; |
4 | 638 |
Gear:= GearsList; |
639 |
while Gear <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
640 |
begin |
4120
0aba28eb8e34
more button updates, wait for hogs in infinite attack mode stop moving before clearing their damage (just used an arbitrary small interval)
nemo
parents:
4111
diff
changeset
|
641 |
if (Gear^.Kind = gtHedgehog) and (((GameFlags and gfInfAttack) = 0) or ((Gear^.dX.QWordValue < _0_000004.QWordValue) and (Gear^.dY.QWordValue < _0_000004.QWordValue))) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
642 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
643 |
if (not isInMultiShoot) then inc(Gear^.Damage, Gear^.Karma); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
644 |
if (Gear^.Damage <> 0) and |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
645 |
(not Gear^.Invulnerable) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
646 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
647 |
CheckNoDamage:= false; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
648 |
uStats.HedgehogDamaged(Gear); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
649 |
dmg:= Gear^.Damage; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
650 |
if Gear^.Health < dmg then |
3453 | 651 |
begin |
652 |
Gear^.Active:= true; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
653 |
Gear^.Health:= 0 |
3453 | 654 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
655 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
656 |
dec(Gear^.Health, dmg); |
351 | 657 |
|
2017 | 658 |
if (PHedgehog(Gear^.Hedgehog)^.Team = CurrentTeam) and |
2135
0b7972dfad01
Push karma application to end of round - should avoid problems w/ plane and kamikaze
nemo
parents:
2134
diff
changeset
|
659 |
(Gear^.Damage <> Gear^.Karma) and |
2824
2d25e49bc2e8
Extra incentive to attack non-king hogs. If king loses his entourage, he loses 5hp per turn
nemo
parents:
2814
diff
changeset
|
660 |
not PHedgehog(Gear^.Hedgehog)^.King and |
3135 | 661 |
not PHedgehog(Gear^.Hedgehog)^.Effects[hePoisoned] and |
2017 | 662 |
not SuddenDeathDmg then |
663 |
Gear^.State:= Gear^.State or gstLoser; |
|
664 |
||
3461
0781275649e9
revert the restoration of non-vgt health gears. desyncs continued with it, and furthermore, occur in r3489 too
nemo
parents:
3460
diff
changeset
|
665 |
spawnHealthTagForHH(Gear, dmg); |
867 | 666 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
667 |
RenderHealth(PHedgehog(Gear^.Hedgehog)^); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
668 |
RecountTeamHealth(PHedgehog(Gear^.Hedgehog)^.Team); |
1505 | 669 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
670 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
671 |
if (not isInMultiShoot) then Gear^.Karma:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
672 |
Gear^.Damage:= 0 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
673 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
674 |
Gear:= Gear^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
675 |
end; |
4 | 676 |
end; |
677 |
||
1054 | 678 |
procedure HealthMachine; |
679 |
var Gear: PGear; |
|
2824
2d25e49bc2e8
Extra incentive to attack non-king hogs. If king loses his entourage, he loses 5hp per turn
nemo
parents:
2814
diff
changeset
|
680 |
team: PTeam; |
2d25e49bc2e8
Extra incentive to attack non-king hogs. If king loses his entourage, he loses 5hp per turn
nemo
parents:
2814
diff
changeset
|
681 |
i: LongWord; |
2d25e49bc2e8
Extra incentive to attack non-king hogs. If king loses his entourage, he loses 5hp per turn
nemo
parents:
2814
diff
changeset
|
682 |
flag: Boolean; |
3682 | 683 |
tmp: LongWord; |
1054 | 684 |
begin |
3682 | 685 |
Gear:= GearsList; |
1054 | 686 |
|
3682 | 687 |
while Gear <> nil do |
688 |
begin |
|
689 |
if Gear^.Kind = gtHedgehog then |
|
690 |
begin |
|
691 |
tmp:= 0; |
|
3112 | 692 |
if PHedgehog(Gear^.Hedgehog)^.Effects[hePoisoned] then |
4111 | 693 |
begin |
3908
1429c303858d
Can't use cHealthDecrease here for these two 'cause it isn't a generic "do some damage to hog" flag, but is rather set when SD starts
nemo
parents:
3894
diff
changeset
|
694 |
inc(tmp, ModifyDamage(5, Gear)); |
4111 | 695 |
if (GameFlags and gfResetHealth) <> 0 then dec(PHedgehog(Gear^.Hedgehog)^.InitialHealth) // does not need a minimum check since <= 1 basically disables it |
696 |
end; |
|
4153
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
697 |
if (TotalRounds > cSuddenDTurns - 1) then |
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
698 |
begin |
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
699 |
inc(tmp, cHealthDecrease); |
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
700 |
if (GameFlags and gfResetHealth) <> 0 then dec(PHedgehog(Gear^.Hedgehog)^.InitialHealth, cHealthDecrease) |
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
701 |
end; |
3109
06c089cb739c
Reduce turns to -1 to allow processing health machine on first turn. Needs testing with Sudden Death set to 0
nemo
parents:
3107
diff
changeset
|
702 |
if PHedgehog(Gear^.Hedgehog)^.King then |
06c089cb739c
Reduce turns to -1 to allow processing health machine on first turn. Needs testing with Sudden Death set to 0
nemo
parents:
3107
diff
changeset
|
703 |
begin |
06c089cb739c
Reduce turns to -1 to allow processing health machine on first turn. Needs testing with Sudden Death set to 0
nemo
parents:
3107
diff
changeset
|
704 |
flag:= false; |
06c089cb739c
Reduce turns to -1 to allow processing health machine on first turn. Needs testing with Sudden Death set to 0
nemo
parents:
3107
diff
changeset
|
705 |
team:= PHedgehog(Gear^.Hedgehog)^.Team; |
06c089cb739c
Reduce turns to -1 to allow processing health machine on first turn. Needs testing with Sudden Death set to 0
nemo
parents:
3107
diff
changeset
|
706 |
for i:= 0 to Pred(team^.HedgehogsNumber) do |
3697 | 707 |
if (team^.Hedgehogs[i].Gear <> nil) and |
708 |
(not team^.Hedgehogs[i].King) and |
|
709 |
(team^.Hedgehogs[i].Gear^.Health > team^.Hedgehogs[i].Gear^.Damage) |
|
3109
06c089cb739c
Reduce turns to -1 to allow processing health machine on first turn. Needs testing with Sudden Death set to 0
nemo
parents:
3107
diff
changeset
|
710 |
then flag:= true; |
4111 | 711 |
if not flag then |
712 |
begin |
|
713 |
inc(tmp, 5); |
|
714 |
if (GameFlags and gfResetHealth) <> 0 then dec(PHedgehog(Gear^.Hedgehog)^.InitialHealth, 5) |
|
715 |
end |
|
3109
06c089cb739c
Reduce turns to -1 to allow processing health machine on first turn. Needs testing with Sudden Death set to 0
nemo
parents:
3107
diff
changeset
|
716 |
end; |
3845
90034acb2e43
Untested fix of r3672 - should avoid hogs dying due to multiple health machine sources, and inappropriate application of karma/vampirism to these.
nemo
parents:
3836
diff
changeset
|
717 |
if tmp > 0 then |
90034acb2e43
Untested fix of r3672 - should avoid hogs dying due to multiple health machine sources, and inappropriate application of karma/vampirism to these.
nemo
parents:
3836
diff
changeset
|
718 |
begin |
90034acb2e43
Untested fix of r3672 - should avoid hogs dying due to multiple health machine sources, and inappropriate application of karma/vampirism to these.
nemo
parents:
3836
diff
changeset
|
719 |
inc(Gear^.Damage, min(tmp, max(0,Gear^.Health - 1 - Gear^.Damage))); |
90034acb2e43
Untested fix of r3672 - should avoid hogs dying due to multiple health machine sources, and inappropriate application of karma/vampirism to these.
nemo
parents:
3836
diff
changeset
|
720 |
HHHurt(Gear^.Hedgehog, dsPoison); |
90034acb2e43
Untested fix of r3672 - should avoid hogs dying due to multiple health machine sources, and inappropriate application of karma/vampirism to these.
nemo
parents:
3836
diff
changeset
|
721 |
end |
3682 | 722 |
end; |
1054 | 723 |
|
3682 | 724 |
Gear:= Gear^.NextGear |
725 |
end; |
|
1054 | 726 |
end; |
727 |
||
4 | 728 |
procedure ProcessGears; |
614 | 729 |
const delay: LongWord = 0; |
3949
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
730 |
delay2: LongWord = 0; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
731 |
step: (stDelay, stChDmg, stSweep, stTurnReact, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
732 |
stAfterDelay, stChWin, stWater, stChWin2, stHealth, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
733 |
stSpawn, stNTurn) = stDelay; |
4 | 734 |
var Gear, t: PGear; |
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
735 |
i, AliveCount: LongInt; |
3331 | 736 |
s: shortstring; |
4 | 737 |
begin |
868 | 738 |
PrvInactive:= AllInactive; |
4 | 739 |
AllInactive:= true; |
1495 | 740 |
|
2940 | 741 |
if (StepSoundTimer > 0) and (StepSoundChannel < 0) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
742 |
StepSoundChannel:= LoopSound(sndSteps) |
2940 | 743 |
else if (StepSoundTimer = 0) and (StepSoundChannel > -1) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
744 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
745 |
StopSound(StepSoundChannel); |
2993
d83edb74e92d
Remove animation on jumping/resuming walk, only leave it in on weapon switch
nemo
parents:
2991
diff
changeset
|
746 |
StepSoundChannel:= -1 |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
747 |
end; |
2940 | 748 |
|
749 |
if StepSoundTimer > 0 then |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
750 |
dec(StepSoundTimer, 1); |
2940 | 751 |
|
4 | 752 |
t:= GearsList; |
1054 | 753 |
while t <> nil do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
754 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
755 |
Gear:= t; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
756 |
t:= Gear^.NextGear; |
3123 | 757 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
758 |
if Gear^.Active then |
2204
526f8165acce
Smaxx' idea of timers, reworked just a tad. Might need variable for offset, but seems ok for now
nemo
parents:
2186
diff
changeset
|
759 |
begin |
526f8165acce
Smaxx' idea of timers, reworked just a tad. Might need variable for offset, but seems ok for now
nemo
parents:
2186
diff
changeset
|
760 |
if Gear^.RenderTimer and (Gear^.Timer > 500) and ((Gear^.Timer mod 1000) = 0) then |
526f8165acce
Smaxx' idea of timers, reworked just a tad. Might need variable for offset, but seems ok for now
nemo
parents:
2186
diff
changeset
|
761 |
begin |
2376 | 762 |
if Gear^.Tex <> nil then FreeTexture(Gear^.Tex); |
2619 | 763 |
Gear^.Tex:= RenderStringTex(inttostr(Gear^.Timer div 1000), cWhiteColor, fntSmall); |
2204
526f8165acce
Smaxx' idea of timers, reworked just a tad. Might need variable for offset, but seems ok for now
nemo
parents:
2186
diff
changeset
|
764 |
end; |
526f8165acce
Smaxx' idea of timers, reworked just a tad. Might need variable for offset, but seems ok for now
nemo
parents:
2186
diff
changeset
|
765 |
Gear^.doStep(Gear); |
3848 | 766 |
// might be useful later |
767 |
//ScriptCall('OnGearStep', Gear^.uid); |
|
2204
526f8165acce
Smaxx' idea of timers, reworked just a tad. Might need variable for offset, but seems ok for now
nemo
parents:
2186
diff
changeset
|
768 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
769 |
end; |
89 | 770 |
|
4 | 771 |
if AllInactive then |
1343 | 772 |
case step of |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
773 |
stDelay: begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
774 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
775 |
delay:= cInactDelay |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
776 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
777 |
dec(delay); |
614 | 778 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
779 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
780 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
781 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
782 |
stChDmg: if CheckNoDamage then inc(step) else step:= stDelay; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
783 |
stSweep: if SweepDirty then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
784 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
785 |
SetAllToActive; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
786 |
step:= stChDmg |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
787 |
end else inc(step); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
788 |
stTurnReact: begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
789 |
if (not bBetweenTurns) and (not isInMultiShoot) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
790 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
791 |
uStats.TurnReaction; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
792 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
793 |
end else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
794 |
inc(step, 2); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
795 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
796 |
stAfterDelay: begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
797 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
798 |
delay:= cInactDelay |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
799 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
800 |
dec(delay); |
815 | 801 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
802 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
803 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
804 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
805 |
stChWin: begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
806 |
CheckForWin; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
807 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
808 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
809 |
stWater: if (not bBetweenTurns) and (not isInMultiShoot) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
810 |
begin |
3331 | 811 |
if TotalRounds = cSuddenDTurns + 1 then bWaterRising:= true; |
1055
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset
|
812 |
|
4153
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
813 |
if bWaterRising and (cWaterRise > 0) then |
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
814 |
AddGear(0, 0, gtWaterUp, 0, _0, _0, 0)^.Tag:= cWaterRise; |
1055
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset
|
815 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
816 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
817 |
end else inc(step); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
818 |
stChWin2: begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
819 |
CheckForWin; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
820 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
821 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
822 |
stHealth: begin |
4215
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
823 |
if (cWaterRise <> 0) or (cHealthDecrease <> 0) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
824 |
begin |
4215
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
825 |
if (TotalRounds = cSuddenDTurns) and not SuddenDeathDmg and not isInMultiShoot then |
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
826 |
begin |
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
827 |
SuddenDeathDmg:= true; |
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
828 |
AddCaption(trmsg[sidSuddenDeath], cWhiteColor, capgrpGameState); |
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
829 |
playSound(sndSuddenDeath) |
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
830 |
end |
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
831 |
else if (TotalRounds < cSuddenDTurns) and not isInMultiShoot then |
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
832 |
begin |
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
833 |
i:= cSuddenDTurns - TotalRounds; |
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
834 |
s:= inttostr(i); |
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
835 |
if i = 1 then |
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
836 |
AddCaption(trmsg[sidRoundSD], cWhiteColor, capgrpGameState) |
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
837 |
else if i in [2, 5, 10, 15, 20, 25, 50, 100] then |
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
838 |
AddCaption(Format(trmsg[sidRoundsSD], s), cWhiteColor, capgrpGameState); |
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
839 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
840 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
841 |
if bBetweenTurns |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
842 |
or isInMultiShoot |
3109
06c089cb739c
Reduce turns to -1 to allow processing health machine on first turn. Needs testing with Sudden Death set to 0
nemo
parents:
3107
diff
changeset
|
843 |
or (TotalRounds = -1) then inc(step) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
844 |
else begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
845 |
bBetweenTurns:= true; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
846 |
HealthMachine; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
847 |
step:= stChDmg |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
848 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
849 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
850 |
stSpawn: begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
851 |
if not isInMultiShoot then SpawnBoxOfSmth; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
852 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
853 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
854 |
stNTurn: begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
855 |
if isInMultiShoot then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
856 |
isInMultiShoot:= false |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
857 |
else begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
858 |
// delayed till after 0.9.12 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
859 |
// reset to default zoom |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
860 |
//ZoomValue:= ZoomDefault; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
861 |
with CurrentHedgehog^ do |
3697 | 862 |
if (Gear <> nil) |
2611 | 863 |
and ((Gear^.State and gstAttacked) = 0) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
864 |
and (MultiShootAttacks > 0) then OnUsedAmmo(CurrentHedgehog^); |
3697 | 865 |
|
3396
e5b3e5f2818e
More portal changes. Allows for a multishoot utility. Hopefully not breaking anything.
nemo
parents:
3390
diff
changeset
|
866 |
EndTurnCleanup; |
2376 | 867 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
868 |
FreeActionsList; // could send -left, -right and similar commands, so should be called before /nextturn |
1298 | 869 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
870 |
ParseCommand('/nextturn', true); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
871 |
SwitchHedgehog; |
1298 | 872 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
873 |
AfterSwitchHedgehog; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
874 |
bBetweenTurns:= false |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
875 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
876 |
step:= Low(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
877 |
end; |
3949
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
878 |
end |
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
879 |
else if ((GameFlags and gfInfAttack) <> 0) then |
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
880 |
begin |
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
881 |
if delay2 = 0 then |
3951
c9a63db3e603
Correct another bug in slot switching, adjust width of theme list, really truly fix reset of weps (I hope) should also fix infinite teleport bug in place hogs mode. Slow update of health to 5s for inf attack mode.
nemo
parents:
3949
diff
changeset
|
882 |
delay2:= cInactDelay * 4 |
3949
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
883 |
else |
3957 | 884 |
begin |
3949
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
885 |
dec(delay2); |
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
886 |
|
3957 | 887 |
if ((delay2 mod cInactDelay) = 0) and (CurrentHedgehog <> nil) and (CurrentHedgehog^.Gear <> nil) then |
888 |
CurrentHedgehog^.Gear^.State:= CurrentHedgehog^.Gear^.State and not gstAttacked; |
|
889 |
if delay2 = 0 then |
|
890 |
begin |
|
891 |
SweepDirty; |
|
892 |
CheckNoDamage; |
|
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
893 |
AliveCount:= 0; // shorter version of check for win to allow typical step activity to proceed |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
894 |
for i:= 0 to Pred(ClansCount) do |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
895 |
if ClansArray[i]^.ClanHealth > 0 then inc(AliveCount); |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
896 |
if (AliveCount <= 1) and ((GameFlags and gfOneClanMode) = 0) then |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
897 |
begin |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
898 |
step:= stChDmg; |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
899 |
TurnTimeLeft:= 0 |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
900 |
end |
3957 | 901 |
end |
3949
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
902 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
903 |
end; |
15 | 904 |
|
4 | 905 |
if TurnTimeLeft > 0 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
906 |
if CurrentHedgehog^.Gear <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
907 |
if ((CurrentHedgehog^.Gear^.State and gstAttacking) = 0) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
908 |
and not isInMultiShoot then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
909 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
910 |
if (TurnTimeLeft = 5000) |
4198 | 911 |
and (cHedgehogTurnTime >= 10000) |
2770
851313907bcb
Decrease king buff from 150% bonus to 50% bonus, disable warning sound in placement mode
nemo
parents:
2762
diff
changeset
|
912 |
and (not PlacingHogs) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
913 |
and (CurrentHedgehog^.Gear <> nil) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
914 |
and ((CurrentHedgehog^.Gear^.State and gstAttacked) = 0) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
915 |
PlaySound(sndHurry, CurrentTeam^.voicepack); |
3799 | 916 |
if ReadyTimeLeft > 0 then |
917 |
begin |
|
918 |
if ReadyTimeLeft = 2000 then |
|
919 |
PlaySound(sndComeonthen, CurrentTeam^.voicepack); |
|
920 |
dec(ReadyTimeLeft) |
|
921 |
end |
|
922 |
else |
|
923 |
dec(TurnTimeLeft) |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
924 |
end; |
351 | 925 |
|
2621
956ff066f3a5
Fix desync when playing with AI via network, occuring in certain conditions
unc0rr
parents:
2619
diff
changeset
|
926 |
if skipFlag then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
927 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
928 |
TurnTimeLeft:= 0; |
3784
75aa91bea32b
Extend statistics collection (TeamKills, TurnSkips, TeamDamage)
burp
parents:
3775
diff
changeset
|
929 |
skipFlag:= false; |
75aa91bea32b
Extend statistics collection (TeamKills, TurnSkips, TeamDamage)
burp
parents:
3775
diff
changeset
|
930 |
inc(CurrentHedgehog^.Team^.stats.TurnSkips); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
931 |
end; |
2621
956ff066f3a5
Fix desync when playing with AI via network, occuring in certain conditions
unc0rr
parents:
2619
diff
changeset
|
932 |
|
2134 | 933 |
if ((GameTicks and $FFFF) = $FFFF) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
934 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
935 |
if (not CurrentTeam^.ExtDriven) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
936 |
SendIPCTimeInc; |
2134 | 937 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
938 |
if (not CurrentTeam^.ExtDriven) or CurrentTeam^.hasGone then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
939 |
inc(hiTicks) // we do not recieve a message for this |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
940 |
end; |
656
6d6d9d7b1054
Fix network game bug caused by recent protocol changes
unc0rr
parents:
651
diff
changeset
|
941 |
|
515 | 942 |
inc(GameTicks) |
4 | 943 |
end; |
944 |
||
3396
e5b3e5f2818e
More portal changes. Allows for a multishoot utility. Hopefully not breaking anything.
nemo
parents:
3390
diff
changeset
|
945 |
//Purpose, to reset all transient attributes toggled by a utility and clean up various gears and effects at end of turn |
1854 | 946 |
//If any of these are set as permanent toggles in the frontend, that needs to be checked and skipped here. |
3396
e5b3e5f2818e
More portal changes. Allows for a multishoot utility. Hopefully not breaking anything.
nemo
parents:
3390
diff
changeset
|
947 |
procedure EndTurnCleanup; |
1865
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset
|
948 |
var i: LongInt; |
3480
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
949 |
t: PGear; |
1849 | 950 |
begin |
2221 | 951 |
SpeechText:= ''; // in case it has not been consumed |
2017 | 952 |
|
1895 | 953 |
if (GameFlags and gfLowGravity) = 0 then |
3355
dc9e61e67484
cWindSpeed recalculation assumed GetRandom returns a value between 0.0-1.0 while in fact is in the 0.0-0.5 range; Halve cMaxWindSpeed to compensate.
palewolf
parents:
3350
diff
changeset
|
954 |
cGravity:= cMaxWindSpeed * 2; |
1895 | 955 |
|
2017 | 956 |
if (GameFlags and gfVampiric) = 0 then |
957 |
cVampiric:= false; |
|
958 |
||
1849 | 959 |
cDamageModifier:= _1; |
1895 | 960 |
|
961 |
if (GameFlags and gfLaserSight) = 0 then |
|
962 |
cLaserSighting:= false; |
|
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
963 |
|
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
964 |
if (GameFlags and gfArtillery) = 0 then |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
965 |
cArtillery:= false; |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
966 |
// have to sweep *all* current team hedgehogs since it is theoretically possible if you have enough invulnerabilities and switch turns to make your entire team invulnerable |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
967 |
if (CurrentTeam <> nil) then |
4099 | 968 |
with CurrentTeam^ do |
969 |
for i:= 0 to cMaxHHIndex do |
|
970 |
with Hedgehogs[i] do |
|
971 |
begin |
|
972 |
if (SpeechGear <> nil) then |
|
973 |
begin |
|
974 |
DeleteVisualGear(SpeechGear); // remove to restore persisting beyond end of turn. Tiy says was too much of a gameplay issue |
|
975 |
SpeechGear:= nil |
|
976 |
end; |
|
2045
b0588498bc3a
- Fix network (my crappy fault, triggered by nemo's patch)
unc0rr
parents:
2042
diff
changeset
|
977 |
|
4099 | 978 |
if (Gear <> nil) then |
979 |
begin |
|
980 |
if (GameFlags and gfInvulnerable) = 0 then |
|
981 |
Gear^.Invulnerable:= false; |
|
982 |
end; |
|
983 |
end; |
|
3480
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
984 |
t:= GearsList; |
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
985 |
while t <> nil do |
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
986 |
begin |
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
987 |
t^.PortalCounter:= 0; |
4101
c5967f360beb
Apply the reset to all hogs on all teams in uGears. Make InitialHealth same type as Health to avoid issues w/ initial health > 255. Update InitialHealth with the king buff.
nemo
parents:
4099
diff
changeset
|
988 |
if ((GameFlags and gfResetHealth) <> 0) and (t^.Kind = gtHedgehog) and (t^.Health < PHedgehog(t^.Hedgehog)^.InitialHealth) then |
c5967f360beb
Apply the reset to all hogs on all teams in uGears. Make InitialHealth same type as Health to avoid issues w/ initial health > 255. Update InitialHealth with the king buff.
nemo
parents:
4099
diff
changeset
|
989 |
begin |
c5967f360beb
Apply the reset to all hogs on all teams in uGears. Make InitialHealth same type as Health to avoid issues w/ initial health > 255. Update InitialHealth with the king buff.
nemo
parents:
4099
diff
changeset
|
990 |
t^.Health:= PHedgehog(t^.Hedgehog)^.InitialHealth; |
c5967f360beb
Apply the reset to all hogs on all teams in uGears. Make InitialHealth same type as Health to avoid issues w/ initial health > 255. Update InitialHealth with the king buff.
nemo
parents:
4099
diff
changeset
|
991 |
RenderHealth(PHedgehog(t^.Hedgehog)^); |
c5967f360beb
Apply the reset to all hogs on all teams in uGears. Make InitialHealth same type as Health to avoid issues w/ initial health > 255. Update InitialHealth with the king buff.
nemo
parents:
4099
diff
changeset
|
992 |
end; |
3480
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
993 |
t:= t^.NextGear |
3946
41e06b74c991
Enable resetting of weapons after each turn - useful in combination with a limited weaponset and unlimited attacks
nemo
parents:
3908
diff
changeset
|
994 |
end; |
41e06b74c991
Enable resetting of weapons after each turn - useful in combination with a limited weaponset and unlimited attacks
nemo
parents:
3908
diff
changeset
|
995 |
|
4344
23ab3bdbf218
This should fix Chip's bug with unlimited teleports. Also remove more hog placement special behaviour and just use ResetWeapons with a check against PlacingHogs mode
nemo
parents:
4337
diff
changeset
|
996 |
if ((GameFlags and gfResetWeps) <> 0) and not PlacingHogs then |
4099 | 997 |
ResetWeapons; |
4101
c5967f360beb
Apply the reset to all hogs on all teams in uGears. Make InitialHealth same type as Health to avoid issues w/ initial health > 255. Update InitialHealth with the king buff.
nemo
parents:
4099
diff
changeset
|
998 |
|
4099 | 999 |
if (GameFlags and gfResetHealth) <> 0 then |
4101
c5967f360beb
Apply the reset to all hogs on all teams in uGears. Make InitialHealth same type as Health to avoid issues w/ initial health > 255. Update InitialHealth with the king buff.
nemo
parents:
4099
diff
changeset
|
1000 |
for i:= 0 to Pred(TeamsCount) do |
c5967f360beb
Apply the reset to all hogs on all teams in uGears. Make InitialHealth same type as Health to avoid issues w/ initial health > 255. Update InitialHealth with the king buff.
nemo
parents:
4099
diff
changeset
|
1001 |
RecountTeamHealth(TeamsArray[i]) |
1849 | 1002 |
end; |
2045
b0588498bc3a
- Fix network (my crappy fault, triggered by nemo's patch)
unc0rr
parents:
2042
diff
changeset
|
1003 |
|
3682 | 1004 |
procedure ApplyDamage(Gear: PGear; Damage: Longword; Source: TDamageSource); |
2017 | 1005 |
var s: shortstring; |
2428 | 1006 |
vampDmg, tmpDmg, i: Longword; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1007 |
vg: PVisualGear; |
2017 | 1008 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1009 |
if (Gear^.Kind = gtHedgehog) and (Damage>=1) then |
2017 | 1010 |
begin |
3682 | 1011 |
HHHurt(Gear^.Hedgehog, Source); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1012 |
AddDamageTag(hwRound(Gear^.X), hwRound(Gear^.Y), Damage, PHedgehog(Gear^.Hedgehog)^.Team^.Clan^.Color); |
2067
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1013 |
tmpDmg:= min(Damage, max(0,Gear^.Health-Gear^.Damage)); |
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1014 |
if (Gear <> CurrentHedgehog^.Gear) and (CurrentHedgehog^.Gear <> nil) and (tmpDmg >= 1) then |
2017 | 1015 |
begin |
1016 |
if cVampiric then |
|
1017 |
begin |
|
2067
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1018 |
vampDmg:= hwRound(int2hwFloat(tmpDmg)*_0_8); |
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1019 |
if vampDmg >= 1 then |
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1020 |
begin |
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1021 |
// was considering pulsing on attack, Tiy thinks it should be permanent while in play |
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1022 |
//CurrentHedgehog^.Gear^.State:= CurrentHedgehog^.Gear^.State or gstVampiric; |
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1023 |
inc(CurrentHedgehog^.Gear^.Health,vampDmg); |
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1024 |
str(vampDmg, s); |
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1025 |
s:= '+' + s; |
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1026 |
AddCaption(s, CurrentHedgehog^.Team^.Clan^.Color, capgrpAmmoinfo); |
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1027 |
RenderHealth(CurrentHedgehog^); |
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1028 |
RecountTeamHealth(CurrentHedgehog^.Team); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1029 |
i:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1030 |
while i < vampDmg do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1031 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1032 |
vg:= AddVisualGear(hwRound(CurrentHedgehog^.Gear^.X), hwRound(CurrentHedgehog^.Gear^.Y), vgtHealth); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1033 |
if vg <> nil then vg^.Frame:= 10; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1034 |
inc(i, 5); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1035 |
end; |
2067
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1036 |
end |
2017 | 1037 |
end; |
2376 | 1038 |
if ((GameFlags and gfKarma) <> 0) and |
2017 | 1039 |
((GameFlags and gfInvulnerable) = 0) and |
1040 |
not CurrentHedgehog^.Gear^.Invulnerable then |
|
1041 |
begin // this cannot just use Damage or it interrupts shotgun and gets you called stupid |
|
2135
0b7972dfad01
Push karma application to end of round - should avoid problems w/ plane and kamikaze
nemo
parents:
2134
diff
changeset
|
1042 |
inc(CurrentHedgehog^.Gear^.Karma, tmpDmg); |
3461
0781275649e9
revert the restoration of non-vgt health gears. desyncs continued with it, and furthermore, occur in r3489 too
nemo
parents:
3460
diff
changeset
|
1043 |
spawnHealthTagForHH(CurrentHedgehog^.Gear, tmpDmg); |
2017 | 1044 |
end; |
1045 |
end; |
|
1046 |
end; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1047 |
inc(Gear^.Damage, Damage); |
3848 | 1048 |
ScriptCall('OnGearDamage', Gear^.UID, Damage); |
2017 | 1049 |
end; |
1849 | 1050 |
|
4 | 1051 |
procedure SetAllToActive; |
1052 |
var t: PGear; |
|
1053 |
begin |
|
1054 |
AllInactive:= false; |
|
1055 |
t:= GearsList; |
|
351 | 1056 |
while t <> nil do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1057 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1058 |
t^.Active:= true; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1059 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1060 |
end |
4 | 1061 |
end; |
1062 |
||
1063 |
procedure SetAllHHToActive; |
|
1064 |
var t: PGear; |
|
1065 |
begin |
|
1066 |
AllInactive:= false; |
|
1067 |
t:= GearsList; |
|
351 | 1068 |
while t <> nil do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1069 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1070 |
if t^.Kind = gtHedgehog then t^.Active:= true; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1071 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1072 |
end |
4 | 1073 |
end; |
1074 |
||
2811 | 1075 |
procedure DrawAltWeapon(Gear: PGear; sx, sy: LongInt); |
2802 | 1076 |
begin |
1077 |
with PHedgehog(Gear^.Hedgehog)^ do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1078 |
begin |
3836
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3832
diff
changeset
|
1079 |
if not (((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_AltUse) <> 0) and ((Gear^.State and gstAttacked) = 0)) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1080 |
exit; |
4159
64e677349124
REmove stupid int64 conversions, provide real fixes to compiler hints
unc0rr
parents:
4155
diff
changeset
|
1081 |
DrawTexture(sx + 16, sy + 16, ropeIconTex); |
64e677349124
REmove stupid int64 conversions, provide real fixes to compiler hints
unc0rr
parents:
4155
diff
changeset
|
1082 |
DrawTextureF(SpritesData[sprAMAmmos].Texture, 0.75, sx + 30, sy + 30, ord(CurAmmoType) - 1, 1, 32, 32); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1083 |
end; |
2802 | 1084 |
end; |
1085 |
||
2362 | 1086 |
procedure DrawRopeLinesRQ(Gear: PGear); |
1087 |
begin |
|
1088 |
with RopePoints do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1089 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1090 |
rounded[Count].X:= hwRound(Gear^.X); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1091 |
rounded[Count].Y:= hwRound(Gear^.Y); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1092 |
rounded[Count + 1].X:= hwRound(PHedgehog(Gear^.Hedgehog)^.Gear^.X); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1093 |
rounded[Count + 1].Y:= hwRound(PHedgehog(Gear^.Hedgehog)^.Gear^.Y); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1094 |
end; |
2362 | 1095 |
|
2365 | 1096 |
if (RopePoints.Count > 0) or (Gear^.Elasticity.QWordValue > 0) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1097 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1098 |
glDisable(GL_TEXTURE_2D); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1099 |
//glEnable(GL_LINE_SMOOTH); |
2365 | 1100 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1101 |
glPushMatrix; |
2365 | 1102 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1103 |
glTranslatef(WorldDx, WorldDy, 0); |
2376 | 1104 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1105 |
glLineWidth(4.0); |
2362 | 1106 |
|
3390 | 1107 |
Tint($C0, $C0, $C0, $FF); |
2362 | 1108 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1109 |
glVertexPointer(2, GL_FLOAT, 0, @RopePoints.rounded[0]); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1110 |
glDrawArrays(GL_LINE_STRIP, 0, RopePoints.Count + 2); |
3390 | 1111 |
Tint($FF, $FF, $FF, $FF); |
2365 | 1112 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1113 |
glPopMatrix; |
2376 | 1114 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1115 |
glEnable(GL_TEXTURE_2D); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1116 |
//glDisable(GL_LINE_SMOOTH) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1117 |
end |
2362 | 1118 |
end; |
1119 |
||
1120 |
procedure DrawRope(Gear: PGear); |
|
1121 |
var roplen: LongInt; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1122 |
i: Longword; |
2362 | 1123 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1124 |
procedure DrawRopeLine(X1, Y1, X2, Y2: LongInt); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1125 |
var eX, eY, dX, dY: LongInt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1126 |
i, sX, sY, x, y, d: LongInt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1127 |
b: boolean; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1128 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1129 |
if (X1 = X2) and (Y1 = Y2) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1130 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1131 |
//OutError('WARNING: zero length rope line!', false); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1132 |
exit |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1133 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1134 |
eX:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1135 |
eY:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1136 |
dX:= X2 - X1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1137 |
dY:= Y2 - Y1; |
2362 | 1138 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1139 |
if (dX > 0) then sX:= 1 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1140 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1141 |
if (dX < 0) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1142 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1143 |
sX:= -1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1144 |
dX:= -dX |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1145 |
end else sX:= dX; |
2362 | 1146 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1147 |
if (dY > 0) then sY:= 1 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1148 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1149 |
if (dY < 0) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1150 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1151 |
sY:= -1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1152 |
dY:= -dY |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1153 |
end else sY:= dY; |
2362 | 1154 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1155 |
if (dX > dY) then d:= dX |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1156 |
else d:= dY; |
2362 | 1157 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1158 |
x:= X1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1159 |
y:= Y1; |
2362 | 1160 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1161 |
for i:= 0 to d do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1162 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1163 |
inc(eX, dX); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1164 |
inc(eY, dY); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1165 |
b:= false; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1166 |
if (eX > d) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1167 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1168 |
dec(eX, d); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1169 |
inc(x, sX); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1170 |
b:= true |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1171 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1172 |
if (eY > d) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1173 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1174 |
dec(eY, d); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1175 |
inc(y, sY); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1176 |
b:= true |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1177 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1178 |
if b then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1179 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1180 |
inc(roplen); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1181 |
if (roplen mod 4) = 0 then DrawSprite(sprRopeNode, x - 2, y - 2, 0) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1182 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1183 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1184 |
end; |
2362 | 1185 |
begin |
3594
aeca3d8f1b29
turn cReducedQuality into a LongInt and provide a series of quality flags (and best of all, this is still compatible with current frontend)
koda
parents:
3580
diff
changeset
|
1186 |
if (cReducedQuality and rqSimpleRope) <> 0 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1187 |
DrawRopeLinesRQ(Gear) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1188 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1189 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1190 |
roplen:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1191 |
if RopePoints.Count > 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1192 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1193 |
i:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1194 |
while i < Pred(RopePoints.Count) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1195 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1196 |
DrawRopeLine(hwRound(RopePoints.ar[i].X) + WorldDx, hwRound(RopePoints.ar[i].Y) + WorldDy, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1197 |
hwRound(RopePoints.ar[Succ(i)].X) + WorldDx, hwRound(RopePoints.ar[Succ(i)].Y) + WorldDy); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1198 |
inc(i) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1199 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1200 |
DrawRopeLine(hwRound(RopePoints.ar[i].X) + WorldDx, hwRound(RopePoints.ar[i].Y) + WorldDy, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1201 |
hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1202 |
DrawRopeLine(hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1203 |
hwRound(PHedgehog(Gear^.Hedgehog)^.Gear^.X) + WorldDx, hwRound(PHedgehog(Gear^.Hedgehog)^.Gear^.Y) + WorldDy); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1204 |
end else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1205 |
if Gear^.Elasticity.QWordValue > 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1206 |
DrawRopeLine(hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1207 |
hwRound(PHedgehog(Gear^.Hedgehog)^.Gear^.X) + WorldDx, hwRound(PHedgehog(Gear^.Hedgehog)^.Gear^.Y) + WorldDy); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1208 |
end; |
2362 | 1209 |
|
1210 |
||
1211 |
if RopePoints.Count > 0 then |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1212 |
DrawRotated(sprRopeHook, hwRound(RopePoints.ar[0].X) + WorldDx, hwRound(RopePoints.ar[0].Y) + WorldDy, 1, RopePoints.HookAngle) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1213 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1214 |
if Gear^.Elasticity.QWordValue > 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1215 |
DrawRotated(sprRopeHook, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, 0, DxDy2Angle(Gear^.dY, Gear^.dX)); |
2362 | 1216 |
end; |
1217 |
||
3387
733f4001b8b9
Break out DrawHH/DrawGear to reduce scrolling in uGears.pas, add portal graphics
nemo
parents:
3384
diff
changeset
|
1218 |
{$INCLUDE "GearDrawing.inc"} |
4 | 1219 |
|
1220 |
procedure FreeGearsList; |
|
1221 |
var t, tt: PGear; |
|
1222 |
begin |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1223 |
tt:= GearsList; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1224 |
GearsList:= nil; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1225 |
while tt <> nil do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1226 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1227 |
t:= tt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1228 |
tt:= tt^.NextGear; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1229 |
Dispose(t) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1230 |
end; |
4 | 1231 |
end; |
1232 |
||
10 | 1233 |
procedure AddMiscGears; |
371 | 1234 |
var i: LongInt; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1235 |
Gear: PGear; |
4 | 1236 |
begin |
498 | 1237 |
AddGear(0, 0, gtATStartGame, 0, _0, _0, 2000); |
1435
d4b32ee3caa6
Fix using freed memory (could be the cause of queue error problem and other bugs)
unc0rr
parents:
1434
diff
changeset
|
1238 |
|
2428 | 1239 |
if (TrainingFlags and tfSpawnTargets) <> 0 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1240 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1241 |
TrainingTargetGear:= AddGear(0, 0, gtTarget, 0, _0, _0, 0); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1242 |
FindPlace(TrainingTargetGear, false, 0, LAND_WIDTH); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1243 |
end; |
2428 | 1244 |
|
4148
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
1245 |
for i:= 0 to Pred(cLandMines) do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1246 |
begin |
4148
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
1247 |
Gear:= AddGear(0, 0, gtMine, 0, _0, _0, 0); |
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
1248 |
FindPlace(Gear, false, 0, LAND_WIDTH); |
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
1249 |
end; |
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
1250 |
for i:= 0 to Pred(cExplosives) do |
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
1251 |
begin |
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
1252 |
Gear:= AddGear(0, 0, gtExplosives, 0, _0, _0, 0); |
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
1253 |
FindPlace(Gear, false, 0, LAND_WIDTH); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1254 |
end; |
1895 | 1255 |
|
1256 |
if (GameFlags and gfLowGravity) <> 0 then |
|
3355
dc9e61e67484
cWindSpeed recalculation assumed GetRandom returns a value between 0.0-1.0 while in fact is in the 0.0-0.5 range; Halve cMaxWindSpeed to compensate.
palewolf
parents:
3350
diff
changeset
|
1257 |
cGravity:= cMaxWindSpeed; |
1895 | 1258 |
|
2017 | 1259 |
if (GameFlags and gfVampiric) <> 0 then |
1260 |
cVampiric:= true; |
|
1261 |
||
1895 | 1262 |
Gear:= GearsList; |
1263 |
if (GameFlags and gfInvulnerable) <> 0 then |
|
1264 |
while Gear <> nil do |
|
1265 |
begin |
|
1266 |
Gear^.Invulnerable:= true; // this is only checked on hogs right now, so no need for gear type check |
|
1267 |
Gear:= Gear^.NextGear |
|
1268 |
end; |
|
1269 |
||
1270 |
if (GameFlags and gfLaserSight) <> 0 then |
|
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
1271 |
cLaserSighting:= true; |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
1272 |
|
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
1273 |
if (GameFlags and gfArtillery) <> 0 then |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
1274 |
cArtillery:= true |
4 | 1275 |
end; |
1276 |
||
371 | 1277 |
procedure doMakeExplosion(X, Y, Radius: LongInt; Mask: LongWord); |
3475 | 1278 |
begin |
1279 |
doMakeExplosion(X, Y, Radius, Mask, $FFFFFFFF); |
|
1280 |
end; |
|
1281 |
||
1282 |
procedure doMakeExplosion(X, Y, Radius: LongInt; Mask, Tint: LongWord); |
|
4 | 1283 |
var Gear: PGear; |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1284 |
dmg, dmgRadius, dmgBase: LongInt; |
3322 | 1285 |
fX, fY: hwFloat; |
3475 | 1286 |
vg: PVisualGear; |
3689 | 1287 |
i, cnt: LongInt; |
4 | 1288 |
begin |
1289 |
TargetPoint.X:= NoPointX; |
|
1434 | 1290 |
{$IFDEF DEBUGFILE}if Radius > 4 then AddFileLog('Explosion: at (' + inttostr(x) + ',' + inttostr(y) + ')');{$ENDIF} |
3083
8da8f2515221
Eliminate flake kick on themes with no flakes, more than 200 flakes (city) or explosions of 25 or smaller
nemo
parents:
3080
diff
changeset
|
1291 |
if Radius > 25 then KickFlakes(Radius, X, Y); |
8da8f2515221
Eliminate flake kick on themes with no flakes, more than 200 flakes (city) or explosions of 25 or smaller
nemo
parents:
3080
diff
changeset
|
1292 |
|
3032 | 1293 |
if ((Mask and EXPLNoGfx) = 0) then |
1294 |
begin |
|
3475 | 1295 |
vg:= nil; |
1296 |
if Radius > 50 then vg:= AddVisualGear(X, Y, vgtBigExplosion) |
|
1297 |
else if Radius > 10 then vg:= AddVisualGear(X, Y, vgtExplosion); |
|
1298 |
if vg <> nil then |
|
1299 |
vg^.Tint:= Tint; |
|
3032 | 1300 |
end; |
2745 | 1301 |
if (Mask and EXPLAutoSound) <> 0 then PlaySound(sndExplosion); |
1433 | 1302 |
|
1303 |
if (Mask and EXPLAllDamageInRadius) = 0 then |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1304 |
dmgRadius:= Radius shl 1 |
1433 | 1305 |
else |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1306 |
dmgRadius:= Radius; |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1307 |
dmgBase:= dmgRadius + cHHRadius div 2; |
3322 | 1308 |
fX:= int2hwFloat(X); |
1309 |
fY:= int2hwFloat(Y); |
|
4 | 1310 |
Gear:= GearsList; |
1311 |
while Gear <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1312 |
begin |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1313 |
dmg:= 0; |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1314 |
//dmg:= dmgRadius + cHHRadius div 2 - hwRound(Distance(Gear^.X - int2hwFloat(X), Gear^.Y - int2hwFloat(Y))); |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1315 |
//if (dmg > 1) and |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1316 |
if (Gear^.State and gstNoDamage) = 0 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1317 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1318 |
case Gear^.Kind of |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1319 |
gtHedgehog, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1320 |
gtMine, |
3710 | 1321 |
gtSMine, |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1322 |
gtCase, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1323 |
gtTarget, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1324 |
gtFlame, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1325 |
gtExplosives: begin |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1326 |
// Run the calcs only once we know we have a type that will need damage |
3322 | 1327 |
if hwRound(hwAbs(Gear^.X-fX)+hwAbs(Gear^.Y-fY)) < dmgBase then |
1328 |
dmg:= dmgBase - hwRound(Distance(Gear^.X - fX, Gear^.Y - fY)); |
|
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1329 |
if dmg > 1 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1330 |
begin |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1331 |
dmg:= ModifyDamage(min(dmg div 2, Radius), Gear); |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1332 |
//{$IFDEF DEBUGFILE}AddFileLog('Damage: ' + inttostr(dmg));{$ENDIF} |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1333 |
if (Mask and EXPLNoDamage) = 0 then |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1334 |
begin |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1335 |
if not Gear^.Invulnerable then |
3682 | 1336 |
ApplyDamage(Gear, dmg, dsExplosion) |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1337 |
else |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1338 |
Gear^.State:= Gear^.State or gstWinner; |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1339 |
end; |
3712 | 1340 |
if ((Mask and EXPLDoNotTouchAny) = 0) and (((Mask and EXPLDoNotTouchHH) = 0) or (Gear^.Kind <> gtHedgehog)) then |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1341 |
begin |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1342 |
DeleteCI(Gear); |
3322 | 1343 |
Gear^.dX:= Gear^.dX + SignAs(_0_005 * dmg + cHHKick, Gear^.X - fX); |
1344 |
Gear^.dY:= Gear^.dY + SignAs(_0_005 * dmg + cHHKick, Gear^.Y - fY); |
|
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1345 |
Gear^.State:= (Gear^.State or gstMoving) and (not gstLoser); |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1346 |
if not Gear^.Invulnerable then |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1347 |
Gear^.State:= (Gear^.State or gstMoving) and (not gstWinner); |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1348 |
Gear^.Active:= true; |
3997 | 1349 |
if Gear^.Kind <> gtFlame then FollowGear:= Gear |
3112 | 1350 |
end; |
1351 |
if ((Mask and EXPLPoisoned) <> 0) and (Gear^.Kind = gtHedgehog) then |
|
1352 |
PHedgehog(Gear^.Hedgehog)^.Effects[hePoisoned] := true; |
|
1353 |
end; |
|
3100 | 1354 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1355 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1356 |
gtGrave: begin |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1357 |
// Run the calcs only once we know we have a type that will need damage |
3322 | 1358 |
if hwRound(hwAbs(Gear^.X-fX)+hwAbs(Gear^.Y-fY)) < dmgBase then |
1359 |
dmg:= dmgBase - hwRound(Distance(Gear^.X - fX, Gear^.Y - fY)); |
|
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1360 |
if dmg > 1 then |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1361 |
begin |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1362 |
dmg:= ModifyDamage(min(dmg div 2, Radius), Gear); |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1363 |
Gear^.dY:= - _0_004 * dmg; |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1364 |
Gear^.Active:= true |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1365 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1366 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1367 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1368 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1369 |
Gear:= Gear^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1370 |
end; |
1200 | 1371 |
|
621 | 1372 |
if (Mask and EXPLDontDraw) = 0 then |
3689 | 1373 |
if (GameFlags and gfSolidLand) = 0 then |
1374 |
begin |
|
1375 |
cnt:= DrawExplosion(X, Y, Radius) div 1608; // approx 2 16x16 circles to erase per chunk |
|
1376 |
if cnt > 0 then |
|
1377 |
for i:= 0 to cnt do |
|
1378 |
AddVisualGear(X, Y, vgtChunk) |
|
1379 |
end; |
|
1200 | 1380 |
|
498 | 1381 |
uAIMisc.AwareOfExplosion(0, 0, 0) |
4 | 1382 |
end; |
1383 |
||
506 | 1384 |
procedure ShotgunShot(Gear: PGear); |
1385 |
var t: PGear; |
|
955 | 1386 |
dmg: LongInt; |
506 | 1387 |
begin |
509 | 1388 |
Gear^.Radius:= cShotgunRadius; |
506 | 1389 |
t:= GearsList; |
1390 |
while t <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1391 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1392 |
dmg:= ModifyDamage(min(Gear^.Radius + t^.Radius - hwRound(Distance(Gear^.X - t^.X, Gear^.Y - t^.Y)), 25), t); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1393 |
if dmg > 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1394 |
case t^.Kind of |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1395 |
gtHedgehog, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1396 |
gtMine, |
3710 | 1397 |
gtSMine, |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1398 |
gtCase, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1399 |
gtTarget, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1400 |
gtExplosives: begin |
1854 | 1401 |
if (not t^.Invulnerable) then |
3682 | 1402 |
ApplyDamage(t, dmg, dsBullet) |
1865
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset
|
1403 |
else |
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset
|
1404 |
Gear^.State:= Gear^.State or gstWinner; |
867 | 1405 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1406 |
DeleteCI(t); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1407 |
t^.dX:= t^.dX + Gear^.dX * dmg * _0_01 + SignAs(cHHKick, Gear^.dX); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1408 |
t^.dY:= t^.dY + Gear^.dY * dmg * _0_01; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1409 |
t^.State:= t^.State or gstMoving; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1410 |
t^.Active:= true; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1411 |
FollowGear:= t |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1412 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1413 |
gtGrave: begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1414 |
t^.dY:= - _0_1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1415 |
t^.Active:= true |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1416 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1417 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1418 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1419 |
end; |
621 | 1420 |
if (GameFlags and gfSolidLand) = 0 then DrawExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), cShotgunRadius) |
506 | 1421 |
end; |
1422 |
||
371 | 1423 |
procedure AmmoShove(Ammo: PGear; Damage, Power: LongInt); |
53 | 1424 |
var t: PGearArray; |
2424
b52344de23ae
In progress, trying to make a fire for molotov cocktail. Normal fire should still work fairly normally.
nemo
parents:
2407
diff
changeset
|
1425 |
Gear: PGear; |
2726 | 1426 |
i, tmpDmg: LongInt; |
4327 | 1427 |
VGear: PVisualGear; |
38 | 1428 |
begin |
53 | 1429 |
t:= CheckGearsCollision(Ammo); |
3098
e5a1bc4e56fd
Specifically check for current hedgehog being on rope, the tricky bastard.
nemo
parents:
3097
diff
changeset
|
1430 |
// Just to avoid hogs on rope dodging fire. |
3697 | 1431 |
if (CurAmmoGear <> nil) and (CurAmmoGear^.Kind = gtRope) and |
1432 |
(CurrentHedgehog^.Gear <> nil) and (CurrentHedgehog^.Gear^.CollisionIndex = -1) and |
|
1433 |
(sqr(hwRound(Ammo^.X) - hwRound(CurrentHedgehog^.Gear^.X)) + sqr(hwRound(Ammo^.Y) - hwRound(CurrentHedgehog^.Gear^.Y)) <= sqr(cHHRadius + Ammo^.Radius)) then |
|
3098
e5a1bc4e56fd
Specifically check for current hedgehog being on rope, the tricky bastard.
nemo
parents:
3097
diff
changeset
|
1434 |
begin |
e5a1bc4e56fd
Specifically check for current hedgehog being on rope, the tricky bastard.
nemo
parents:
3097
diff
changeset
|
1435 |
t^.ar[t^.Count]:= CurrentHedgehog^.Gear; |
e5a1bc4e56fd
Specifically check for current hedgehog being on rope, the tricky bastard.
nemo
parents:
3097
diff
changeset
|
1436 |
inc(t^.Count) |
4182 | 1437 |
end; |
4165 | 1438 |
|
351 | 1439 |
i:= t^.Count; |
1506 | 1440 |
|
2489 | 1441 |
if (Ammo^.Kind = gtFlame) and (i > 0) then Ammo^.Health:= 0; |
53 | 1442 |
while i > 0 do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1443 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1444 |
dec(i); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1445 |
Gear:= t^.ar[i]; |
2726 | 1446 |
tmpDmg:= ModifyDamage(Damage, Gear); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1447 |
if (Gear^.State and gstNoDamage) = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1448 |
begin |
4327 | 1449 |
|
4329 | 1450 |
if (Ammo^.Kind = gtDEagleShot) or (Ammo^.Kind = gtSniperRifleShot) then |
4327 | 1451 |
begin |
4329 | 1452 |
VGear := AddVisualGear(hwround(Ammo^.X), hwround(Ammo^.Y), vgtBulletHit); |
1453 |
if VGear <> nil then |
|
1454 |
begin |
|
1455 |
VGear^.Angle := DxDy2Angle(-Ammo^.dX, Ammo^.dY); |
|
1456 |
end; |
|
4327 | 1457 |
end; |
1458 |
||
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1459 |
if (Gear^.Kind = gtHedgehog) and (Ammo^.State and gsttmpFlag <> 0) and (Ammo^.Kind = gtShover) then Gear^.FlightTime:= 1; |
3697 | 1460 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1461 |
case Gear^.Kind of |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1462 |
gtHedgehog, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1463 |
gtMine, |
3710 | 1464 |
gtSMine, |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1465 |
gtTarget, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1466 |
gtCase, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1467 |
gtExplosives: begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1468 |
if (Ammo^.Kind = gtDrill) then begin Ammo^.Timer:= 0; exit; end; |
2424
b52344de23ae
In progress, trying to make a fire for molotov cocktail. Normal fire should still work fairly normally.
nemo
parents:
2407
diff
changeset
|
1469 |
if (not Gear^.Invulnerable) then |
3682 | 1470 |
ApplyDamage(Gear, tmpDmg, dsShove) |
1865
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset
|
1471 |
else |
2424
b52344de23ae
In progress, trying to make a fire for molotov cocktail. Normal fire should still work fairly normally.
nemo
parents:
2407
diff
changeset
|
1472 |
Gear^.State:= Gear^.State or gstWinner; |
3682 | 1473 |
if (Gear^.Kind = gtExplosives) and (Ammo^.Kind = gtBlowtorch) then ApplyDamage(Gear, tmpDmg * 100, dsUnknown); // crank up damage for explosives + blowtorch |
867 | 1474 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1475 |
DeleteCI(Gear); |
2728
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1476 |
if (Gear^.Kind = gtHedgehog) and PHedgehog(Gear^.Hedgehog)^.King then |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1477 |
begin |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1478 |
Gear^.dX:= Ammo^.dX * Power * _0_005; |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1479 |
Gear^.dY:= Ammo^.dY * Power * _0_005 |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1480 |
end |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1481 |
else |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1482 |
begin |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1483 |
Gear^.dX:= Ammo^.dX * Power * _0_01; |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1484 |
Gear^.dY:= Ammo^.dY * Power * _0_01 |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1485 |
end; |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1486 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1487 |
Gear^.Active:= true; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1488 |
Gear^.State:= Gear^.State or gstMoving; |
867 | 1489 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1490 |
if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1491 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1492 |
if not (TestCollisionXwithXYShift(Gear, _0, -3, hwSign(Gear^.dX)) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1493 |
or TestCollisionYwithGear(Gear, -1)) then Gear^.Y:= Gear^.Y - _1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1494 |
if not (TestCollisionXwithXYShift(Gear, _0, -2, hwSign(Gear^.dX)) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1495 |
or TestCollisionYwithGear(Gear, -1)) then Gear^.Y:= Gear^.Y - _1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1496 |
if not (TestCollisionXwithXYShift(Gear, _0, -1, hwSign(Gear^.dX)) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1497 |
or TestCollisionYwithGear(Gear, -1)) then Gear^.Y:= Gear^.Y - _1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1498 |
end; |
3697 | 1499 |
|
2537
aceebf0653f7
Disable followgear on ammoshove for napalm fire damage
nemo
parents:
2492
diff
changeset
|
1500 |
if (Ammo^.Kind <> gtFlame) or ((Ammo^.State and gsttmpFlag) = 0) then FollowGear:= Gear |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1501 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1502 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1503 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1504 |
end; |
2424
b52344de23ae
In progress, trying to make a fire for molotov cocktail. Normal fire should still work fairly normally.
nemo
parents:
2407
diff
changeset
|
1505 |
if i <> 0 then SetAllToActive |
38 | 1506 |
end; |
1507 |
||
4 | 1508 |
procedure AssignHHCoords; |
955 | 1509 |
var i, t, p, j: LongInt; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1510 |
ar: array[0..Pred(cMaxHHs)] of PHedgehog; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1511 |
Count: Longword; |
4 | 1512 |
begin |
2771
477957a89881
Override both hog placements, this makes divide teams pretty much useless with hog placement mode. Restricting hog placement to one side might be a nice addition.
nemo
parents:
2770
diff
changeset
|
1513 |
if (GameFlags and gfPlaceHog) <> 0 then PlacingHogs:= true; |
4148
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
1514 |
if (GameFlags and gfDivideTeams) <> 0 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1515 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1516 |
t:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1517 |
TryDo(ClansCount = 2, 'More or less than 2 clans on map in divided teams mode!', true); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1518 |
for p:= 0 to 1 do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1519 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1520 |
with ClansArray[p]^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1521 |
for j:= 0 to Pred(TeamsNumber) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1522 |
with Teams[j]^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1523 |
for i:= 0 to cMaxHHIndex do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1524 |
with Hedgehogs[i] do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1525 |
if (Gear <> nil) and (Gear^.X.QWordValue = 0) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1526 |
begin |
2771
477957a89881
Override both hog placements, this makes divide teams pretty much useless with hog placement mode. Restricting hog placement to one side might be a nice addition.
nemo
parents:
2770
diff
changeset
|
1527 |
if PlacingHogs then Unplaced:= true |
477957a89881
Override both hog placements, this makes divide teams pretty much useless with hog placement mode. Restricting hog placement to one side might be a nice addition.
nemo
parents:
2770
diff
changeset
|
1528 |
else FindPlace(Gear, false, t, t + LAND_WIDTH div 2);// could make Gear == nil; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1529 |
if Gear <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1530 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1531 |
Gear^.Pos:= GetRandom(49); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1532 |
Gear^.dX.isNegative:= p = 1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1533 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1534 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1535 |
t:= LAND_WIDTH div 2 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1536 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1537 |
end else // mix hedgehogs |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1538 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1539 |
Count:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1540 |
for p:= 0 to Pred(TeamsCount) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1541 |
with TeamsArray[p]^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1542 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1543 |
for i:= 0 to cMaxHHIndex do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1544 |
with Hedgehogs[i] do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1545 |
if (Gear <> nil) and (Gear^.X.QWordValue = 0) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1546 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1547 |
ar[Count]:= @Hedgehogs[i]; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1548 |
inc(Count) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1549 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1550 |
end; |
1792 | 1551 |
// unC0Rr, while it is true user can watch value on map screen, IMO this (and check above) should be enforced in UI |
1552 |
// - is there a good place to put values for the different widgets to check? Right now they are kind of disconnected. |
|
1965 | 1553 |
//it would be nice if divide teams, forts mode and hh per map could all be checked by the team widget, or maybe disable start button |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1554 |
TryDo(Count <= MaxHedgehogs, 'Too many hedgehogs for this map! (max # is ' + inttostr(MaxHedgehogs) + ')', true); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1555 |
while (Count > 0) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1556 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1557 |
i:= GetRandom(Count); |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2760
diff
changeset
|
1558 |
if PlacingHogs then ar[i]^.Unplaced:= true |
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2760
diff
changeset
|
1559 |
else FindPlace(ar[i]^.Gear, false, 0, LAND_WIDTH); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1560 |
if ar[i]^.Gear <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1561 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1562 |
ar[i]^.Gear^.dX.isNegative:= hwRound(ar[i]^.Gear^.X) > LAND_WIDTH div 2; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1563 |
ar[i]^.Gear^.Pos:= GetRandom(19) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1564 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1565 |
ar[i]:= ar[Count - 1]; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1566 |
dec(Count) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1567 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1568 |
end |
4 | 1569 |
end; |
1570 |
||
4024
1ffb84b3823d
Resurrector: respect modified Gear position for resurrection range circle
Tobias Neumann <mail@tobias-neumann.eu>
parents:
4007
diff
changeset
|
1571 |
function GearsNear(X, Y: hwFloat; Kind: TGearType; r: LongInt): TPGearArray; |
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1572 |
var |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1573 |
t: PGear; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1574 |
begin |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1575 |
GearsNear := nil; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1576 |
t := GearsList; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1577 |
while t <> nil do begin |
4024
1ffb84b3823d
Resurrector: respect modified Gear position for resurrection range circle
Tobias Neumann <mail@tobias-neumann.eu>
parents:
4007
diff
changeset
|
1578 |
if (t^.Kind = Kind) then begin |
1ffb84b3823d
Resurrector: respect modified Gear position for resurrection range circle
Tobias Neumann <mail@tobias-neumann.eu>
parents:
4007
diff
changeset
|
1579 |
if (X - t^.X)*(X - t^.X) + (Y - t^.Y)*(Y-t^.Y) < |
1ffb84b3823d
Resurrector: respect modified Gear position for resurrection range circle
Tobias Neumann <mail@tobias-neumann.eu>
parents:
4007
diff
changeset
|
1580 |
int2hwFloat(r)*int2hwFloat(r) then |
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1581 |
begin |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1582 |
SetLength(GearsNear, Length(GearsNear)+1); |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1583 |
GearsNear[High(GearsNear)] := t; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1584 |
end; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1585 |
end; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1586 |
t := t^.NextGear; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1587 |
end; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1588 |
end; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1589 |
|
371 | 1590 |
function CheckGearNear(Gear: PGear; Kind: TGearType; rX, rY: LongInt): PGear; |
10 | 1591 |
var t: PGear; |
1592 |
begin |
|
1593 |
t:= GearsList; |
|
1594 |
rX:= sqr(rX); |
|
1595 |
rY:= sqr(rY); |
|
1433 | 1596 |
|
10 | 1597 |
while t <> nil do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1598 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1599 |
if (t <> Gear) and (t^.Kind = Kind) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1600 |
if not((hwSqr(Gear^.X - t^.X) / rX + hwSqr(Gear^.Y - t^.Y) / rY) > _1) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1601 |
exit(t); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1602 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1603 |
end; |
1433 | 1604 |
|
351 | 1605 |
CheckGearNear:= nil |
15 | 1606 |
end; |
1607 |
||
1433 | 1608 |
{procedure AmmoFlameWork(Ammo: PGear); |
79 | 1609 |
var t: PGear; |
1610 |
begin |
|
1611 |
t:= GearsList; |
|
1612 |
while t <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1613 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1614 |
if (t^.Kind = gtHedgehog) and (t^.Y < Ammo^.Y) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1615 |
if not (hwSqr(Ammo^.X - t^.X) + hwSqr(Ammo^.Y - t^.Y - int2hwFloat(cHHRadius)) * 2 > _2) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1616 |
begin |
2017 | 1617 |
ApplyDamage(t, 5); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1618 |
t^.dX:= t^.dX + (t^.X - Ammo^.X) * _0_02; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1619 |
t^.dY:= - _0_25; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1620 |
t^.Active:= true; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1621 |
DeleteCI(t); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1622 |
FollowGear:= t |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1623 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1624 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1625 |
end; |
1433 | 1626 |
end;} |
79 | 1627 |
|
371 | 1628 |
function CheckGearsNear(mX, mY: LongInt; Kind: TGearsType; rX, rY: LongInt): PGear; |
16 | 1629 |
var t: PGear; |
1630 |
begin |
|
1631 |
t:= GearsList; |
|
1632 |
rX:= sqr(rX); |
|
1633 |
rY:= sqr(rY); |
|
1634 |
while t <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1635 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1636 |
if t^.Kind in Kind then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1637 |
if not (hwSqr(int2hwFloat(mX) - t^.X) / rX + hwSqr(int2hwFloat(mY) - t^.Y) / rY > _1) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1638 |
exit(t); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1639 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1640 |
end; |
351 | 1641 |
CheckGearsNear:= nil |
16 | 1642 |
end; |
1643 |
||
1644 |
function CountGears(Kind: TGearType): Longword; |
|
1645 |
var t: PGear; |
|
2695 | 1646 |
count: Longword = 0; |
16 | 1647 |
begin |
2695 | 1648 |
|
16 | 1649 |
t:= GearsList; |
1650 |
while t <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1651 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1652 |
if t^.Kind = Kind then inc(count); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1653 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1654 |
end; |
2695 | 1655 |
CountGears:= count; |
16 | 1656 |
end; |
1657 |
||
3768 | 1658 |
procedure ResurrectHedgehog(gear: PGear); |
3831
3410db7ac43e
gfAISurvival: fix issue when cpu cannot find new place to spawn
burp
parents:
3799
diff
changeset
|
1659 |
var tempTeam : PTeam; |
3768 | 1660 |
begin |
1661 |
gear^.dX := _0; |
|
1662 |
gear^.dY := _0; |
|
1663 |
gear^.State := gstWait; |
|
3775
c0397452e7c5
gfAISurvival/heResurrectable: respawn always with 100HP
burp
parents:
3773
diff
changeset
|
1664 |
uStats.HedgehogDamaged(gear); |
c0397452e7c5
gfAISurvival/heResurrectable: respawn always with 100HP
burp
parents:
3773
diff
changeset
|
1665 |
gear^.Damage := 0; |
c0397452e7c5
gfAISurvival/heResurrectable: respawn always with 100HP
burp
parents:
3773
diff
changeset
|
1666 |
gear^.Health := 100; |
3773 | 1667 |
with CurrentHedgehog^ do begin |
1668 |
inc(Team^.stats.AIKills); |
|
1669 |
if Team^.AIKillsTex <> nil then FreeTexture(Team^.AIKillsTex); |
|
1670 |
Team^.AIKillsTex := RenderStringTex(inttostr(Team^.stats.AIKills), Team^.Clan^.Color, fnt16); |
|
1671 |
end; |
|
3831
3410db7ac43e
gfAISurvival: fix issue when cpu cannot find new place to spawn
burp
parents:
3799
diff
changeset
|
1672 |
tempTeam := PHedgehog(gear^.Hedgehog)^.Team; |
3832
f949798219bf
Delete CI in ResurrectHedgehog prior to FindPlace. Restrict FindPlace to the waterline, a bit more efficient.
nemo
parents:
3831
diff
changeset
|
1673 |
DeleteCI(gear); |
3770 | 1674 |
FindPlace(gear, false, 0, LAND_WIDTH); |
3831
3410db7ac43e
gfAISurvival: fix issue when cpu cannot find new place to spawn
burp
parents:
3799
diff
changeset
|
1675 |
if gear <> nil then begin |
3410db7ac43e
gfAISurvival: fix issue when cpu cannot find new place to spawn
burp
parents:
3799
diff
changeset
|
1676 |
RenderHealth(PHedgehog(gear^.Hedgehog)^); |
3848 | 1677 |
ScriptCall('onGearResurrect', gear^.uid); |
3831
3410db7ac43e
gfAISurvival: fix issue when cpu cannot find new place to spawn
burp
parents:
3799
diff
changeset
|
1678 |
end; |
3410db7ac43e
gfAISurvival: fix issue when cpu cannot find new place to spawn
burp
parents:
3799
diff
changeset
|
1679 |
RecountTeamHealth(tempTeam); |
3768 | 1680 |
end; |
1681 |
||
3750
3aa85b5f3318
SpawnCustomCrateAt: spawn crate at random position for x=y=0, also let it return the gear, and luabindings the gear uid
burp
parents:
3749
diff
changeset
|
1682 |
function SpawnCustomCrateAt(x, y: LongInt; crate: TCrateType; content: Longword): PGear; |
3730 | 1683 |
begin |
3734 | 1684 |
FollowGear := AddGear(x, y, gtCase, 0, _0, _0, 0); |
1685 |
cCaseFactor := 0; |
|
1686 |
||
1687 |
if (content > ord(High(TAmmoType))) then content := ord(High(TAmmoType)); |
|
1688 |
||
1689 |
case crate of |
|
1690 |
HealthCrate: begin |
|
4143
eb7981f34800
Remove the last vestiges of the shoppa hack by adding 2 spinners for percentage health and amount of health in crate, also update translations and increase SD spinner (some users have requested it)
henek
parents:
4120
diff
changeset
|
1691 |
FollowGear^.Health := cHealthCaseAmount; |
3734 | 1692 |
FollowGear^.Pos := posCaseHealth; |
1693 |
AddCaption(GetEventString(eidNewHealthPack), cWhiteColor, capgrpAmmoInfo); |
|
1694 |
end; |
|
1695 |
AmmoCrate: begin |
|
1696 |
FollowGear^.Pos := posCaseAmmo; |
|
4240
4e81670e52aa
er. and cast to TAmmoType, which burp's routine still requires :)
nemo
parents:
4239
diff
changeset
|
1697 |
FollowGear^.AmmoType := TAmmoType(content); |
3734 | 1698 |
AddCaption(GetEventString(eidNewAmmoPack), cWhiteColor, capgrpAmmoInfo); |
1699 |
end; |
|
1700 |
UtilityCrate: begin |
|
1701 |
FollowGear^.Pos := posCaseUtility; |
|
4240
4e81670e52aa
er. and cast to TAmmoType, which burp's routine still requires :)
nemo
parents:
4239
diff
changeset
|
1702 |
FollowGear^.AmmoType := TAmmoType(content); |
3734 | 1703 |
AddCaption(GetEventString(eidNewUtilityPack), cWhiteColor, capgrpAmmoInfo); |
1704 |
end; |
|
1705 |
end; |
|
3750
3aa85b5f3318
SpawnCustomCrateAt: spawn crate at random position for x=y=0, also let it return the gear, and luabindings the gear uid
burp
parents:
3749
diff
changeset
|
1706 |
|
3aa85b5f3318
SpawnCustomCrateAt: spawn crate at random position for x=y=0, also let it return the gear, and luabindings the gear uid
burp
parents:
3749
diff
changeset
|
1707 |
if ( (x = 0) and (y = 0) ) then FindPlace(FollowGear, true, 0, LAND_WIDTH); |
3aa85b5f3318
SpawnCustomCrateAt: spawn crate at random position for x=y=0, also let it return the gear, and luabindings the gear uid
burp
parents:
3749
diff
changeset
|
1708 |
|
3aa85b5f3318
SpawnCustomCrateAt: spawn crate at random position for x=y=0, also let it return the gear, and luabindings the gear uid
burp
parents:
3749
diff
changeset
|
1709 |
SpawnCustomCrateAt := FollowGear; |
3730 | 1710 |
end; |
1711 |
||
15 | 1712 |
procedure SpawnBoxOfSmth; |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1713 |
var t, aTot, uTot, a, h: LongInt; |
394
4c017ae1226a
- Implement hack to let ammo stores work without needed assistance of frontend
unc0rr
parents:
393
diff
changeset
|
1714 |
i: TAmmoType; |
15 | 1715 |
begin |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2760
diff
changeset
|
1716 |
if (PlacingHogs) or |
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2760
diff
changeset
|
1717 |
(cCaseFactor = 0) or |
614 | 1718 |
(CountGears(gtCase) >= 5) or |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1719 |
(GetRandom(cCaseFactor) <> 0) then exit; |
1295 | 1720 |
|
1948 | 1721 |
FollowGear:= nil; |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1722 |
aTot:= 0; |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1723 |
uTot:= 0; |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1724 |
for i:= Low(TAmmoType) to High(TAmmoType) do |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1725 |
if (Ammoz[i].Ammo.Propz and ammoprop_Utility) = 0 then |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1726 |
inc(aTot, Ammoz[i].Probability) |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1727 |
else |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1728 |
inc(uTot, Ammoz[i].Probability); |
1966 | 1729 |
|
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1730 |
t:=0; |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1731 |
a:=aTot; |
3268 | 1732 |
h:= 1; |
4143
eb7981f34800
Remove the last vestiges of the shoppa hack by adding 2 spinners for percentage health and amount of health in crate, also update translations and increase SD spinner (some users have requested it)
henek
parents:
4120
diff
changeset
|
1733 |
|
3268 | 1734 |
if (aTot+uTot) <> 0 then |
4143
eb7981f34800
Remove the last vestiges of the shoppa hack by adding 2 spinners for percentage health and amount of health in crate, also update translations and increase SD spinner (some users have requested it)
henek
parents:
4120
diff
changeset
|
1735 |
if ((GameFlags and gfInvulnerable) = 0) then |
3268 | 1736 |
begin |
4143
eb7981f34800
Remove the last vestiges of the shoppa hack by adding 2 spinners for percentage health and amount of health in crate, also update translations and increase SD spinner (some users have requested it)
henek
parents:
4120
diff
changeset
|
1737 |
h:= cHealthCaseProb * 100; |
3268 | 1738 |
t:= GetRandom(10000); |
4143
eb7981f34800
Remove the last vestiges of the shoppa hack by adding 2 spinners for percentage health and amount of health in crate, also update translations and increase SD spinner (some users have requested it)
henek
parents:
4120
diff
changeset
|
1739 |
a:= (10000-h)*aTot div (aTot+uTot) |
3268 | 1740 |
end |
3697 | 1741 |
else |
3268 | 1742 |
begin |
1743 |
t:= GetRandom(aTot+uTot); |
|
1744 |
h:= 0 |
|
1745 |
end; |
|
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1746 |
|
3697 | 1747 |
|
3261
fa7086253e83
Rebalance Default to take into account reweighting of crates, remove redundant check
nemo
parents:
3259
diff
changeset
|
1748 |
if t<h then |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1749 |
begin |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1750 |
FollowGear:= AddGear(0, 0, gtCase, 0, _0, _0, 0); |
4143
eb7981f34800
Remove the last vestiges of the shoppa hack by adding 2 spinners for percentage health and amount of health in crate, also update translations and increase SD spinner (some users have requested it)
henek
parents:
4120
diff
changeset
|
1751 |
FollowGear^.Health:= cHealthCaseAmount; |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1752 |
FollowGear^.Pos:= posCaseHealth; |
3331 | 1753 |
AddCaption(GetEventString(eidNewHealthPack), cWhiteColor, capgrpAmmoInfo); |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1754 |
end |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1755 |
else if (t<a+h) then |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1756 |
begin |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1757 |
t:= aTot; |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1758 |
if (t > 0) then |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1759 |
begin |
1865
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset
|
1760 |
FollowGear:= AddGear(0, 0, gtCase, 0, _0, _0, 0); |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1761 |
t:= GetRandom(t); |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1762 |
i:= Low(TAmmoType); |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1763 |
while t >= 0 do |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1764 |
begin |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1765 |
inc(i); |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1766 |
if (Ammoz[i].Ammo.Propz and ammoprop_Utility) = 0 then |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1767 |
dec(t, Ammoz[i].Probability) |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1768 |
end; |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1769 |
FollowGear^.Pos:= posCaseAmmo; |
4238
6f1631765ebd
Fix a long-standing bug with ammo due to gstMoving being set on gears generically, causing an incorrect ammo type to be set. This caused crashes and incorrect ammo types.
nemo
parents:
4225
diff
changeset
|
1770 |
FollowGear^.AmmoType:= i; |
3331 | 1771 |
AddCaption(GetEventString(eidNewAmmoPack), cWhiteColor, capgrpAmmoInfo); |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1772 |
end |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1773 |
end |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1774 |
else |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1775 |
begin |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1776 |
t:= uTot; |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1777 |
if (t > 0) then |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1778 |
begin |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1779 |
FollowGear:= AddGear(0, 0, gtCase, 0, _0, _0, 0); |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1780 |
t:= GetRandom(t); |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1781 |
i:= Low(TAmmoType); |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1782 |
while t >= 0 do |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1783 |
begin |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1784 |
inc(i); |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1785 |
if (Ammoz[i].Ammo.Propz and ammoprop_Utility) <> 0 then |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1786 |
dec(t, Ammoz[i].Probability) |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1787 |
end; |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1788 |
FollowGear^.Pos:= posCaseUtility; |
4238
6f1631765ebd
Fix a long-standing bug with ammo due to gstMoving being set on gears generically, causing an incorrect ammo type to be set. This caused crashes and incorrect ammo types.
nemo
parents:
4225
diff
changeset
|
1789 |
FollowGear^.AmmoType:= i; |
3331 | 1790 |
AddCaption(GetEventString(eidNewUtilityPack), cWhiteColor, capgrpAmmoInfo); |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1791 |
end |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1792 |
end; |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1793 |
|
1865
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset
|
1794 |
// handles case of no ammo or utility crates - considered also placing booleans in uAmmos and altering probabilities |
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset
|
1795 |
if (FollowGear <> nil) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1796 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1797 |
FindPlace(FollowGear, true, 0, LAND_WIDTH); |
2376 | 1798 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1799 |
if (FollowGear <> nil) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1800 |
PlaySound(sndReinforce, CurrentTeam^.voicepack) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1801 |
end |
70 | 1802 |
end; |
1803 |
||
1515 | 1804 |
procedure FindPlace(var Gear: PGear; withFall: boolean; Left, Right: LongInt); |
70 | 1805 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1806 |
function CountNonZeroz(x, y, r, c: LongInt): LongInt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1807 |
var i: LongInt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1808 |
count: LongInt = 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1809 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1810 |
if (y and LAND_HEIGHT_MASK) = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1811 |
for i:= max(x - r, 0) to min(x + r, LAND_WIDTH - 4) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1812 |
if Land[y, i] <> 0 then |
2659 | 1813 |
begin |
2695 | 1814 |
inc(count); |
1815 |
if count = c then exit(count) |
|
2659 | 1816 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1817 |
CountNonZeroz:= count; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1818 |
end; |
70 | 1819 |
|
495 | 1820 |
var x: LongInt; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1821 |
y, sy: LongInt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1822 |
ar: array[0..511] of TPoint; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1823 |
ar2: array[0..1023] of TPoint; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1824 |
cnt, cnt2: Longword; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1825 |
delta: LongInt; |
70 | 1826 |
begin |
386 | 1827 |
delta:= 250; |
1828 |
cnt2:= 0; |
|
16 | 1829 |
repeat |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1830 |
x:= Left + LongInt(GetRandom(Delta)); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1831 |
repeat |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1832 |
inc(x, Delta); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1833 |
cnt:= 0; |
3407 | 1834 |
y:= min(1024, topY) - 2 * Gear^.Radius; |
3832
f949798219bf
Delete CI in ResurrectHedgehog prior to FindPlace. Restrict FindPlace to the waterline, a bit more efficient.
nemo
parents:
3831
diff
changeset
|
1835 |
while y < cWaterLine do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1836 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1837 |
repeat |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1838 |
inc(y, 2); |
3832
f949798219bf
Delete CI in ResurrectHedgehog prior to FindPlace. Restrict FindPlace to the waterline, a bit more efficient.
nemo
parents:
3831
diff
changeset
|
1839 |
until (y >= cWaterLine) or (CountNonZeroz(x, y, Gear^.Radius - 1, 1) = 0); |
2376 | 1840 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1841 |
sy:= y; |
1515 | 1842 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1843 |
repeat |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1844 |
inc(y); |
3832
f949798219bf
Delete CI in ResurrectHedgehog prior to FindPlace. Restrict FindPlace to the waterline, a bit more efficient.
nemo
parents:
3831
diff
changeset
|
1845 |
until (y >= cWaterLine) or (CountNonZeroz(x, y, Gear^.Radius - 1, 1) <> 0); |
3697 | 1846 |
|
2923
e33ecd95aa1a
Rearrange the test a bit to make the separation a bit clearer, also try snuggling crates up a bit closer to other things.
nemo
parents:
2915
diff
changeset
|
1847 |
if (y - sy > Gear^.Radius * 2) and |
e33ecd95aa1a
Rearrange the test a bit to make the separation a bit clearer, also try snuggling crates up a bit closer to other things.
nemo
parents:
2915
diff
changeset
|
1848 |
(((Gear^.Kind = gtExplosives) |
3832
f949798219bf
Delete CI in ResurrectHedgehog prior to FindPlace. Restrict FindPlace to the waterline, a bit more efficient.
nemo
parents:
3831
diff
changeset
|
1849 |
and (y < cWaterLine) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1850 |
and (CheckGearsNear(x, y - Gear^.Radius, [gtFlame, gtHedgehog, gtMine, gtCase, gtExplosives], 60, 60) = nil) |
3697 | 1851 |
and (CountNonZeroz(x, y+1, Gear^.Radius - 1, Gear^.Radius+1) > Gear^.Radius)) |
2923
e33ecd95aa1a
Rearrange the test a bit to make the separation a bit clearer, also try snuggling crates up a bit closer to other things.
nemo
parents:
2915
diff
changeset
|
1852 |
or |
e33ecd95aa1a
Rearrange the test a bit to make the separation a bit clearer, also try snuggling crates up a bit closer to other things.
nemo
parents:
2915
diff
changeset
|
1853 |
((Gear^.Kind <> gtExplosives) |
3832
f949798219bf
Delete CI in ResurrectHedgehog prior to FindPlace. Restrict FindPlace to the waterline, a bit more efficient.
nemo
parents:
3831
diff
changeset
|
1854 |
and (y < cWaterLine) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1855 |
and (CheckGearsNear(x, y - Gear^.Radius, [gtFlame, gtHedgehog, gtMine, gtCase, gtExplosives], 110, 110) = nil))) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1856 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1857 |
ar[cnt].X:= x; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1858 |
if withFall then ar[cnt].Y:= sy + Gear^.Radius |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1859 |
else ar[cnt].Y:= y - Gear^.Radius; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1860 |
inc(cnt) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1861 |
end; |
2376 | 1862 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1863 |
inc(y, 45) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1864 |
end; |
2376 | 1865 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1866 |
if cnt > 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1867 |
with ar[GetRandom(cnt)] do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1868 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1869 |
ar2[cnt2].x:= x; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1870 |
ar2[cnt2].y:= y; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1871 |
inc(cnt2) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1872 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1873 |
until (x + Delta > Right); |
2376 | 1874 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1875 |
dec(Delta, 60) |
386 | 1876 |
until (cnt2 > 0) or (Delta < 70); |
1515 | 1877 |
|
386 | 1878 |
if cnt2 > 0 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1879 |
with ar2[GetRandom(cnt2)] do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1880 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1881 |
Gear^.X:= int2hwFloat(x); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1882 |
Gear^.Y:= int2hwFloat(y); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1883 |
{$IFDEF DEBUGFILE} |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1884 |
AddFileLog('Assigned Gear coordinates (' + inttostr(x) + ',' + inttostr(y) + ')'); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1885 |
{$ENDIF} |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1886 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1887 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1888 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1889 |
OutError('Can''t find place for Gear', false); |
3832
f949798219bf
Delete CI in ResurrectHedgehog prior to FindPlace. Restrict FindPlace to the waterline, a bit more efficient.
nemo
parents:
3831
diff
changeset
|
1890 |
if Gear^.Kind = gtHedgehog then PHedgehog(Gear^.Hedgehog)^.Effects[heResurrectable] := false; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1891 |
DeleteGear(Gear); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1892 |
Gear:= nil |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1893 |
end |
10 | 1894 |
end; |
1895 |
||
2726 | 1896 |
function ModifyDamage(dmg: Longword; Gear: PGear): Longword; |
2728
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1897 |
var i: hwFloat; |
2726 | 1898 |
begin |
1899 |
(* Invulnerability cannot be placed in here due to still needing kicks |
|
1900 |
Not without a new damage machine. |
|
1901 |
King check should be in here instead of ApplyDamage since Tiy wants them kicked less |
|
1902 |
*) |
|
2728
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1903 |
i:= _1; |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1904 |
if (CurrentHedgehog <> nil) and CurrentHedgehog^.King then i:= _1_5; |
2741 | 1905 |
if (Gear^.Hedgehog <> nil) and (PHedgehog(Gear^.Hedgehog)^.King) then |
2728
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1906 |
ModifyDamage:= hwRound(_0_01 * cDamageModifier * dmg * i * cDamagePercent * _0_5) |
2726 | 1907 |
else |
2728
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1908 |
ModifyDamage:= hwRound(_0_01 * cDamageModifier * dmg * i * cDamagePercent) |
2726 | 1909 |
end; |
1910 |
||
2790 | 1911 |
function GearByUID(uid : Longword) : PGear; |
1912 |
var gear: PGear; |
|
1913 |
begin |
|
1914 |
GearByUID:= nil; |
|
1915 |
gear:= GearsList; |
|
1916 |
while gear <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1917 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1918 |
if gear^.uid = uid then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1919 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1920 |
GearByUID:= gear; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1921 |
exit |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1922 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1923 |
gear:= gear^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1924 |
end |
2790 | 1925 |
end; |
1926 |
||
3038 | 1927 |
procedure initModule; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
1928 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1929 |
CurAmmoGear:= nil; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1930 |
GearsList:= nil; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1931 |
KilledHHs:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1932 |
SuddenDeathDmg:= false; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1933 |
SpeechType:= 1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1934 |
TrainingTargetGear:= nil; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1935 |
skipFlag:= false; |
3697 | 1936 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1937 |
AllInactive:= false; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1938 |
PrvInactive:= false; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
1939 |
end; |
4 | 1940 |
|
3038 | 1941 |
procedure freeModule; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
1942 |
begin |
3615 | 1943 |
FreeGearsList(); |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
1944 |
end; |
4 | 1945 |
|
2451
5affd0840927
New data files from Tiy, add gtFlame to avoidance list
nemo
parents:
2428
diff
changeset
|
1946 |
end. |