-
Notifications
You must be signed in to change notification settings - Fork 16
/
action.pp
1571 lines (1346 loc) · 57 KB
/
action.pp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
unit action;
{ This is the *ACTION* unit! It handles two kinds of action- }
{ gears moving across the gameboard, and gears taking damage + }
{ potentially blowing up. This might seem like two strange things }
{ to combine in a single unit, but believe me it makes sense. }
{
GearHead2, a roguelike mecha CRPG
Copyright (C) 2005 Joseph Hewitt
This library is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or (at
your option) any later version.
The full text of the LGPL can be found in license.txt.
This library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this library; if not, write to the Free Software Foundation,
Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
}
{$LONGSTRINGS ON}
interface
uses gears,locale;
Type
DamageRec = Record
EjectRoll,EjectOK,PilotDied,MechaDestroyed: Boolean;
DamageDone: LongInt;
end;
const
TRIGGER_NumberOfUnits = 'NU';
TRIGGER_UnitEliminated = 'TD';
TRIGGER_NPCEliminated = 'FAINT';
TRIGGER_NPCSurrendered = 'SURRENDER';
TRIGGER_TeamMovement = 'TMOVE';
TRIGGER_NPCMovement = 'MOVE';
TRIGGER_PCAttack = 'PCATTACK';
{ *** ENACT MOVEMENT RESULTS *** }
EMR_Blocked = -2; { May indicate a charge... }
EMR_Crash = 2; { If either of these are returned from movement, }
{ you should do a check to resolve crashes and charges. }
SA_Explosion = 'EXPLOSION';
var
Destroyed_Parts_List: SAttPtr;
Function Confused( Mek: GearPtr ): Boolean;
Procedure GiveSkillRollXPAward( Pilot: GearPtr; Skill,SkRoll,SkTar: Integer );
Function SkillRoll( GB: GameBoardPtr; PC: GearPtr; Skill,Stat,SkTar,SkMod: Integer; CasualUse,GainXP: Boolean ): Integer;
Function CheckLOS( GB: GameBoardPtr; Observer,Target: GearPtr ): Boolean;
Procedure VisionCheck( GB: GameBoardPtr; Mek: GearPtr );
Function DamageGear( gb: GameBoardPtr; O_Part,O_Weapon: GearPtr; O_DMG,O_MOS,O_NumHits: Integer; const AtAt: String ): DamageRec;
Function DamageGear( gb: GameBoardPtr; Part: GearPtr; DMG: Integer): DamageRec;
procedure Crash( gb: GameBoardPtr; Mek: GearPtr );
Procedure PrepAction( GB: GameBoardPtr; Mek: GearPtr; Action: Integer );
Procedure SetMoveMode( GB: GameBoardPtr; Mek: GearPtr; MM: Integer );
Function EnactMovement( GB: GameBoardPtr; Mek: GearPtr ): Integer;
Procedure DoDrift( GB: GameBoardPtr; Mek: GearPtr );
Procedure WaitAMinute( GB: GameBoardPtr; Mek: GearPtr; D: Integer );
implementation
uses ability,gearutil,ghchars,ghmodule,ghweapon,movement,rpgdice,texutil,
math,ui4gh,ghintrinsic,ghsensor,ghprop,ghsupport,
{$IFDEF ASCII}
vidgfx;
{$ELSE}
sdlgfx;
{$ENDIF}
const
EjectDamage = 10; { The damage step to roll during an ejection attempt. }
MissileConcussion = 3;
MeleeConcussion = 3;
ModuleConcussion = 7;
DamagePilotChance = 75; { % chance to damage pilot by concussion. }
DamageInventoryChance = 25; { % chance to damage inventory gears by concussion. }
Stealth_Per_Scale = 4; { If scale different from map, get stealth bonus/penalty }
Function Confused( Mek: GearPtr ): Boolean;
{ Return true if either the pilot or the mecha is either }
{ HAYWIRE or STONED. }
var
Pilot: GearPtr;
begin
if Mek^.G = GG_Mecha then begin
Pilot := LocatePilot( Mek );
end else begin
Pilot := Nil;
end;
Confused := HasStatus( Mek , NAS_Haywire ) or HasStatus( Mek , NAS_Stoned ) or HasStatus( Pilot , NAS_Haywire ) or HasStatus( Pilot , NAS_Stoned );
end;
Procedure GiveSkillRollXPAward( Pilot: GearPtr; Skill,SkRoll,SkTar: Integer );
{ Give a skill XP award. The size of the award is going to depend on the }
{ relation betwee SkRoll and SkTar. }
const
{ Basic_Skill_Award_Multiplier: Array [1..NumSkill] of Byte = (
1,1,1,1,1, 2,2,2,2,2,
1,1,1,5,1, 1,1,1,5,1,
1,1,1,1,1, 1,5,3,3,1,
1,3,1,3,1, 2,3,1,1,10,
7,1,1
);}
MaxTarLevel = 12;
Skill_Award_By_Level: Array [1..12] of Integer = (
1,2,3,4,5,
8,13,21,34,55,
89,144
);
var
TarLevel: Integer; { Just how tough was this target? }
SkRank: Integer; { Skill rank. }
begin
Pilot := LocatePilot( Pilot );
if ( Pilot <> Nil ) and ( Skill >= 1 ) and ( Skill <= NumSkill ) and ( SkRoll >= SkTar ) then begin
{ Determine the TarLevel. This will tell how much XP to give. }
TarLevel := ( SkTar + 2 ) div 3;
if TarLevel < 1 then TarLevel := 1
else if TarLevel > MaxTarLevel then TarLevel := MaxTarLevel;
{ Determine the Pilot's skill rank. This will be needed later. }
SkRank := NAttValue( Pilot^.NA , NAG_Skill , Skill );
{ The expereince award can't exceed one level beyond the skill rank. }
if TarLevel > ( SkRank + 1 ) then TarLevel := SkRank + 1;
if ( SkTar > SkRank ) and ( SkRank > 0 ) then begin
DoleSkillExperience( Pilot , Skill , Skill_Award_By_Level[ TarLevel ] * 2 );
DoleExperience( Pilot , Skill_Award_By_Level[ TarLevel ] );
end else if ( SkTar > ( SkRank div 2 ) ) then begin
DoleSkillExperience( Pilot , Skill , Skill_Award_By_Level[ TarLevel ] );
if SkRank > 0 then DoleExperience( Pilot , 1 );
end;
end;
end;
Function SkillRoll( GB: GameBoardPtr; PC: GearPtr; Skill,Stat,SkTar,SkMod: Integer; CasualUse,GainXP: Boolean ): Integer;
{ Attempt to make a skill roll. }
{ Skill = The skill to use. }
{ SkTar = The target number to try and beat. }
{ SkMod = The modifier to the skill roll. }
{ CasualUse = TRUE if the PC can use things in his backpack and use the team's }
{ help, or FALSE otherwise. }
var
msg: String;
SkRank,SkRoll: Integer;
Pilot: GearPtr;
begin
{ Determine the base skill value, and initialize the message. }
msg := PilotName( PC ) + ' rolls ' + MSgString( 'SKILLNAME_' + BStr( Skill ) ) + '+' + MSgString( 'STATNAME_' + BStr( Stat ) ) + ' ';
if CasualUse and ( GB <> Nil ) then begin
SkRank := TeamSkill( GB , NAV_DefPlayerTeam , Skill , Stat );
end else begin
SkRank := SkillValue( PC , Skill , Stat );
end;
msg := msg + '[' + BStr( SkRank );
if SkMod <> 0 then msg := msg + SgnStr( SkMod );
msg := msg + ']';
if SkTar > 0 then begin
msg := msg + ' vs ' + BStr( SkTar ) + ':';
end else begin
msg := msg + ':';
SkTar := SkRank div 2;
end;
{ Adjust the skill value by the modifier. }
SkRank := SkRank + SkMod;
if SkRank < 1 then SkRank := 1;
{ Make the die roll. }
SkRoll := RollStep( SkRank );
msg := msg + BStr( SkRoll );
{ Store the message. }
{ NOTE: Awareness only gets stored if it's successful. }
{ Otherwise the player could check the skill roll history and easily see }
{ that there's something hidden nearby. }
if ( Skill <> NAS_Awareness ) or ( SkRoll > SkTar ) then begin
SkillComment( Msg );
end;
{ If the roll was a success, give some skill XP. }
Pilot := LocatePilot( PC );
if GainXP and ( Pilot <> Nil ) then begin
GiveSkillRollXPAward( Pilot , Skill , SkRoll , SkTar );
end;
{ Return the result. }
SkillRoll := SkRoll;
end;
Function CheckLOS( GB: GameBoardPtr; Observer,Target: GearPtr ): Boolean;
{ Do the line-of-sight roll to see if Observer notices Target. }
Function TargetStealth: Integer;
{ Return the modified stealth rating of this target. }
var
T: Integer;
begin
T := MechaStealthRating( Target );
if Target^.Scale > GB^.Scale then begin
T := T - ( Target^.Scale - GB^.Scale ) * Stealth_Per_Scale;
end else if Target^.Scale < GB^.Scale then begin
T := T + ( GB^.Scale - Target^.Scale ) * Stealth_Per_Scale;
end;
if ( Target^.G = GG_MetaTerrain ) and ( Target^.S = GS_MetaEncounter ) then begin
T := T + Range( GB , Observer , Target );
if T < 5 then T := 5;
end;
TargetStealth := T;
end;
Function CasualUseAwareness: Boolean;
{ Can use the team skill level if the map scale is bigger than 2. }
begin
CasualUseAwareness := ( GB^.Scale > 2 );
end;
var
O,T,Roll: Integer;
P1,P2: Point;
it: Boolean;
begin
{ Calculate the obscurement. }
O := CalcObscurement( Observer , Target , gb );
{ Encounters can only be spotted within a limited range, }
{ based on the observer's awareness skill. }
if ( Target^.G = GG_MetaTerrain ) and ( Target^.S = GS_MetaEncounter ) then begin
if Range( GB , Observer , Target ) > ( ( SkillValue( Observer , NAS_Awareness , STAT_Perception ) + 2 ) div 2 ) then O := -1;
end;
{ If there's nothing standing between the target and the spotter, }
{ visibility is mostly guaranteed. }
if ( O = 0 ) and ( Target^.G <> GG_MetaTerrain ) then begin
{ If the target has stealth and is outside of the spotter's front arc, }
{ then it gets a STEALTH roll. }
if ( NAttValue( Target^.NA , NAG_Action , NAS_MoveAction ) <> NAV_FullSpeed ) and HasSkill( Target , NAS_Stealth ) then begin
{ Get the position of the spotter and the target. }
P1 := GearCurrentLocation( Observer );
P2 := GearCurrentLocation( Target );
if not ArcCheck( P1.X , P1.Y , NAttValue( Observer^.NA , NAG_Location , NAS_D ) , P2.X , P2.Y , ARC_F180 ) then begin
{ Make the awareness roll. }
T := TargetStealth;
Roll := SkillRoll( GB , Observer , NAS_Awareness , STAT_Perception , T , 0 , CasualUseAwareness , AreEnemies( GB , Observer , Target ) );
if SkillRoll( GB , Target , NAS_Stealth , STAT_Speed , Roll , -5 , False , AreEnemies( GB , Observer , Target ) ) > Roll then begin
it := False;
end else begin
it := True;
end;
end else begin
{ Within the front arc and with no cover, Stealth is of no help. }
it := True;
end;
end else begin
it := True;
end;
end else if O = -1 then begin
it := False;
end else begin
{ Make the awareness roll. }
T := O + TargetStealth;
Roll := SkillRoll( GB , Observer , NAS_Awareness , STAT_Perception , T , 0 , CasualUseAwareness , AreEnemies( GB , Observer , Target ) );
if Roll > T then begin
{ The target might get a STEALTH save now. }
if ( NAttValue( Target^.NA , NAG_Action , NAS_MoveAction ) <> NAV_FullSpeed ) and HasSkill( Target , NAS_Stealth ) then begin
if SkillRoll( GB , Target , NAS_Stealth , STAT_Speed , Roll , 5 , False , AreEnemies( GB , Observer , Target ) ) > Roll then begin
it := False;
end else begin
it := True;
end;
end else begin
it := True;
end;
end else it := False;
end;
{ If the spotter is BLINDED, there's a 2/3 chance that the LOS check will fail. }
if HasStatus( Observer , NAS_Blinded ) and ( Random( 3 ) <> 1 ) then it := False;
CheckLOS := it;
end;
Procedure VisionCheck( GB: GameBoardPtr; Mek: GearPtr );
{ Perform a sensor check for MEK. It might spot hidden enemy }
{ units; it may get spotted by enemy units itself. }
var
M2: GearPtr;
Team: Integer;
begin
if ( Mek = Nil ) or ( not GearOperational( Mek ) ) or ( not OnTheMap( GB , Mek ) ) then exit;
Team := NAttValue( Mek^.NA , NAG_Location , NAS_Team );
{ Start by assuming that the mek will be hidden after this. }
{ Strip all of its visibility tokens. }
StripNAtt( Mek , NAG_Visibility );
M2 := GB^.Meks;
while M2 <> Nil do begin
{ We are only interested in this other mek if it's an }
{ enemy of the one we're checking. }
if OnTheMap( GB , M2 ) then begin
if IsMasterGear( Mek ) and not MekCanSeeTarget( gb , Mek , M2 ) then begin
{ If this enemy mecha has not yet been spotted, }
{ there's a chance it will become visible. }
if IsMasterGear( M2 ) and CheckLOS( GB , Mek , M2 ) then begin
{ M2 has just been spotted. }
RevealMek( GB , M2 , Mek );
end else if ( Team = NAV_DefPlayerTeam ) and ( M2^.G = GG_MetaTerrain ) and ( M2^.S = GS_MetaEncounter ) and ( M2^.Stat[ STAT_MetaVisibility ] >= 0 ) then begin
if CheckLOS( GB , Mek , M2 ) then begin
RevealMek( GB , M2 , Mek );
end;
end;
end;
{ There is also a chance that M2 might spot Mek. }
if IsMasterGear( M2 ) and GearOperational( M2 ) and not MekCanSeeTarget( GB , M2 , Mek ) then begin
if CheckLOS( GB , M2 , Mek ) then RevealMek( GB , Mek , M2 );
end;
end;
M2 := M2^.Next;
end;
if ( Team = NAV_DefPlayerTeam ) or ( Team = NAV_LancemateTeam ) then begin
CheckVisibleArea( GB , Mek );
end;
Screen_Needs_Redraw := True;
end;
Function DamageGear( gb: GameBoardPtr; O_Part,O_Weapon: GearPtr; O_DMG,O_MOS,O_NumHits: Integer; const AtAt: String ): DamageRec;
{ Damage the provided gear. }
var
DR: DamageRec;
DAMAGE_OverKill,DAMAGE_Iterations: LongInt;
{ Procedures block. }
Function TakeDamage( Part: GearPtr; DMG: LongInt ): Boolean;
{ Store the listed amount of damage in PART. Return TRUE if part }
{ was operational at the start & is still operational, FALSE otherwise. }
{ The main reason for having this procedure is to record triggers }
{ when something is destroyed. }
var
Ok_At_Start: Boolean;
GoUp: GearPtr; { A counter that will be used to check all of PART's parents. }
Team: Integer;
begin
Ok_At_Start := GearOperational( Part );
AddNAtt(Part^.NA,NAG_Damage,NAS_StrucDamage,DMG);
{ If PART was destroyed by this damage, there may be triggers that }
{ need generating. Get to work. }
if Ok_At_Start and ( not GearOperational( Part ) ) then begin
{ PART and all of its parents up to root need to be }
{ checked for triggers. }
GoUp := Part;
while GoUp <> Nil do begin
{ If GoUp is destroyed, and it has a UID, generate }
{ a TD* trigger. }
if ( NAttValue( GoUp^.NA , NAG_EpisodeData , NAS_UID ) <> 0 ) and ( Not GearOperational( GoUp ) ) then begin
SetTrigger( GB , TRIGGER_UnitEliminated + BStr( NAttValue( GoUp^.NA , NAG_EpisodeData , NAS_UID ) ) );
end;
{ If GoUp is destroyed and it had a CID, generate }
{ a UTD* trigger. }
if ( NAttValue( GoUp^.NA , NAG_Personal , NAS_CID ) <> 0 ) and ( Not GearOperational( GoUp ) ) then begin
SetTrigger( GB , TRIGGER_NPCEliminated + BStr( NAttValue( GoUp^.NA , NAG_Personal , NAS_CID ) ) );
end;
{ If this is a root level gear, generate a NU* trigger. }
if ( GoUp^.Parent = Nil ) and IsMasterGear( GoUp ) then begin
Team := NAttValue( GoUp^.NA , NAG_Location , NAS_Team );
SetTrigger( GB , TRIGGER_NumberOfUnits + BStr( Team ) );
end;
{ Move up one more level. }
GoUp := GoUp^.Parent;
end;
{ Add this gear to the list of destroyed parts. }
{ Only do this for non-master gears which aren't at }
{ root level. }
if ( Part^.Parent <> Nil ) and not IsMasterGear( Part ) then StoreSAtt( Destroyed_Parts_List , GearName( Part ) );
end else if OK_At_Start and ( Part^.G = GG_Character ) then begin
{ Taking damage causes the afflicted to feel worse for wear. }
AddMoraleDmg( Part , DMG );
end;
TakeDamage := Ok_At_Start and NotDestroyed( Part );
end;
Procedure EjectionCheck( Part: GearPtr );
{ The parent has just been destroyed. Check to see whether or not }
{ there is a pilot inside of it, then roll to escape or be blasted }
{ to bits. }
{ ASSERT: PART is a subcomponent of its parent. }
var
P2: GearPtr;
Master: GearPtr;
ERoll,EMod,Team: Integer;
SafeEject: Boolean;
begin
{ To start with, find the team for this unit, since we might not be }
{ able to after the pilot ejects. }
if Part <> Nil then Team := NAttValue( FindRoot( Part )^.NA , NAG_Location , NAS_Team );
{ Determine if this is an honorable duel- if so, the chance of being killed }
{ is greatly reduced. }
SafeEject := ( GB^.Scene <> Nil ) and AStringHasBString( SAttValue( GB^.Scene^.SA , 'SPECIAL' ) , 'ARENA' );
while ( Part <> Nil ) do begin
P2 := Part^.Next;
if NotDestroyed( Part ) then begin
if Part^.G = GG_Character then begin
{ This character must either eject or die. }
{ Actually, eject, suffer damage, or die. }
DR.EjectRoll := True;
EMod := 5;
{ First, determine what sort of module the pilot }
{ is in. HEAD = +3 bonus to eject. }
Master := Part^.Parent;
while ( Master <> Nil ) and ( Master^.G <> GG_Module ) do begin
Master := Master^.Parent;
end;
if Master <> Nil then begin
{ We've found the module the cockpit is in. }
if Master^.S = GS_Head then EMod := EMod - 3;
end else begin
{ We can't find a module, all the way back to root. }
{ Try to handle things gracefully... }
Master := Part^.Parent;
end;
{ Find the root-level master of this part. }
while Master^.Parent <> Nil do begin
Master := Master^.Parent;
end;
{ Do the Skill Roll - SPEED + DODGE SKILL }
ERoll := SkillRoll( GB , Part , NAS_Dodge , STAT_Speed , EMod , 0 , False, True );
if SafeEject then begin
ERoll := ERoll + 20;
end;
if ERoll < ( EMod * 2 ) then begin
{ The character will eject, but takes some damage. }
TakeDamage( Part , RollDamage( EjectDamage , Part^.Scale ) );
end;
if ( ERoll > EMod ) and not PartHasIntrinsic( Part , NAS_Integral ) then begin
{ Delink the chaacter, then attach as a sibling of the master gear. }
DelinkGear( Part^.Parent^.SubCom , Part );
SetNAtt( Part^.NA , NAG_Location , NAS_X , 0 );
SetNAtt( Part^.NA , NAG_Location , NAS_Y , 0 );
Part^.Next := Master^.Next;
Master^.Next := Part;
DR.EjectOK := True;
end else begin
{ The character has not managed to eject successfully. }
{ He's toast. }
TakeDamage( Part , GearMaxDamage( Part ) );
end;
if Destroyed( Part ) then begin
DR.PilotDied := True;
end;
{ If an ejection has occurred, or the pilot has died trying, }
{ better set a NUMBER OF UNITS trigger. }
SetTrigger( GB , TRIGGER_NumberOfUnits + BStr( Team ) );
end else begin
{ Check the sub components for characters. }
EjectionCheck( Part^.SubCom );
end;
end;
Part := P2;
end;
end;
Procedure AmmoExplosion( Part: GearPtr );
{ How should an ammo explosion work? Well, roll damage for the }
{ ammo and add it to the OVERKILL history variable. }
var
PercentFull: Integer;
M: GearPtr;
begin
{ Only installed ammo can explode. This may seem silly, and it }
{ probably is, but otherwise carrying replacement clips is }
{ asking for certain death. }
if IsExternalPart( FindRoot( Part ) , Part ) then exit;
{ First calculate the number of shots in the magazine. }
{ If it is empty, no ammo explosion will take place. }
if Part^.Stat[ STAT_AmmoPresent ] > 0 then PercentFull := ( ( Part^.Stat[ STAT_AmmoPresent ] - NAttValue( Part^.NA , NAG_WeaponModifier , NAS_AmmoSpent ) ) * 100 ) div Part^.Stat[ STAT_AmmoPresent ]
else PercentFull := 100;
if PercentFull > 0 then begin
M := FindModule( Part );
if ( M = Nil ) or ( M^.S <> GS_Storage ) then begin
DAMAGE_OverKill := DAMAGE_OverKill + RollDamage( Part^.V * PercentFull div 50 , Part^.Scale );
end;
end;
end;
Procedure CriticalEngineFailure( Part: GearPtr );
{ So sad; this mecha is set to go boom. }
begin
Part := FindRoot( Part );
if ( Part <> Nil ) and ( Part^.G = GG_Mecha ) then SetNAtt( Part^.NA , NAG_Action , NAS_WillExplode , 1 );
end;
Procedure ApplyDamage( Part: GearPtr; DMG: LongInt);
{ Add to the damage total of this part, }
{ then check for special effects such as eject rolls, ammo }
{ explosions, and whatever else has been implemented. }
var
OK_at_Start: Boolean; { Was the part OK before damage was applied? }
M: GearPtr;
begin
{ERROR CHECK - If we are attempting to damage a storage}
{module or other -1HP type, don't do anything.}
if GearMaxDamage(Part) > 0 then begin
OK_At_Start := NotDestroyed( Part );
{ Calculate overkill. }
if GearCurrentDamage( Part ) < DMG then begin
{ Damage dealt to storage modules doesn't carry through to }
{ overkill. The module can be blown off without affecting }
{ the structural integrity of the whole. }
M := FindModule( Part );
if ( M = Nil ) or ( M^.S <> GS_Storage ) then begin
DAMAGE_OverKill := DAMAGE_OverKill + DMG - GearCurrentDamage( Part );
end;
DMG := GearCurrentDamage( Part );
end;
TakeDamage( Part , DMG );
if OK_At_Start and Destroyed( Part ) then begin
{ The part started out OK, but it's been }
{ destroyed. Check for special effects. }
if (Part^.G = GG_Module ) or ( Part^.G = GG_Cockpit ) then begin
EjectionCheck( Part^.SubCom );
end else if Part^.G = GG_Ammo then begin
AmmoExplosion( Part );
end else if ( Part^.G = GG_Support ) and ( Part^.S = GS_Engine ) then begin
{ If the engine is destroyed, there's a chance for a catastrophic failure. }
if Part^.Stat[ STAT_EngineSubType ] = EST_HighPerformance then begin
CriticalEngineFailure( Part );
end else if Part^.Stat[ STAT_EngineSubType ] <> 0 then begin
if Random( 4 ) = 1 then CriticalEngineFailure( Part );
end else if Random( 100 ) = 1 then begin
CriticalEngineFailure( Part );
end;
end;
end;
end;
end;
Function IsBeamAttack: Boolean;
{ Return TRUE if this is a beam attack. How to tell? }
{ If it's a beamgun, an emelee, or HYPER. }
begin
if HasAttackAttribute( AtAt , AA_Hyper ) then begin
IsBeamAttack := TRUE;
end else if ( O_Weapon <> Nil ) and ( O_Weapon^.G = GG_Weapon ) then begin
IsBeamAttack := ( O_Weapon^.S = GS_BeamGun ) or ( O_Weapon^.S = GS_EMelee );
end else IsBeamAttack := False;
end;
Procedure StagedPenetration( Part: GearPtr; var DMG: Longint; var MOS , Scale: Integer );
{This procedure applies armor damage to Part.}
{ Variables DMG and MOS will be affected by this procedure. }
var
XA,PMaster: GearPtr;
MAP: Integer; {The maximum number of armor points to lose.}
AAP: Integer; {The actual number that will be lost.}
AType: Integer; { What kind of armor does this part have? }
Armor: LongInt; { Initial armor value of the part. }
IsHardened: Boolean;
begin
{ First, check InvComponents for external armor. }
if ( Part <> Nil ) and ( not IsMasterGear( Part ) ) then begin
XA := Part^.InvCom;
while ( XA <> Nil ) do begin
if XA^.G = GG_ExArmor then StagedPenetration( XA , Dmg , MOS , Scale );
XA := XA^.Next;
end;
end;
{ Damage can be affected by the armor type. }
AType := NAttValue( Part^.NA , NAG_GearOps , NAS_ArmorType );
if AType = NAV_Hardened then begin
{ Hardened armor is hardened. That is all. }
IsHardened := True;
end else if ( AType = NAV_AntiBeam ) and IsBeamAttack then begin
{ Anti-Beam Armor reduces beam damage by half, and counts as }
{ hardened against it. }
Dmg := Dmg div 2;
IsHardened := True;
end else begin
IsHardened := False;
end;
{ Locate the master of this part, which we'll need in order }
{ to check status conditions. }
PMaster := FindMaster( Part );
{ Only do armor damage to parts which have armor. }
if ( GearMaxArmor( Part ) > 0 ) then begin
Armor := GearCurrentArmor( Part );
{ Reduce armor protection if the target is rusty. }
if HasStatus( PMaster , NAS_Rust ) then ARMOR := ARMOR div 2;
{ Next, apply damage to the armor itself. }
{ Calculate the maximum armor damage possible. }
{ This is determined by the scale of the attack. }
MAP := 2;
if Scale > 0 then for AAP := 1 to Scale do MAP := MAP * 5;
{ If the part is MetaTerrain, the maximum armor }
{ penetration may well be reduced. If an attack can't }
{ get through the armor, it can't do any damage at all. }
{ This is to prevent the PC from knocking down doors with }
{ a lot of low-power attacks. }
if ( Part^.G = GG_MetaTerrain ) and ( DMG < Armor ) then begin
MAP := 0;
end;
{ Decide upon actual armor damage. }
{ This will be MUCH greater if the target is rusty. }
if HasStatus( PMaster , NAS_Rust ) then begin
AAP := DMG div 2;
end else begin
AAP := Random( DMG div 2 + 1 );
if AAP > MAP then AAP := MAP;
end;
{ BRUTAL attacks double their armor penetration. }
if HasAttackAttribute( AtAt , AA_Brutal ) then begin
AAP := AAP * 2;
if AAP < 3 then AAP := 3;
end;
{ HARDENED armor takes only half damage. }
if IsHardened then begin
AAP := AAP div 2;
end;
{ Record the current armor value, then record the armor damage. }
if AAP > GearCurrentArmor( Part ) then AAP := GearCurrentArmor( Part );
{ Nonlethal attacks don't affect armor. }
if not HasAttackAttribute( AtAt , AA_NonLethal ) then AddNAtt(Part^.NA,NAG_Damage,NAS_ArmorDamage,AAP);
end else begin
{ It's possible that this part has no armor at all. }
{ Cover that possibility here. }
Armor := 0;
end;
{ Adjust armor for MOS, then reduce MOS. }
if ( MOS > 0 ) and ( Armor > 0 ) then begin
if MOS < 4 then Armor := ( Armor * ( 4 - MOS ) ) div 4
else Armor := 0;
{ MOS := MOS - 4;}
MOS := MOS - 2;
end;
{ Reduce the DMG variable by the current armor level. }
DMG := DMG - Armor;
if DMG < 0 then DMG := 0;
end;
Function SelectRandomModule( LList: GearPtr ): GearPtr;
{ Select a module from LList at random. If no module is found, }
{ return NIL. }
var
M: GearPtr;
N: Integer;
begin
{ First, count the number of modules present. }
N := 0;
M := LList;
while M <> Nil do begin
if M^.G = GG_Module then Inc( N );
M := M^.Next;
end;
{ Next, select one of the modules randomly. }
if N > 0 then begin
N := Random( N );
M := LList;
while ( M <> Nil ) and ( N > -1 ) do begin
if M^.G = GG_Module then Dec( N );
if N <> -1 then M := M^.Next;
end;
end;
SelectRandomModule := M;
end;
Function REALDamageGear( Part: GearPtr; DMG: LongInt; MOS,Scale: Integer ): LongInt;
{This is where the REAL damage process starts.}
var
XA: GearPtr;
N: Integer;
begin
{ Increment the ITERATIONS value. }
Inc( DAMAGE_Iterations );
{ Do all damage thingies, unless we want to ignore damage. }
if Not HasAttackAttribute( AtAt, AA_ArmorIgnore ) then begin
{ If this is the first iteration, reduce the amount of damage done }
{ by all armor values up to root level. This is so aimed shots at }
{ sensors/etc won't ignore the armor of the module they're located in. }
{ Note that only sub components get upwards armor protection- }
{ externally mounted inv components don't. }
if ( DAMAGE_Iterations = 1 ) and IsSubCom( Part ) then begin
XA := Part^.Parent;
while XA <> Nil do begin
StagedPenetration( XA , DMG , MOS , Scale );
XA := XA^.Parent;
end;
end;
{ If this is a character, apply staged penetration randomly }
{ to the armor of one limb. }
if ( Part^.G = GG_Character ) then begin
XA := SelectRandomModule( Part^.SubCom );
if XA <> Nil then StagedPenetration( XA , dmg , MOS , Scale );
end;
{Reduce the amount of damage by the armor rating of}
{this gear, and do damage to the armor.}
StagedPenetration( Part , dmg , MOS , Scale );
end;
if DMG > 0 then begin
{If the damage made it through the armor, apply it to}
{whatever's on the inside.}
{ Increase damage by excess margin of success. }
if ( MOS > 0 ) and ( GearMaxDamage(Part) <> -1 ) then begin
{ Each extra point of MOS will increase damage }
{ by 20%. }
DMG := ( DMG * ( 5 + MOS ) ) div 5;
MOS := 0;
end;
{Depending upon what the part we are damaging is, we}
{might apply damage here or pass it on to a subcomponent.}
N := NumActiveGears(Part^.SubCom);
if N > 0 then begin
{There are subcomponents. Either damage this}
{part directly, or pass damage on to a subcom.}
if (GearMaxDamage(Part) = -1) or ( Random(100) = 23 ) then begin
{Damage a subcomponent. Time for recursion.}
DMG := REALDamageGear( FindActiveGear(Part^.SubCom,Random(N)+1), DMG , MOS , Scale );
end else if (Random(3) = 1) then begin
{ Apply half the damage to this component, }
{ and half the damage to its children. }
ApplyDamage( Part,DMG div 2);
{ Recalculate the number of active subcomponents, as it may have changed. }
N := NumActiveGears(Part^.SubCom);
if N > 0 then begin
DMG := ( DMG div 2 ) + REALDamageGear( FindActiveGear(Part^.SubCom,Random(N)+1), (DMG+1) div 2 , MOS , Scale );
end else begin
{ Apply all damage against this part. }
ApplyDamage( Part , ( DMG + 1 ) div 2 );
end;
end else begin
ApplyDamage( Part , DMG );
end;
end else begin
{There are no subcomponents. Damage this}
{module directly.}
ApplyDamage( Part , DMG );
end;
end else if DMG < 0 then begin
{ We don't want this procedure reporting Damage less than }
{ zero, because that's silly. }
DMG := 0;
end;
REALDamageGear := DMG;
end;
Function NonlethalDamageGear( Part: GearPtr; DMG: LongInt; MOS,Scale: Integer ): LongInt;
{This is where the REAL damage process starts, for nonlethal damage.}
var
XA: GearPtr;
begin
{ Reduce the damage based on the target's armor value. }
StagedPenetration( Part , DMG , MOS , Scale );
{ We know this is a character, so reduce by the armor value of one randomly }
{ selected limb. }
if ( Part^.G = GG_Character ) then begin
XA := SelectRandomGear( Part^.SubCom );
if XA <> Nil then StagedPenetration( XA , dmg , MOS , Scale );
end;
if DMG > 0 then begin
{If the damage made it through the armor, apply it to}
{whatever's on the inside.}
{ Increase damage by excess margin of success. }
if ( MOS > 0 ) then begin
{ Each extra point of MOS will increase damage }
{ by 25%. }
DMG := ( DMG * ( 4 + MOS ) ) div 4;
MOS := 0;
end;
AddStaminaDown( Part , DMG );
end else if DMG < 0 then begin
{ We don't want this procedure reporting Damage less than }
{ zero, because that's silly. }
DMG := 0;
end;
NonlethalDamageGear := DMG;
end;
Function ConcussionDamageAmount( Part , Weapon: GearPtr; Dmg , Scale: Integer ): Integer;
{ Determine the amount of concussive damage this attack could }
{ potentially apply to the soft bits of the mecha. }
var
it,MS: Integer;
begin
{ Base concussion chance is equal to the damage class of }
{ the weapon. }
it := Dmg;
{ Missiles and Melee Weapons do more concussion than normal. }
if ( Weapon <> Nil ) then begin
if Weapon^.G = GG_Weapon then begin
if ( Weapon^.S = GS_Missile ) then begin
it := it + MissileConcussion;
end else if ( Weapon^.S = GS_Melee ) then begin
it := it + MeleeConcussion;
end;
end else if Weapon^.G = GG_Module then begin
it := it + ModuleConcussion;
end;
end;
{ If the weapon scale is greater than the target scale, }
{ more concussion is done. }
if Scale > Part^.Scale then it := it * ( Scale - Part^.Scale + 1 )
else if Scale < Part^.Scale then it := it div ( Part^.Scale - Scale + 3 );
{ Determine the master size of the target. }
MS := MasterSize( Part );
if MS < 1 then MS := 1;
ConcussionDamageAmount := it div MS;
end;
Function ApplyConcussion( Part: GearPtr; CDC: Integer; AutoDamage: Boolean ): Integer;
{ Concussion damage is force from the impact which is passed }
{ on to the soft parts of a mecha- i.e. its pilot. It can also }
{ be passed on to inventory items, since these are outside }
{ of the armor's protection. }
{ Return the amount of damage done. }
Function ACNow: Integer;
{ Apply the concussion damage to PART now. }
{ Return the amount of damage done. }
var
D: Integer;
begin
D := Random( CDC + 1 );
if ( D > 0 ) and NotDestroyed( Part ) then ApplyDamage( Part , D );
ACNow := D;
end;
var
P2: GearPtr;
Total: Integer;
begin
{ Initialize TOTAL to 0. }
Total := 0;
{ If this part is succeptable to concussion damage, }
{ apply the damage. }
if ( Part^.G = GG_Character ) and ( Part^.Parent <> Nil ) and ( Random( 100 ) < DamagePilotChance ) then begin
Total := Total + ACNow;
end else if AutoDamage and ( Random( 100 ) < DamageInventoryChance ) then begin
Total := Total + ACNow;
end;
{ Check all sub- and inv- components of this part. }
{ Automatically damage the inventory components. }
P2 := Part^.SubCom;
while P2 <> Nil do begin
Total := Total + ApplyConcussion( P2 , CDC , False );
P2 := P2^.Next;
end;
P2 := Part^.InvCom;
while P2 <> Nil do begin
Total := Total + ApplyConcussion( P2 , CDC , True );
P2 := P2^.Next;
end;
ApplyConcussion := Total;
end;
var
P2: GearPtr;
Total,T,Scale,TPDmg0: LongInt;
TMaster,TPilot: GearPtr;
TMasterOK,TPilotOK,OKatStart: Boolean;
MobileAtStart: Boolean;
begin
{ Initialize History Variables. }
DR.EjectRoll := False;
DR.EjectOK := False;
DR.PilotDied := False;
DR.MechaDestroyed := False;
DR.DamageDone := 0;
DAMAGE_OverKill := 0;
DAMAGE_Iterations := 0;
DisposeSAtt( Destroyed_Parts_List );
TMaster := FindRoot( O_Part );
TPilot := LocatePilot( TMaster );
TMasterOK := ( TMaster <> TPilot ) and NotDestroyed( TMaster );
TPilotOK := NoTDestroyed( TPilot );
OKatStart := TMasterOK or TPilotOK;
if TPilot <> Nil then TPDmg0 := AmountOfDamage( TPilot , False );
MobileAtStart := CurrentMoveRate( GB^.Scene , TMaster ) > 0;
{ Make sure at least one hit will be caused. }
if O_NumHits < 1 then O_NumHits := 1;
{ Reset total damage done to 0. }
Total := 0;
{ Determine the scale of the attack - this info is needed for }
{ rolling damage. If no weapon was used, this was probably a }
{ crash or other self-inflicted injury. Use the target's own }
{ scale against it. }
if O_Weapon = Nil then Scale := O_Part^.Scale
else begin
Scale := O_Weapon^.Scale;
{ Area effect weapons deal scatter damage. }
{ Scatter weapons do full damage against props and metaterrain. }
if HasAreaEffect( AtAt ) and ( O_Part^.G <> GG_MetaTerrain ) and ( O_Part^.G <> GG_Prop ) then begin
O_NumHits := O_NumHits * O_DMG;
O_DMG := 1;
end;
end;
{ Call the REAL procedure. }