author | Wuzzy <Wuzzy2@mail.ru> |
Wed, 14 Mar 2018 15:55:38 +0100 | |
changeset 13203 | ceae8e01af98 |
parent 13159 | 44351ea57b71 |
child 13352 | e7b89e87a1b3 |
permissions | -rw-r--r-- |
6581 | 1 |
(* |
2 |
* Hedgewars, a free turn based strategy game |
|
11046 | 3 |
* Copyright (c) 2004-2015 Andrey Korotaev <unC0Rr@gmail.com> |
6581 | 4 |
* |
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 |
|
8 |
* |
|
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. |
|
13 |
* |
|
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 |
|
10108
c68cf030eded
update FSF address. note: two sdl include files (by Sam Lantinga) still have the old FSF address in their copyright - but I ain't gonna touch their copyright headers
sheepluva
parents:
10040
diff
changeset
|
16 |
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
6581 | 17 |
*) |
18 |
||
19 |
{$INCLUDE "options.inc"} |
|
20 |
unit uGearsList; |
|
21 |
||
22 |
interface |
|
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset
|
23 |
uses uFloat, uTypes, SDLh; |
6581 | 24 |
|
25 |
function AddGear(X, Y: LongInt; Kind: TGearType; State: Longword; dX, dY: hwFloat; Timer: LongWord): PGear; |
|
11207 | 26 |
function AddGear(X, Y: LongInt; Kind: TGearType; State: Longword; dX, dY: hwFloat; Timer, newUid: LongWord): PGear; |
10646
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
27 |
procedure DeleteGear(Gear: PGear); |
6581 | 28 |
procedure InsertGearToList(Gear: PGear); |
29 |
procedure RemoveGearFromList(Gear: PGear); |
|
30 |
||
7395 | 31 |
var curHandledGear: PGear; |
32 |
||
6581 | 33 |
implementation |
34 |
||
35 |
uses uRandom, uUtils, uConsts, uVariables, uAmmos, uTeams, uStats, |
|
36 |
uTextures, uScript, uRenderUtils, uAI, uCollisions, |
|
7395 | 37 |
uGearsRender, uGearsUtils, uDebug; |
6581 | 38 |
|
8145
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
39 |
const |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
40 |
GearKindAmmoTypeMap : array [TGearType] of TAmmoType = ( |
8145
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
41 |
(* gtFlame *) amNothing |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
42 |
(* gtHedgehog *) , amNothing |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
43 |
(* gtMine *) , amMine |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
44 |
(* gtCase *) , amNothing |
10829 | 45 |
(* gtAirMine *) , amAirMine |
8145
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
46 |
(* gtExplosives *) , amNothing |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
47 |
(* gtGrenade *) , amGrenade |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
48 |
(* gtShell *) , amBazooka |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
49 |
(* gtGrave *) , amNothing |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
50 |
(* gtBee *) , amBee |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
51 |
(* gtShotgunShot *) , amShotgun |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
52 |
(* gtPickHammer *) , amPickHammer |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
53 |
(* gtRope *) , amRope |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
54 |
(* gtDEagleShot *) , amDEagle |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
55 |
(* gtDynamite *) , amDynamite |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
56 |
(* gtClusterBomb *) , amClusterBomb |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
57 |
(* gtCluster *) , amClusterBomb |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
58 |
(* gtShover *) , amBaseballBat // Shover is only used for baseball bat right now |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
59 |
(* gtFirePunch *) , amFirePunch |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
60 |
(* gtATStartGame *) , amNothing |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
61 |
(* gtATFinishGame *) , amNothing |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
62 |
(* gtParachute *) , amParachute |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
63 |
(* gtAirAttack *) , amAirAttack |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
64 |
(* gtAirBomb *) , amAirAttack |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
65 |
(* gtBlowTorch *) , amBlowTorch |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
66 |
(* gtGirder *) , amGirder |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
67 |
(* gtTeleport *) , amTeleport |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
68 |
(* gtSwitcher *) , amSwitch |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
69 |
(* gtTarget *) , amNothing |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
70 |
(* gtMortar *) , amMortar |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
71 |
(* gtWhip *) , amWhip |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
72 |
(* gtKamikaze *) , amKamikaze |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
73 |
(* gtCake *) , amCake |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
74 |
(* gtSeduction *) , amSeduction |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
75 |
(* gtWatermelon *) , amWatermelon |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
76 |
(* gtMelonPiece *) , amWatermelon |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
77 |
(* gtHellishBomb *) , amHellishBomb |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
78 |
(* gtWaterUp *) , amNothing |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
79 |
(* gtDrill *) , amDrill |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
80 |
(* gtBallGun *) , amBallgun |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
81 |
(* gtBall *) , amBallgun |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
82 |
(* gtRCPlane *) , amRCPlane |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
83 |
(*gtSniperRifleShot *) , amSniperRifle |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
84 |
(* gtJetpack *) , amJetpack |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
85 |
(* gtMolotov *) , amMolotov |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
86 |
(* gtBirdy *) , amBirdy |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
87 |
(* gtEgg *) , amBirdy |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
88 |
(* gtPortal *) , amPortalGun |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
89 |
(* gtPiano *) , amPiano |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
90 |
(* gtGasBomb *) , amGasBomb |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
91 |
(* gtSineGunShot *) , amSineGun |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
92 |
(* gtFlamethrower *) , amFlamethrower |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
93 |
(* gtSMine *) , amSMine |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
94 |
(* gtPoisonCloud *) , amNothing |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
95 |
(* gtHammer *) , amHammer |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
96 |
(* gtHammerHit *) , amHammer |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
97 |
(* gtResurrector *) , amResurrector |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
98 |
(* gtPoisonCloud *) , amNothing |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
99 |
(* gtSnowball *) , amSnowball |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
100 |
(* gtFlake *) , amNothing |
8161 | 101 |
//(* gtStructure *) , amStructure // TODO - This will undoubtedly change once there is more than one structure |
8145
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
102 |
(* gtLandGun *) , amLandGun |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
103 |
(* gtTardis *) , amTardis |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
104 |
(* gtIceGun *) , amIceGun |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
105 |
(* gtAddAmmo *) , amNothing |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
106 |
(* gtGenericFaller *) , amNothing |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
107 |
(* gtKnife *) , amKnife |
12198
71c47122fbc0
Add ammotype amDuck for rubber duck
Wuzzy <almikes@aol.com>
parents:
12197
diff
changeset
|
108 |
(* gtDuck *) , amDuck |
12903 | 109 |
(* gtMinigun *) , amMinigun |
110 |
(* gtMinigunBullet *) , amMinigun |
|
8145
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
111 |
); |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
112 |
|
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
113 |
|
7093 | 114 |
var GCounter: LongWord = 0; // this does not get re-initialized, but should be harmless |
7028 | 115 |
|
8145
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
116 |
const |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
117 |
cUsualZ = 500; |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
118 |
cOnHHZ = 2000; |
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset
|
119 |
|
6581 | 120 |
procedure InsertGearToList(Gear: PGear); |
121 |
var tmp, ptmp: PGear; |
|
122 |
begin |
|
123 |
tmp:= GearsList; |
|
124 |
ptmp:= GearsList; |
|
7366
e5a0856708dc
Insert at front of same Z, not end. Saves a little time on insertion and lua lookup of recent adds.
nemo
parents:
7364
diff
changeset
|
125 |
while (tmp <> nil) and (tmp^.Z < Gear^.Z) do |
6581 | 126 |
begin |
127 |
ptmp:= tmp; |
|
128 |
tmp:= tmp^.NextGear |
|
129 |
end; |
|
130 |
||
131 |
if ptmp <> tmp then |
|
132 |
begin |
|
133 |
Gear^.NextGear:= ptmp^.NextGear; |
|
134 |
Gear^.PrevGear:= ptmp; |
|
135 |
if ptmp^.NextGear <> nil then |
|
136 |
ptmp^.NextGear^.PrevGear:= Gear; |
|
137 |
ptmp^.NextGear:= Gear |
|
138 |
end |
|
139 |
else |
|
140 |
begin |
|
141 |
Gear^.NextGear:= GearsList; |
|
142 |
if Gear^.NextGear <> nil then |
|
143 |
Gear^.NextGear^.PrevGear:= Gear; |
|
144 |
GearsList:= Gear; |
|
145 |
end; |
|
146 |
end; |
|
147 |
||
7395 | 148 |
|
6581 | 149 |
procedure RemoveGearFromList(Gear: PGear); |
150 |
begin |
|
10634
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10625
diff
changeset
|
151 |
if (Gear <> GearsList) and (Gear <> nil) and (Gear^.NextGear = nil) and (Gear^.PrevGear = nil) then |
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10625
diff
changeset
|
152 |
begin |
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10625
diff
changeset
|
153 |
AddFileLog('Attempted to remove Gear #'+inttostr(Gear^.uid)+' from the list twice.'); |
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10625
diff
changeset
|
154 |
exit |
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10625
diff
changeset
|
155 |
end; |
11544 | 156 |
|
157 |
checkFails((Gear = nil) or (curHandledGear = nil) or (Gear = curHandledGear), 'You''re doing it wrong', true); |
|
7395 | 158 |
|
6581 | 159 |
if Gear^.NextGear <> nil then |
160 |
Gear^.NextGear^.PrevGear:= Gear^.PrevGear; |
|
161 |
if Gear^.PrevGear <> nil then |
|
162 |
Gear^.PrevGear^.NextGear:= Gear^.NextGear |
|
11043
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
163 |
else |
10634
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10625
diff
changeset
|
164 |
GearsList:= Gear^.NextGear; |
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10625
diff
changeset
|
165 |
|
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10625
diff
changeset
|
166 |
Gear^.NextGear:= nil; |
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10625
diff
changeset
|
167 |
Gear^.PrevGear:= nil |
6581 | 168 |
end; |
7395 | 169 |
|
170 |
||
6581 | 171 |
function AddGear(X, Y: LongInt; Kind: TGearType; State: Longword; dX, dY: hwFloat; Timer: LongWord): PGear; |
11207 | 172 |
begin |
173 |
AddGear:= AddGear(X, Y, Kind, State, dX, dY, Timer, 0); |
|
174 |
end; |
|
175 |
function AddGear(X, Y: LongInt; Kind: TGearType; State: Longword; dX, dY: hwFloat; Timer, newUid: LongWord): PGear; |
|
6581 | 176 |
var gear: PGear; |
10518
dbbe2f6c0a96
make gear ability to speak somewhat less ironic
sheepluva
parents:
10495
diff
changeset
|
177 |
//c: byte; |
10874
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset
|
178 |
cakeData: PCakeData; |
6581 | 179 |
begin |
11207 | 180 |
if newUid = 0 then |
181 |
inc(GCounter); |
|
8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7754
diff
changeset
|
182 |
|
7028 | 183 |
AddFileLog('AddGear: #' + inttostr(GCounter) + ' (' + inttostr(x) + ',' + inttostr(y) + '), d(' + floattostr(dX) + ',' + floattostr(dY) + ') type = ' + EnumToStr(Kind)); |
6581 | 184 |
|
8330 | 185 |
|
6581 | 186 |
New(gear); |
187 |
FillChar(gear^, sizeof(TGear), 0); |
|
188 |
gear^.X:= int2hwFloat(X); |
|
189 |
gear^.Y:= int2hwFloat(Y); |
|
190 |
gear^.Target.X:= NoPointX; |
|
191 |
gear^.Kind := Kind; |
|
192 |
gear^.State:= State; |
|
193 |
gear^.Active:= true; |
|
194 |
gear^.dX:= dX; |
|
195 |
gear^.dY:= dY; |
|
196 |
gear^.doStep:= doStepHandlers[Kind]; |
|
197 |
gear^.CollisionIndex:= -1; |
|
198 |
gear^.Timer:= Timer; |
|
11207 | 199 |
if newUid = 0 then |
200 |
gear^.uid:= GCounter |
|
201 |
else gear^.uid:= newUid; |
|
6581 | 202 |
gear^.SoundChannel:= -1; |
203 |
gear^.ImpactSound:= sndNone; |
|
204 |
gear^.Density:= _1; |
|
205 |
// Define ammo association, if any. |
|
206 |
gear^.AmmoType:= GearKindAmmoTypeMap[Kind]; |
|
7730
2013733f9ca9
A bit more on the knife. Also add missing files to CMakeLists
nemo
parents:
7726
diff
changeset
|
207 |
gear^.CollisionMask:= $FFFF; |
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset
|
208 |
gear^.Tint:= $FFFFFFFF; |
10874
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset
|
209 |
gear^.Data:= nil; |
7272
71df899c4163
Second part of the change. Make collision check use the new mask bit.
nemo
parents:
7176
diff
changeset
|
210 |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
211 |
if CurrentHedgehog <> nil then |
7726
1137406bce12
Set default collision mask for gears at currenthedgehog X/Y to FF7F, expose mask to scripting as well. This should resolve the collision part of bug #420
nemo
parents:
7721
diff
changeset
|
212 |
begin |
1137406bce12
Set default collision mask for gears at currenthedgehog X/Y to FF7F, expose mask to scripting as well. This should resolve the collision part of bug #420
nemo
parents:
7721
diff
changeset
|
213 |
gear^.Hedgehog:= CurrentHedgehog; |
1137406bce12
Set default collision mask for gears at currenthedgehog X/Y to FF7F, expose mask to scripting as well. This should resolve the collision part of bug #420
nemo
parents:
7721
diff
changeset
|
214 |
if (CurrentHedgehog^.Gear <> nil) and (hwRound(CurrentHedgehog^.Gear^.X) = X) and (hwRound(CurrentHedgehog^.Gear^.Y) = Y) then |
8751
4609823efc94
More flagging of Land values. Also use less than for tests of non-terrain, instead of "and $FF00 = 0". Saves a couple of ops, which actually matters a small amount in a few places.
nemo
parents:
8744
diff
changeset
|
215 |
gear^.CollisionMask:= lfNotCurrentMask |
7730
2013733f9ca9
A bit more on the knife. Also add missing files to CMakeLists
nemo
parents:
7726
diff
changeset
|
216 |
end; |
7272
71df899c4163
Second part of the change. Make collision check use the new mask bit.
nemo
parents:
7176
diff
changeset
|
217 |
|
7364 | 218 |
if (Ammoz[Gear^.AmmoType].Ammo.Propz and ammoprop_NeedTarget <> 0) then |
6581 | 219 |
gear^.Z:= cHHZ+1 |
220 |
else gear^.Z:= cUsualZ; |
|
221 |
||
11473
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
222 |
case Kind of |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
223 |
gtFlame: Gear^.Boom := 2; // some additional expl in there are x3, x4 this |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
224 |
gtHedgehog: Gear^.Boom := 30; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
225 |
gtMine: Gear^.Boom := 50; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
226 |
gtCase: Gear^.Boom := 25; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
227 |
gtAirMine: Gear^.Boom := 25; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
228 |
gtExplosives: Gear^.Boom := 75; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
229 |
gtGrenade: Gear^.Boom := 50; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
230 |
gtShell: Gear^.Boom := 50; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
231 |
gtBee: Gear^.Boom := 50; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
232 |
gtShotgunShot: Gear^.Boom := 25; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
233 |
gtPickHammer: Gear^.Boom := 6; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
234 |
// gtRope: Gear^.Boom := 2; could be funny to have rope attaching to hog deal small amount of dmg? |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
235 |
gtDEagleShot: Gear^.Boom := 7; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
236 |
gtDynamite: Gear^.Boom := 75; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
237 |
gtClusterBomb: Gear^.Boom := 20; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
238 |
gtMelonPiece, |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
239 |
gtCluster: Gear^.Boom := Timer; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
240 |
gtShover: Gear^.Boom := 30; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
241 |
gtFirePunch: Gear^.Boom := 30; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
242 |
gtAirBomb: Gear^.Boom := 30; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
243 |
gtBlowTorch: Gear^.Boom := 2; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
244 |
gtMortar: Gear^.Boom := 20; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
245 |
gtWhip: Gear^.Boom := 30; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
246 |
gtKamikaze: Gear^.Boom := 30; // both shove and explosion |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
247 |
gtCake: Gear^.Boom := cakeDmg; // why is cake damage a global constant |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
248 |
gtWatermelon: Gear^.Boom := 75; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
249 |
gtHellishBomb: Gear^.Boom := 90; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
250 |
gtDrill: if Gear^.State and gsttmpFlag = 0 then |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
251 |
Gear^.Boom := 50 |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
252 |
else Gear^.Boom := 30; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
253 |
gtBall: Gear^.Boom := 40; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
254 |
gtRCPlane: Gear^.Boom := 25; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
255 |
// sniper rifle is distance linked, this Boom is just an arbitrary scaling factor applied to timer-based-damage |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
256 |
// because, eh, why not.. |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
257 |
gtSniperRifleShot: Gear^.Boom := 100000; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
258 |
gtEgg: Gear^.Boom := 10; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
259 |
gtPiano: Gear^.Boom := 80; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
260 |
gtGasBomb: Gear^.Boom := 20; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
261 |
gtSineGunShot: Gear^.Boom := 35; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
262 |
gtSMine: Gear^.Boom := 30; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
263 |
gtSnowball: Gear^.Boom := 200000; // arbitrary scaling for the shove |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
264 |
gtHammer: if cDamageModifier > _1 then // scale it based on cDamageModifier? |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
265 |
Gear^.Boom := 2 |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
266 |
else Gear^.Boom := 3; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
267 |
gtPoisonCloud: Gear^.Boom := 20; |
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
268 |
gtKnife: Gear^.Boom := 40000; // arbitrary scaling factor since impact-based |
12197 | 269 |
gtDuck: Gear^.Boom := 40; |
12903 | 270 |
gtMinigunBullet: Gear^.Boom := 2; |
11473
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11207
diff
changeset
|
271 |
end; |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
272 |
|
6581 | 273 |
case Kind of |
274 |
gtGrenade, |
|
275 |
gtClusterBomb, |
|
276 |
gtGasBomb: begin |
|
277 |
gear^.ImpactSound:= sndGrenadeImpact; |
|
278 |
gear^.nImpactSounds:= 1; |
|
279 |
gear^.AdvBounce:= 1; |
|
280 |
gear^.Radius:= 5; |
|
281 |
gear^.Elasticity:= _0_8; |
|
282 |
gear^.Friction:= _0_8; |
|
283 |
gear^.Density:= _1_5; |
|
284 |
gear^.RenderTimer:= true; |
|
285 |
if gear^.Timer = 0 then |
|
286 |
gear^.Timer:= 3000 |
|
287 |
end; |
|
288 |
gtWatermelon: begin |
|
289 |
gear^.ImpactSound:= sndMelonImpact; |
|
290 |
gear^.nImpactSounds:= 1; |
|
291 |
gear^.AdvBounce:= 1; |
|
292 |
gear^.Radius:= 6; |
|
293 |
gear^.Elasticity:= _0_8; |
|
294 |
gear^.Friction:= _0_995; |
|
295 |
gear^.Density:= _2; |
|
296 |
gear^.RenderTimer:= true; |
|
297 |
if gear^.Timer = 0 then |
|
298 |
gear^.Timer:= 3000 |
|
299 |
end; |
|
300 |
gtMelonPiece: begin |
|
9825 | 301 |
gear^.AdvBounce:= 1; |
10889
f7200e614295
give melon pieces a radius. is why they weren't bouncing.
nemo
parents:
10875
diff
changeset
|
302 |
gear^.Density:= _2; |
11036
6e866be63b1d
oops. melon pieces need friction and elasticity to bounce right.
nemo
parents:
11002
diff
changeset
|
303 |
gear^.Elasticity:= _0_8; |
6e866be63b1d
oops. melon pieces need friction and elasticity to bounce right.
nemo
parents:
11002
diff
changeset
|
304 |
gear^.Friction:= _0_995; |
10889
f7200e614295
give melon pieces a radius. is why they weren't bouncing.
nemo
parents:
10875
diff
changeset
|
305 |
gear^.Radius:= 4 |
6581 | 306 |
end; |
307 |
gtHedgehog: begin |
|
308 |
gear^.AdvBounce:= 1; |
|
309 |
gear^.Radius:= cHHRadius; |
|
310 |
gear^.Elasticity:= _0_35; |
|
311 |
gear^.Friction:= _0_999; |
|
312 |
gear^.Angle:= cMaxAngle div 2; |
|
313 |
gear^.Density:= _3; |
|
314 |
gear^.Z:= cHHZ; |
|
315 |
if (GameFlags and gfAISurvival) <> 0 then |
|
316 |
if gear^.Hedgehog^.BotLevel > 0 then |
|
7077 | 317 |
gear^.Hedgehog^.Effects[heResurrectable] := 1; |
13101
d78e65c66573
Add hedgehog effect heArtillery, allows to set per-hedgehog artillery mode
Wuzzy <Wuzzy2@mail.ru>
parents:
12903
diff
changeset
|
318 |
if (GameFlags and gfArtillery) <> 0 then |
d78e65c66573
Add hedgehog effect heArtillery, allows to set per-hedgehog artillery mode
Wuzzy <Wuzzy2@mail.ru>
parents:
12903
diff
changeset
|
319 |
gear^.Hedgehog^.Effects[heArtillery] := 1; |
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset
|
320 |
// this would presumably be set in the frontend |
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset
|
321 |
// if we weren't going to do that yet, would need to reinit GetRandom |
10040 | 322 |
// oh, and, randomising slightly R and B might be nice too. |
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset
|
323 |
//gear^.Tint:= $fa00efff or ((random(80)+128) shl 16) |
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset
|
324 |
//gear^.Tint:= $faa4efff |
10040 | 325 |
//gear^.Tint:= (($e0+random(32)) shl 24) or |
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset
|
326 |
// ((random(80)+128) shl 16) or |
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset
|
327 |
// (($d5+random(32)) shl 8) or $ff |
10495
6d61b44a5652
- Comment out getrandom in addgear for hedgehog, causes preview-game desync
unc0rr
parents:
10494
diff
changeset
|
328 |
{c:= GetRandom(32); |
10040 | 329 |
gear^.Tint:= (($e0+c) shl 24) or |
10494 | 330 |
((GetRandom(90)+128) shl 16) or |
10495
6d61b44a5652
- Comment out getrandom in addgear for hedgehog, causes preview-game desync
unc0rr
parents:
10494
diff
changeset
|
331 |
(($d5+c) shl 8) or $ff} |
6581 | 332 |
end; |
333 |
gtShell: begin |
|
9721
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset
|
334 |
gear^.Elasticity:= _0_8; |
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset
|
335 |
gear^.Friction:= _0_8; |
6581 | 336 |
gear^.Radius:= 4; |
337 |
gear^.Density:= _1; |
|
9721
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset
|
338 |
gear^.AdvBounce:= 1; |
6581 | 339 |
end; |
340 |
gtSnowball: begin |
|
341 |
gear^.ImpactSound:= sndMudballImpact; |
|
342 |
gear^.nImpactSounds:= 1; |
|
343 |
gear^.Radius:= 4; |
|
344 |
gear^.Density:= _0_5; |
|
9721
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset
|
345 |
gear^.AdvBounce:= 1; |
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset
|
346 |
gear^.Elasticity:= _0_8; |
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset
|
347 |
gear^.Friction:= _0_8; |
6581 | 348 |
end; |
349 |
||
350 |
gtFlake: begin |
|
351 |
with Gear^ do |
|
352 |
begin |
|
353 |
Pos:= 0; |
|
354 |
Radius:= 1; |
|
7069 | 355 |
DirAngle:= random(360); |
6581 | 356 |
if State and gstTmpFlag = 0 then |
357 |
begin |
|
358 |
dx.isNegative:= GetRandom(2) = 0; |
|
9809 | 359 |
dx.QWordValue:= QWord($40DA) * GetRandom(10000) * 8; |
6581 | 360 |
dy.isNegative:= false; |
9809 | 361 |
dy.QWordValue:= QWord($3AD3) * GetRandom(7000) * 8; |
6581 | 362 |
if GetRandom(2) = 0 then |
10645
b8c73bacb31e
Fix in-flight colouring of land spray, make it use tint when added to land too (lua might find that handy), tweak climbhome cake delay slightly
nemo
parents:
10643
diff
changeset
|
363 |
dx := -dx; |
b8c73bacb31e
Fix in-flight colouring of land spray, make it use tint when added to land too (lua might find that handy), tweak climbhome cake delay slightly
nemo
parents:
10643
diff
changeset
|
364 |
Tint:= $FFFFFFFF |
b8c73bacb31e
Fix in-flight colouring of land spray, make it use tint when added to land too (lua might find that handy), tweak climbhome cake delay slightly
nemo
parents:
10643
diff
changeset
|
365 |
end |
b8c73bacb31e
Fix in-flight colouring of land spray, make it use tint when added to land too (lua might find that handy), tweak climbhome cake delay slightly
nemo
parents:
10643
diff
changeset
|
366 |
else |
b8c73bacb31e
Fix in-flight colouring of land spray, make it use tint when added to land too (lua might find that handy), tweak climbhome cake delay slightly
nemo
parents:
10643
diff
changeset
|
367 |
Tint:= (ExplosionBorderColor shr RShift and $FF shl 24) or |
b8c73bacb31e
Fix in-flight colouring of land spray, make it use tint when added to land too (lua might find that handy), tweak climbhome cake delay slightly
nemo
parents:
10643
diff
changeset
|
368 |
(ExplosionBorderColor shr GShift and $FF shl 16) or |
b8c73bacb31e
Fix in-flight colouring of land spray, make it use tint when added to land too (lua might find that handy), tweak climbhome cake delay slightly
nemo
parents:
10643
diff
changeset
|
369 |
(ExplosionBorderColor shr BShift and $FF shl 8) or $FF; |
6581 | 370 |
State:= State or gstInvisible; |
10625
125e120165aa
flake FrameTicks value of 0 now indicades that the frame should not be changed
sheepluva
parents:
10589
diff
changeset
|
371 |
// use health field to store current frameticks |
125e120165aa
flake FrameTicks value of 0 now indicades that the frame should not be changed
sheepluva
parents:
10589
diff
changeset
|
372 |
if vobFrameTicks > 0 then |
125e120165aa
flake FrameTicks value of 0 now indicades that the frame should not be changed
sheepluva
parents:
10589
diff
changeset
|
373 |
Health:= random(vobFrameTicks) |
125e120165aa
flake FrameTicks value of 0 now indicades that the frame should not be changed
sheepluva
parents:
10589
diff
changeset
|
374 |
else |
125e120165aa
flake FrameTicks value of 0 now indicades that the frame should not be changed
sheepluva
parents:
10589
diff
changeset
|
375 |
Health:= 0; |
125e120165aa
flake FrameTicks value of 0 now indicades that the frame should not be changed
sheepluva
parents:
10589
diff
changeset
|
376 |
// use timer to store currently displayed frame index |
9195
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
377 |
if gear^.Timer = 0 then Timer:= random(vobFramesCount); |
10645
b8c73bacb31e
Fix in-flight colouring of land spray, make it use tint when added to land too (lua might find that handy), tweak climbhome cake delay slightly
nemo
parents:
10643
diff
changeset
|
378 |
Damage:= (random(2) * 2 - 1) * (vobVelocity + random(vobVelocity)) * 8 |
6581 | 379 |
end |
380 |
end; |
|
381 |
gtGrave: begin |
|
382 |
gear^.ImpactSound:= sndGraveImpact; |
|
383 |
gear^.nImpactSounds:= 1; |
|
384 |
gear^.Radius:= 10; |
|
385 |
gear^.Elasticity:= _0_6; |
|
11546 | 386 |
gear^.Z:= 1; |
6581 | 387 |
end; |
388 |
gtBee: begin |
|
389 |
gear^.Radius:= 5; |
|
9195
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
390 |
if gear^.Timer = 0 then gear^.Timer:= 500; |
6581 | 391 |
gear^.RenderTimer:= true; |
392 |
gear^.Elasticity:= _0_9; |
|
393 |
gear^.Tag:= 0; |
|
9479
167dea42d7d7
move border back a bit from left/right bounds, bee tweak
nemo
parents:
9195
diff
changeset
|
394 |
gear^.State:= Gear^.State or gstSubmersible |
6581 | 395 |
end; |
396 |
gtSeduction: begin |
|
397 |
gear^.Radius:= 250; |
|
398 |
end; |
|
399 |
gtShotgunShot: begin |
|
9195
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
400 |
if gear^.Timer = 0 then gear^.Timer:= 900; |
6581 | 401 |
gear^.Radius:= 2 |
402 |
end; |
|
403 |
gtPickHammer: begin |
|
404 |
gear^.Radius:= 10; |
|
9195
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
405 |
if gear^.Timer = 0 then gear^.Timer:= 4000 |
6581 | 406 |
end; |
407 |
gtHammerHit: begin |
|
408 |
gear^.Radius:= 8; |
|
9195
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
409 |
if gear^.Timer = 0 then gear^.Timer:= 125 |
6581 | 410 |
end; |
411 |
gtRope: begin |
|
412 |
gear^.Radius:= 3; |
|
413 |
gear^.Friction:= _450 * _0_01 * cRopePercent; |
|
414 |
RopePoints.Count:= 0; |
|
10848 | 415 |
gear^.Tint:= $D8D8D8FF; |
416 |
gear^.Tag:= 0; // normal rope render |
|
11836
dd18d8100afd
Change this back to allowing hooking rope to hogs again, 'cause, well, rage...
nemo
parents:
11770
diff
changeset
|
417 |
gear^.CollisionMask:= lfNotCurrentMask //lfNotObjMask or lfNotHHObjMask; |
6581 | 418 |
end; |
419 |
gtMine: begin |
|
420 |
gear^.ImpactSound:= sndMineImpact; |
|
421 |
gear^.nImpactSounds:= 1; |
|
422 |
gear^.Health:= 10; |
|
423 |
gear^.State:= gear^.State or gstMoving; |
|
424 |
gear^.Radius:= 2; |
|
425 |
gear^.Elasticity:= _0_55; |
|
426 |
gear^.Friction:= _0_995; |
|
7602
a620319d377e
Fix throwing things off rope, also make throwing things a bit more generic and gear density dependent (so you can throw mines further, and also throw dynamite a little).
nemo
parents:
7395
diff
changeset
|
427 |
gear^.Density:= _1; |
9195
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
428 |
if gear^.Timer = 0 then |
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
429 |
begin |
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
430 |
if cMinesTime < 0 then |
12174
869cf5f34700
More ticker messages: Sick, king died, resurrect, time box return, timeout, kamikaze
Wuzzy <almikes@aol.com>
parents:
12124
diff
changeset
|
431 |
gear^.Timer:= getrandom(51)*100 |
9195
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
432 |
else |
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
433 |
gear^.Timer:= cMinesTime |
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
434 |
end |
6581 | 435 |
end; |
10789
acbf69e2e5cf
experiment with air mines. thought they could make shoppa... interesting. ToDo: Allow mines to give up, tweak distances, real graphics, toggle for whether they can acquire a new target while they haven't given up.
nemo
parents:
10663
diff
changeset
|
436 |
gtAirMine: begin |
11770
10860d4bca22
Add sound effects for: cleaver impact, air mine impact, using extra time
Wuzzy <almikes@aol.com>
parents:
11594
diff
changeset
|
437 |
gear^.ImpactSound:= sndAirMineImpact; |
10789
acbf69e2e5cf
experiment with air mines. thought they could make shoppa... interesting. ToDo: Allow mines to give up, tweak distances, real graphics, toggle for whether they can acquire a new target while they haven't given up.
nemo
parents:
10663
diff
changeset
|
438 |
gear^.nImpactSounds:= 1; |
acbf69e2e5cf
experiment with air mines. thought they could make shoppa... interesting. ToDo: Allow mines to give up, tweak distances, real graphics, toggle for whether they can acquire a new target while they haven't given up.
nemo
parents:
10663
diff
changeset
|
439 |
gear^.Health:= 30; |
10827 | 440 |
gear^.State:= gear^.State or gstMoving or gstNoGravity or gstSubmersible; |
10802
089e43d01f74
Use the larger scaled airmine sprite originally intended, add some antidickery measures.
nemo
parents:
10800
diff
changeset
|
441 |
gear^.Radius:= 8; |
10789
acbf69e2e5cf
experiment with air mines. thought they could make shoppa... interesting. ToDo: Allow mines to give up, tweak distances, real graphics, toggle for whether they can acquire a new target while they haven't given up.
nemo
parents:
10663
diff
changeset
|
442 |
gear^.Elasticity:= _0_55; |
acbf69e2e5cf
experiment with air mines. thought they could make shoppa... interesting. ToDo: Allow mines to give up, tweak distances, real graphics, toggle for whether they can acquire a new target while they haven't given up.
nemo
parents:
10663
diff
changeset
|
443 |
gear^.Friction:= _0_995; |
acbf69e2e5cf
experiment with air mines. thought they could make shoppa... interesting. ToDo: Allow mines to give up, tweak distances, real graphics, toggle for whether they can acquire a new target while they haven't given up.
nemo
parents:
10663
diff
changeset
|
444 |
gear^.Density:= _1; |
10791
0311c9fa7498
tweak a few params. still something wtf going on when on rope
nemo
parents:
10789
diff
changeset
|
445 |
gear^.Angle:= 175; // Radius at which air bombs will start "seeking". $FFFFFFFF = unlimited. check is skipped. |
10800 | 446 |
gear^.Power:= cMaxWindSpeed.QWordValue div 2; // hwFloat converted. 1/2 g default. defines the "seek" speed when a gear is in range. |
10828
9867dd60a66a
bit more friction. remove gstSubmersible clearing. was for the old "sea" thing that is totally gone now. As a general attribute, better to let other stuff clear it as needed.
nemo
parents:
10827
diff
changeset
|
447 |
gear^.Pos:= cMaxWindSpeed.QWordValue * 3 div 2; // air friction. slows it down when not hitting stuff |
10789
acbf69e2e5cf
experiment with air mines. thought they could make shoppa... interesting. ToDo: Allow mines to give up, tweak distances, real graphics, toggle for whether they can acquire a new target while they haven't given up.
nemo
parents:
10663
diff
changeset
|
448 |
gear^.Karma:= 30; // damage |
10805 | 449 |
if gear^.Timer = 0 then |
450 |
begin |
|
451 |
if cMinesTime < 0 then |
|
452 |
gear^.Timer:= getrandom(13)*100 |
|
453 |
else |
|
454 |
gear^.Timer:= cMinesTime div 4 |
|
455 |
end; |
|
456 |
gear^.WDTimer:= gear^.Timer |
|
10789
acbf69e2e5cf
experiment with air mines. thought they could make shoppa... interesting. ToDo: Allow mines to give up, tweak distances, real graphics, toggle for whether they can acquire a new target while they haven't given up.
nemo
parents:
10663
diff
changeset
|
457 |
end; |
6581 | 458 |
gtSMine: begin |
459 |
gear^.Health:= 10; |
|
460 |
gear^.State:= gear^.State or gstMoving; |
|
461 |
gear^.Radius:= 2; |
|
462 |
gear^.Elasticity:= _0_55; |
|
463 |
gear^.Friction:= _0_995; |
|
7602
a620319d377e
Fix throwing things off rope, also make throwing things a bit more generic and gear density dependent (so you can throw mines further, and also throw dynamite a little).
nemo
parents:
7395
diff
changeset
|
464 |
gear^.Density:= _1_6; |
9721
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset
|
465 |
gear^.AdvBounce:= 1; |
9195
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
466 |
if gear^.Timer = 0 then gear^.Timer:= 500; |
6581 | 467 |
end; |
7733 | 468 |
gtKnife: begin |
11770
10860d4bca22
Add sound effects for: cleaver impact, air mine impact, using extra time
Wuzzy <almikes@aol.com>
parents:
11594
diff
changeset
|
469 |
gear^.ImpactSound:= sndKnifeImpact; |
9721
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset
|
470 |
gear^.AdvBounce:= 1; |
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset
|
471 |
gear^.Elasticity:= _0_8; |
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset
|
472 |
gear^.Friction:= _0_8; |
7754 | 473 |
gear^.Density:= _4; |
8494
53b91a602955
Cleaver tweaks based on feedback. Nerf damage, shrink radius. This means cleaver will embed into ground quite a bit further.
nemo
parents:
8161
diff
changeset
|
474 |
gear^.Radius:= 7 |
7733 | 475 |
end; |
6581 | 476 |
gtCase: begin |
477 |
gear^.ImpactSound:= sndGraveImpact; |
|
478 |
gear^.nImpactSounds:= 1; |
|
479 |
gear^.Radius:= 16; |
|
7168
8defaabce92e
warp sound when AI survival hog respawns. attempt at a bit of a crate spawn animation (moar sparkles and a quick fadein)
nemo
parents:
7093
diff
changeset
|
480 |
gear^.Elasticity:= _0_3; |
9195
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
481 |
if gear^.Timer = 0 then gear^.Timer:= 500 |
6581 | 482 |
end; |
483 |
gtExplosives: begin |
|
9721
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset
|
484 |
gear^.AdvBounce:= 1; |
6581 | 485 |
gear^.ImpactSound:= sndGrenadeImpact; |
486 |
gear^.nImpactSounds:= 1; |
|
487 |
gear^.Radius:= 16; |
|
488 |
gear^.Elasticity:= _0_4; |
|
489 |
gear^.Friction:= _0_995; |
|
490 |
gear^.Density:= _6; |
|
491 |
gear^.Health:= cBarrelHealth; |
|
492 |
gear^.Z:= cHHZ-1 |
|
493 |
end; |
|
494 |
gtDEagleShot: begin |
|
495 |
gear^.Radius:= 1; |
|
496 |
gear^.Health:= 50 |
|
497 |
end; |
|
498 |
gtSniperRifleShot: begin |
|
499 |
gear^.Radius:= 1; |
|
500 |
gear^.Health:= 50 |
|
501 |
end; |
|
502 |
gtDynamite: begin |
|
503 |
gear^.Radius:= 3; |
|
504 |
gear^.Elasticity:= _0_55; |
|
505 |
gear^.Friction:= _0_03; |
|
506 |
gear^.Density:= _2; |
|
9195
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
507 |
if gear^.Timer = 0 then gear^.Timer:= 5000; |
6581 | 508 |
end; |
509 |
gtCluster: begin |
|
9721
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset
|
510 |
gear^.AdvBounce:= 1; |
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset
|
511 |
gear^.Elasticity:= _0_8; |
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset
|
512 |
gear^.Friction:= _0_8; |
6581 | 513 |
gear^.Radius:= 2; |
514 |
gear^.Density:= _1_5; |
|
515 |
gear^.RenderTimer:= true |
|
516 |
end; |
|
12124 | 517 |
gtShover: begin |
518 |
gear^.Radius:= 20; |
|
519 |
gear^.Tag:= 0; |
|
12833 | 520 |
gear^.Timer:= 50; |
12124 | 521 |
end; |
6581 | 522 |
gtFlame: begin |
523 |
gear^.Tag:= GetRandom(32); |
|
524 |
gear^.Radius:= 1; |
|
525 |
gear^.Health:= 5; |
|
526 |
gear^.Density:= _1; |
|
10589
98ea597e5cd9
expose FlightTime to lua, disable in-air flame harming moving hogs ☹ aaaand override that in ClimbHome ☺
nemo
parents:
10518
diff
changeset
|
527 |
gear^.FlightTime:= 9999999; // determines whether in-air flames do damage. disabled by default |
6581 | 528 |
if (gear^.dY.QWordValue = 0) and (gear^.dX.QWordValue = 0) then |
529 |
begin |
|
7001 | 530 |
gear^.dY:= (getrandomf - _0_8) * _0_03; |
531 |
gear^.dX:= (getrandomf - _0_5) * _0_4 |
|
6581 | 532 |
end |
533 |
end; |
|
534 |
gtFirePunch: begin |
|
9824 | 535 |
if gear^.Timer = 0 then gear^.Timer:= 3000; |
6581 | 536 |
gear^.Radius:= 15; |
537 |
gear^.Tag:= Y |
|
538 |
end; |
|
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset
|
539 |
gtAirAttack: begin |
11175 | 540 |
gear^.Health:= 6; |
11174
22d8835beb4d
Allow for arbitrary number of airstrike bombs and spacing.
nemo
parents:
11173
diff
changeset
|
541 |
gear^.Damage:= 30; |
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset
|
542 |
gear^.Z:= cHHZ+2; |
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset
|
543 |
gear^.Tint:= gear^.Hedgehog^.Team^.Clan^.Color shl 8 or $FF |
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset
|
544 |
end; |
6581 | 545 |
gtAirBomb: begin |
10891
a4c454ef80a6
enable bounce on rubber for air bombs. give them the missing elasticity they needed for the code there to work properly.
nemo
parents:
10889
diff
changeset
|
546 |
gear^.AdvBounce:= 1; |
6581 | 547 |
gear^.Radius:= 5; |
548 |
gear^.Density:= _2; |
|
10891
a4c454ef80a6
enable bounce on rubber for air bombs. give them the missing elasticity they needed for the code there to work properly.
nemo
parents:
10889
diff
changeset
|
549 |
gear^.Elasticity:= _0_55; |
a4c454ef80a6
enable bounce on rubber for air bombs. give them the missing elasticity they needed for the code there to work properly.
nemo
parents:
10889
diff
changeset
|
550 |
gear^.Friction:= _0_995 |
6581 | 551 |
end; |
552 |
gtBlowTorch: begin |
|
553 |
gear^.Radius:= cHHRadius + cBlowTorchC; |
|
9195
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
554 |
if gear^.Timer = 0 then gear^.Timer:= 7500 |
6581 | 555 |
end; |
556 |
gtSwitcher: begin |
|
557 |
gear^.Z:= cCurrHHZ |
|
558 |
end; |
|
559 |
gtTarget: begin |
|
560 |
gear^.ImpactSound:= sndGrenadeImpact; |
|
561 |
gear^.nImpactSounds:= 1; |
|
562 |
gear^.Radius:= 10; |
|
563 |
gear^.Elasticity:= _0_3; |
|
564 |
end; |
|
565 |
gtTardis: begin |
|
566 |
gear^.Pos:= 1; |
|
567 |
gear^.Z:= cCurrHHZ+1; |
|
568 |
end; |
|
569 |
gtMortar: begin |
|
9721
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset
|
570 |
gear^.AdvBounce:= 1; |
6581 | 571 |
gear^.Radius:= 4; |
572 |
gear^.Elasticity:= _0_2; |
|
573 |
gear^.Friction:= _0_08; |
|
574 |
gear^.Density:= _1; |
|
575 |
end; |
|
576 |
gtWhip: gear^.Radius:= 20; |
|
577 |
gtHammer: gear^.Radius:= 20; |
|
578 |
gtKamikaze: begin |
|
579 |
gear^.Health:= 2048; |
|
580 |
gear^.Radius:= 20 |
|
581 |
end; |
|
582 |
gtCake: begin |
|
583 |
gear^.Health:= 2048; |
|
584 |
gear^.Radius:= 7; |
|
585 |
gear^.Z:= cOnHHZ; |
|
10875 | 586 |
gear^.RenderTimer:= false; |
6581 | 587 |
gear^.DirAngle:= -90 * hwSign(Gear^.dX); |
12646
f30b70976577
Fix cake taking >200s to explode when it's completely stuck and can't move (bug 194)
Wuzzy <almikes@aol.com>
parents:
12208
diff
changeset
|
588 |
gear^.FlightTime:= 100; // (roughly) ticks spent dropping, used to skip getting up anim when stuck. |
f30b70976577
Fix cake taking >200s to explode when it's completely stuck and can't move (bug 194)
Wuzzy <almikes@aol.com>
parents:
12208
diff
changeset
|
589 |
// Initially set to a high value so cake has at least one getting up anim. |
6581 | 590 |
if not dX.isNegative then |
591 |
gear^.Angle:= 1 |
|
592 |
else |
|
10874
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset
|
593 |
gear^.Angle:= 3; |
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset
|
594 |
New(cakeData); |
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset
|
595 |
gear^.Data:= Pointer(cakeData); |
6581 | 596 |
end; |
597 |
gtHellishBomb: begin |
|
598 |
gear^.ImpactSound:= sndHellishImpact1; |
|
599 |
gear^.nImpactSounds:= 4; |
|
600 |
gear^.AdvBounce:= 1; |
|
601 |
gear^.Radius:= 4; |
|
602 |
gear^.Elasticity:= _0_5; |
|
603 |
gear^.Friction:= _0_96; |
|
604 |
gear^.Density:= _1_5; |
|
605 |
gear^.RenderTimer:= true; |
|
9195
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
606 |
if gear^.Timer = 0 then gear^.Timer:= 5000 |
6581 | 607 |
end; |
608 |
gtDrill: begin |
|
9721
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset
|
609 |
gear^.AdvBounce:= 1; |
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset
|
610 |
gear^.Elasticity:= _0_8; |
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset
|
611 |
gear^.Friction:= _0_8; |
6581 | 612 |
if gear^.Timer = 0 then |
613 |
gear^.Timer:= 5000; |
|
614 |
// Tag for drill strike. if 1 then first impact occured already |
|
615 |
gear^.Tag := 0; |
|
616 |
gear^.Radius:= 4; |
|
617 |
gear^.Density:= _1; |
|
618 |
end; |
|
619 |
gtBall: begin |
|
620 |
gear^.ImpactSound:= sndGrenadeImpact; |
|
621 |
gear^.nImpactSounds:= 1; |
|
622 |
gear^.AdvBounce:= 1; |
|
623 |
gear^.Radius:= 5; |
|
624 |
gear^.Tag:= random(8); |
|
9195
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
625 |
if gear^.Timer = 0 then gear^.Timer:= 5000; |
6581 | 626 |
gear^.Elasticity:= _0_7; |
627 |
gear^.Friction:= _0_995; |
|
628 |
gear^.Density:= _1_5; |
|
629 |
end; |
|
630 |
gtBallgun: begin |
|
9195
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
631 |
if gear^.Timer = 0 then gear^.Timer:= 5001; |
6581 | 632 |
end; |
633 |
gtRCPlane: begin |
|
9195
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
634 |
if gear^.Timer = 0 then gear^.Timer:= 15000; |
6581 | 635 |
gear^.Health:= 3; |
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset
|
636 |
gear^.Radius:= 8; |
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset
|
637 |
gear^.Tint:= gear^.Hedgehog^.Team^.Clan^.Color shl 8 or $FF |
6581 | 638 |
end; |
639 |
gtJetpack: begin |
|
640 |
gear^.Health:= 2000; |
|
8987
47cf32305d99
some saucer thing for firing weps underwater and aiming and such. bit drunk and sleepy so testing I guess
nemo
parents:
8795
diff
changeset
|
641 |
gear^.Damage:= 100; |
9195
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
642 |
gear^.State:= Gear^.State or gstSubmersible |
6581 | 643 |
end; |
644 |
gtMolotov: begin |
|
9825 | 645 |
gear^.AdvBounce:= 1; |
6581 | 646 |
gear^.Radius:= 6; |
12669
943b258d5443
Fix molotov cocktails bouncing off vertically off rubber
Wuzzy <almikes@aol.com>
parents:
12646
diff
changeset
|
647 |
gear^.Elasticity:= _0_8; |
943b258d5443
Fix molotov cocktails bouncing off vertically off rubber
Wuzzy <almikes@aol.com>
parents:
12646
diff
changeset
|
648 |
gear^.Friction:= _0_8; |
9825 | 649 |
gear^.Density:= _2 |
6581 | 650 |
end; |
651 |
gtBirdy: begin |
|
652 |
gear^.Radius:= 16; // todo: check |
|
653 |
gear^.Health := 2000; |
|
9825 | 654 |
gear^.FlightTime := 2 |
6581 | 655 |
end; |
656 |
gtEgg: begin |
|
9721
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset
|
657 |
gear^.AdvBounce:= 1; |
6581 | 658 |
gear^.Radius:= 4; |
659 |
gear^.Elasticity:= _0_6; |
|
660 |
gear^.Friction:= _0_96; |
|
661 |
gear^.Density:= _1; |
|
662 |
if gear^.Timer = 0 then |
|
663 |
gear^.Timer:= 3000 |
|
664 |
end; |
|
665 |
gtPortal: begin |
|
666 |
gear^.ImpactSound:= sndMelonImpact; |
|
667 |
gear^.nImpactSounds:= 1; |
|
668 |
gear^.Radius:= 17; |
|
669 |
// set color |
|
670 |
gear^.Tag:= 2 * gear^.Timer; |
|
671 |
gear^.Timer:= 15000; |
|
672 |
gear^.RenderTimer:= false; |
|
673 |
gear^.Health:= 100; |
|
674 |
end; |
|
675 |
gtPiano: begin |
|
676 |
gear^.Radius:= 32; |
|
677 |
gear^.Density:= _50; |
|
678 |
end; |
|
679 |
gtSineGunShot: begin |
|
680 |
gear^.Radius:= 5; |
|
681 |
gear^.Health:= 6000; |
|
682 |
end; |
|
683 |
gtFlamethrower: begin |
|
684 |
gear^.Tag:= 10; |
|
9195
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
685 |
if gear^.Timer = 0 then gear^.Timer:= 10; |
6581 | 686 |
gear^.Health:= 500; |
687 |
gear^.Damage:= 100; |
|
688 |
end; |
|
689 |
gtLandGun: begin |
|
690 |
gear^.Tag:= 10; |
|
9195
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
691 |
if gear^.Timer = 0 then gear^.Timer:= 10; |
6581 | 692 |
gear^.Health:= 1000; |
693 |
gear^.Damage:= 100; |
|
694 |
end; |
|
695 |
gtPoisonCloud: begin |
|
9195
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
696 |
if gear^.Timer = 0 then gear^.Timer:= 5000; |
6581 | 697 |
gear^.dY:= int2hwfloat(-4 + longint(getRandom(8))) / 1000; |
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset
|
698 |
gear^.Tint:= $C0C000C0 |
6581 | 699 |
end; |
700 |
gtResurrector: begin |
|
701 |
gear^.Radius := 100; |
|
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset
|
702 |
gear^.Tag := 0; |
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset
|
703 |
gear^.Tint:= $F5DB35FF |
6581 | 704 |
end; |
705 |
gtWaterUp: begin |
|
706 |
gear^.Tag := 47; |
|
707 |
end; |
|
708 |
gtNapalmBomb: begin |
|
9721
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset
|
709 |
gear^.Elasticity:= _0_8; |
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset
|
710 |
gear^.Friction:= _0_8; |
9195
e653e96b0ec3
Many of the gears treat non-0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset
|
711 |
if gear^.Timer = 0 then gear^.Timer:= 1000; |
6581 | 712 |
gear^.Radius:= 5; |
713 |
gear^.Density:= _1_5; |
|
714 |
end; |
|
8161 | 715 |
{ |
6581 | 716 |
gtStructure: begin |
717 |
gear^.Elasticity:= _0_55; |
|
718 |
gear^.Friction:= _0_995; |
|
719 |
gear^.Density:= _0_9; |
|
720 |
gear^.Radius:= 13; |
|
721 |
gear^.Health:= 200; |
|
722 |
gear^.Timer:= 0; |
|
723 |
gear^.Tag:= TotalRounds + 3; |
|
724 |
gear^.Pos:= 1; |
|
725 |
end; |
|
8161 | 726 |
} |
8774
39754516eee6
Try to document TGear a bit, so people know what is commonly overridden, and what stuff is used for. Remove gtIceGun-specific values from TGear and abuse a couple of commonly abused members instead.
nemo
parents:
8751
diff
changeset
|
727 |
gtIceGun: begin |
39754516eee6
Try to document TGear a bit, so people know what is commonly overridden, and what stuff is used for. Remove gtIceGun-specific values from TGear and abuse a couple of commonly abused members instead.
nemo
parents:
8751
diff
changeset
|
728 |
gear^.Health:= 1000; |
39754516eee6
Try to document TGear a bit, so people know what is commonly overridden, and what stuff is used for. Remove gtIceGun-specific values from TGear and abuse a couple of commonly abused members instead.
nemo
parents:
8751
diff
changeset
|
729 |
gear^.Radius:= 8; |
39754516eee6
Try to document TGear a bit, so people know what is commonly overridden, and what stuff is used for. Remove gtIceGun-specific values from TGear and abuse a couple of commonly abused members instead.
nemo
parents:
8751
diff
changeset
|
730 |
end; |
12197 | 731 |
gtDuck: begin |
12208
668ee6e388bd
Make duck rise to surface when spawning underwater
Wuzzy <almikes@aol.com>
parents:
12207
diff
changeset
|
732 |
gear^.Pos:= 0; // 0: in air, 1-4: on water, 5-8: underwater |
12207
fb2dea5c98f1
Add a few comments for rubber duck
Wuzzy <almikes@aol.com>
parents:
12206
diff
changeset
|
733 |
// 1: bottom, 2: bottom (mirrored), |
fb2dea5c98f1
Add a few comments for rubber duck
Wuzzy <almikes@aol.com>
parents:
12206
diff
changeset
|
734 |
// 3: left Sea edge, 4: right Sea edge |
12208
668ee6e388bd
Make duck rise to surface when spawning underwater
Wuzzy <almikes@aol.com>
parents:
12207
diff
changeset
|
735 |
// 6: bottom, 7: bottom (mirrored) |
668ee6e388bd
Make duck rise to surface when spawning underwater
Wuzzy <almikes@aol.com>
parents:
12207
diff
changeset
|
736 |
// 7: left Sea edge, 8: right Sea edge |
12197 | 737 |
gear^.Tag:= 1; // 1: facing right, -1: facing left |
738 |
if gear^.Timer = 0 then |
|
12207
fb2dea5c98f1
Add a few comments for rubber duck
Wuzzy <almikes@aol.com>
parents:
12206
diff
changeset
|
739 |
gear^.Timer:= 15000; // Explosion timer to avoid duck existing forever |
12197 | 740 |
gear^.Radius:= 9; // Collision radius (with landscape) |
741 |
gear^.Karma:= 24; // Distance from water when swimming |
|
12206
2c0811bbc1d9
Put duck speed factor into gear variable
Wuzzy <almikes@aol.com>
parents:
12204
diff
changeset
|
742 |
gear^.Damage:= 500; // Speed factor when swimming on water (multiplied with wind speed) |
12208
668ee6e388bd
Make duck rise to surface when spawning underwater
Wuzzy <almikes@aol.com>
parents:
12207
diff
changeset
|
743 |
gear^.State:= gear^.State or gstSubmersible; |
12197 | 744 |
gear^.Elasticity:= _0_6; |
12204
f7c295971143
Fix rubber duck not bouncing off diagonal rubber
Wuzzy <almikes@aol.com>
parents:
12201
diff
changeset
|
745 |
gear^.Friction:= _0_8; |
12197 | 746 |
gear^.Density:= _0_5; |
747 |
gear^.AdvBounce:= 1; |
|
748 |
end; |
|
13159
44351ea57b71
Minigun: Move attack timer to Karma to make gear type more Lua-friendly
Wuzzy <Wuzzy2@mail.ru>
parents:
13101
diff
changeset
|
749 |
gtMinigun: begin |
44351ea57b71
Minigun: Move attack timer to Karma to make gear type more Lua-friendly
Wuzzy <Wuzzy2@mail.ru>
parents:
13101
diff
changeset
|
750 |
// Timer. First, it's the timer before shooting. Then it will become the shooting timer and is set to Karma |
44351ea57b71
Minigun: Move attack timer to Karma to make gear type more Lua-friendly
Wuzzy <Wuzzy2@mail.ru>
parents:
13101
diff
changeset
|
751 |
if gear^.Timer = 0 then |
44351ea57b71
Minigun: Move attack timer to Karma to make gear type more Lua-friendly
Wuzzy <Wuzzy2@mail.ru>
parents:
13101
diff
changeset
|
752 |
gear^.Timer:= 601; |
44351ea57b71
Minigun: Move attack timer to Karma to make gear type more Lua-friendly
Wuzzy <Wuzzy2@mail.ru>
parents:
13101
diff
changeset
|
753 |
// minigun shooting time. 1 bullet is fired every 50ms |
44351ea57b71
Minigun: Move attack timer to Karma to make gear type more Lua-friendly
Wuzzy <Wuzzy2@mail.ru>
parents:
13101
diff
changeset
|
754 |
gear^.Karma:= 3451; |
12903 | 755 |
end; |
756 |
gtMinigunBullet: begin |
|
757 |
gear^.Radius:= 1; |
|
758 |
gear^.Health:= 2; |
|
759 |
end; |
|
7389
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7366
diff
changeset
|
760 |
gtGenericFaller:begin |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7366
diff
changeset
|
761 |
gear^.AdvBounce:= 1; |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7366
diff
changeset
|
762 |
gear^.Radius:= 1; |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7366
diff
changeset
|
763 |
gear^.Elasticity:= _0_9; |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7366
diff
changeset
|
764 |
gear^.Friction:= _0_995; |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7366
diff
changeset
|
765 |
gear^.Density:= _1; |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7366
diff
changeset
|
766 |
end; |
6581 | 767 |
end; |
768 |
||
769 |
InsertGearToList(gear); |
|
770 |
AddGear:= gear; |
|
771 |
||
772 |
ScriptCall('onGearAdd', gear^.uid); |
|
773 |
end; |
|
774 |
||
10646
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
775 |
procedure DeleteGear(Gear: PGear); |
6581 | 776 |
var team: PTeam; |
777 |
t,i: Longword; |
|
778 |
k: boolean; |
|
10874
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset
|
779 |
cakeData: PCakeData; |
11043
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
780 |
iterator: PGear; |
6581 | 781 |
begin |
782 |
||
783 |
ScriptCall('onGearDelete', gear^.uid); |
|
784 |
||
785 |
DeleteCI(Gear); |
|
786 |
||
10634
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10625
diff
changeset
|
787 |
FreeAndNilTexture(Gear^.Tex); |
6581 | 788 |
|
11043
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
789 |
// remove potential links to this gear |
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
790 |
// currently relevant to: gears linked by hammer |
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
791 |
if (Gear^.Kind = gtHedgehog) or (Gear^.Kind = gtMine) or (Gear^.Kind = gtExplosives) then |
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
792 |
begin |
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
793 |
// check all gears for stuff to port through |
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
794 |
iterator := nil; |
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
795 |
while true do |
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
796 |
begin |
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
797 |
|
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
798 |
// iterate through GearsList |
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
799 |
if iterator = nil then |
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
800 |
iterator := GearsList |
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
801 |
else |
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
802 |
iterator := iterator^.NextGear; |
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
803 |
|
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
804 |
// end of list? |
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
805 |
if iterator = nil then |
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
806 |
break; |
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
807 |
|
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
808 |
if iterator^.LinkedGear = Gear then |
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
809 |
iterator^.LinkedGear:= nil; |
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
810 |
end; |
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
811 |
|
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
812 |
end; |
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset
|
813 |
|
6581 | 814 |
// make sure that portals have their link removed before deletion |
815 |
if (Gear^.Kind = gtPortal) then |
|
816 |
begin |
|
7272
71df899c4163
Second part of the change. Make collision check use the new mask bit.
nemo
parents:
7176
diff
changeset
|
817 |
if (Gear^.LinkedGear <> nil) then |
71df899c4163
Second part of the change. Make collision check use the new mask bit.
nemo
parents:
7176
diff
changeset
|
818 |
if (Gear^.LinkedGear^.LinkedGear = Gear) then |
71df899c4163
Second part of the change. Make collision check use the new mask bit.
nemo
parents:
7176
diff
changeset
|
819 |
Gear^.LinkedGear^.LinkedGear:= nil; |
6581 | 820 |
end |
10874
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset
|
821 |
else if Gear^.Kind = gtCake then |
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset
|
822 |
begin |
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset
|
823 |
cakeData:= PCakeData(Gear^.Data); |
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset
|
824 |
Dispose(cakeData); |
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset
|
825 |
cakeData:= nil; |
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset
|
826 |
end |
6581 | 827 |
else if Gear^.Kind = gtHedgehog then |
828 |
(* |
|
829 |
This behaviour dates back to revision 4, and I accidentally encountered it with TARDIS. I don't think it must apply to any modern weapon, since if it was actually hit, the best the gear could do would be to destroy itself immediately, and you'd still end up with two graves. I believe it should be removed |
|
830 |
if (CurAmmoGear <> nil) and (CurrentHedgehog^.Gear = Gear) then |
|
831 |
begin |
|
832 |
AttackBar:= 0; |
|
833 |
Gear^.Message:= gmDestroy; |
|
834 |
CurAmmoGear^.Message:= gmDestroy; |
|
835 |
exit |
|
836 |
end |
|
837 |
else*) |
|
838 |
begin |
|
10646
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
839 |
if ((CurrentHedgehog = nil) or (Gear <> CurrentHedgehog^.Gear)) or (CurAmmoGear = nil) or (CurAmmoGear^.Kind <> gtKamikaze) then |
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
840 |
Gear^.Hedgehog^.Team^.Clan^.Flawless:= false; |
10663
9bbb29d2bd68
remove a not that somehow magically appeared in a prior commit.
nemo
parents:
10646
diff
changeset
|
841 |
if CheckCoordInWater(hwRound(Gear^.X), hwRound(Gear^.Y)) then |
6581 | 842 |
begin |
10646
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
843 |
t:= max(Gear^.Damage, Gear^.Health); |
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
844 |
Gear^.Damage:= t; |
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
845 |
if (((not SuddenDeathDmg) and (WaterOpacity < $FF)) or (SuddenDeathDmg and (SDWaterOpacity < $FF))) then |
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
846 |
spawnHealthTagForHH(Gear, t); |
6581 | 847 |
end; |
848 |
||
10646
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
849 |
team:= Gear^.Hedgehog^.Team; |
10636
aba9ae27ead0
meh. will persevere. DeleteGear can't call that much stuff...
nemo
parents:
10634
diff
changeset
|
850 |
if (CurrentHedgehog <> nil) and (CurrentHedgehog^.Gear = Gear) then |
6581 | 851 |
begin |
852 |
AttackBar:= 0; |
|
853 |
FreeActionsList; // to avoid ThinkThread on drawned gear |
|
854 |
if ((Ammoz[CurrentHedgehog^.CurAmmoType].Ammo.Propz and ammoprop_NoRoundEnd) <> 0) |
|
855 |
and (CurrentHedgehog^.MultiShootAttacks > 0) then |
|
856 |
OnUsedAmmo(CurrentHedgehog^); |
|
857 |
end; |
|
858 |
||
859 |
Gear^.Hedgehog^.Gear:= nil; |
|
10646
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
860 |
|
6581 | 861 |
if Gear^.Hedgehog^.King then |
862 |
begin |
|
863 |
// are there any other kings left? Just doing nil check. Presumably a mortally wounded king will get reaped soon enough |
|
864 |
k:= false; |
|
865 |
for i:= 0 to Pred(team^.Clan^.TeamsNumber) do |
|
866 |
if (team^.Clan^.Teams[i]^.Hedgehogs[0].Gear <> nil) then |
|
867 |
k:= true; |
|
868 |
if not k then |
|
869 |
for i:= 0 to Pred(team^.Clan^.TeamsNumber) do |
|
11002
01c8e95d2265
remove teamgone. desyncs now. less interesting without the animation, perhaps something should be flagged to replace it
nemo
parents:
10891
diff
changeset
|
870 |
with team^.Clan^.Teams[i]^ do |
01c8e95d2265
remove teamgone. desyncs now. less interesting without the animation, perhaps something should be flagged to replace it
nemo
parents:
10891
diff
changeset
|
871 |
for t:= 0 to cMaxHHIndex do |
01c8e95d2265
remove teamgone. desyncs now. less interesting without the animation, perhaps something should be flagged to replace it
nemo
parents:
10891
diff
changeset
|
872 |
if Hedgehogs[t].Gear <> nil then |
01c8e95d2265
remove teamgone. desyncs now. less interesting without the animation, perhaps something should be flagged to replace it
nemo
parents:
10891
diff
changeset
|
873 |
Hedgehogs[t].Gear^.Health:= 0 |
01c8e95d2265
remove teamgone. desyncs now. less interesting without the animation, perhaps something should be flagged to replace it
nemo
parents:
10891
diff
changeset
|
874 |
else if (Hedgehogs[t].GearHidden <> nil) then |
01c8e95d2265
remove teamgone. desyncs now. less interesting without the animation, perhaps something should be flagged to replace it
nemo
parents:
10891
diff
changeset
|
875 |
Hedgehogs[t].GearHidden^.Health:= 0 // hog is still hidden. if tardis should return though, lua, eh... |
6581 | 876 |
end; |
10646
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
877 |
|
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
878 |
// should be not CurrentHedgehog, but hedgehog of the last gear which caused damage to this hog |
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
879 |
// same stand for CheckHHDamage |
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
880 |
if (Gear^.LastDamage <> nil) and (CurrentHedgehog <> nil) then |
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
881 |
uStats.HedgehogDamaged(Gear, Gear^.LastDamage, 0, true) |
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
882 |
else if CurrentHedgehog <> nil then |
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
883 |
uStats.HedgehogDamaged(Gear, CurrentHedgehog, 0, true); |
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
884 |
|
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
885 |
inc(KilledHHs); |
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
886 |
RecountTeamHealth(team); |
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
887 |
if (CurrentHedgehog <> nil) and (CurrentHedgehog^.Effects[heResurrectable] <> 0) and |
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
888 |
//(Gear^.Hedgehog^.Effects[heResurrectable] = 0) then |
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
889 |
(Gear^.Hedgehog^.Team^.Clan <> CurrentHedgehog^.Team^.Clan) then |
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
890 |
with CurrentHedgehog^ do |
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
891 |
begin |
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
892 |
inc(Team^.stats.AIKills); |
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
893 |
FreeAndNilTexture(Team^.AIKillsTex); |
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
894 |
Team^.AIKillsTex := RenderStringTex(ansistring(inttostr(Team^.stats.AIKills)), Team^.Clan^.Color, fnt16); |
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset
|
895 |
end |
6581 | 896 |
end; |
897 |
with Gear^ do |
|
7389
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7366
diff
changeset
|
898 |
begin |
6581 | 899 |
AddFileLog('Delete: #' + inttostr(uid) + ' (' + inttostr(hwRound(x)) + ',' + inttostr(hwRound(y)) + '), d(' + floattostr(dX) + ',' + floattostr(dY) + ') type = ' + EnumToStr(Kind)); |
7389
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7366
diff
changeset
|
900 |
AddRandomness(X.round xor X.frac xor dX.round xor dX.frac xor Y.round xor Y.frac xor dY.round xor dY.frac) |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7366
diff
changeset
|
901 |
end; |
6581 | 902 |
if CurAmmoGear = Gear then |
903 |
CurAmmoGear:= nil; |
|
904 |
if FollowGear = Gear then |
|
905 |
FollowGear:= nil; |
|
906 |
if lastGearByUID = Gear then |
|
907 |
lastGearByUID := nil; |
|
10638 | 908 |
if (Gear^.Hedgehog = nil) or (Gear^.Hedgehog^.GearHidden <> Gear) then // hidden hedgehogs shouldn't be in the list |
10639 | 909 |
RemoveGearFromList(Gear) |
910 |
else Gear^.Hedgehog^.GearHidden:= nil; |
|
10638 | 911 |
|
6581 | 912 |
Dispose(Gear) |
913 |
end; |
|
914 |
||
915 |
end. |