Round 3: Some minor cross-platform compatibility changes (FreeBSD), still may not...
[theoddone33/hhexen.git] / base / p_inter.c
1
2 //**************************************************************************
3 //**
4 //** p_inter.c : Heretic 2 : Raven Software, Corp.
5 //**
6 //** $RCSfile$
7 //** $Revision$
8 //** $Date$
9 //** $Author$
10 //**
11 //**************************************************************************
12
13 #include "h2def.h"
14 #include "p_local.h"
15 #include "soundst.h"
16
17 #define BONUSADD 6
18
19 int ArmorIncrement[NUMCLASSES][NUMARMOR] =
20 {
21         { 25*FRACUNIT, 20*FRACUNIT, 15*FRACUNIT, 5*FRACUNIT },
22         { 10*FRACUNIT, 25*FRACUNIT, 5*FRACUNIT, 20*FRACUNIT },
23         { 5*FRACUNIT, 15*FRACUNIT, 10*FRACUNIT, 25*FRACUNIT },
24         {20*FRACUNIT, 10*FRACUNIT, 25*FRACUNIT, 5*FRACUNIT },
25         { 0, 0, 0, 0 }
26 };
27
28 int AutoArmorSave[NUMCLASSES] = { 15*FRACUNIT, 10*FRACUNIT, 5*FRACUNIT,
29  10*FRACUNIT,
30  0 };
31
32 char *TextKeyMessages[] = 
33 {
34         TXT_KEY_STEEL,
35         TXT_KEY_CAVE,
36         TXT_KEY_AXE,
37         TXT_KEY_FIRE,
38         TXT_KEY_EMERALD,
39         TXT_KEY_DUNGEON,
40         TXT_KEY_SILVER,
41         TXT_KEY_RUSTED,
42         TXT_KEY_HORN,
43         TXT_KEY_SWAMP,
44         TXT_KEY_CASTLE
45 };
46
47 static void SetDormantArtifact(mobj_t *arti);
48 static void TryPickupArtifact(player_t *player, artitype_t artifactType,
49         mobj_t *artifact);
50 static void TryPickupWeapon(player_t *player, pclass_t weaponClass,
51         weapontype_t weaponType, mobj_t *weapon, char *message);
52 static void TryPickupWeaponPiece(player_t *player, pclass_t matchClass,
53         int pieceValue, mobj_t *pieceMobj);
54
55 /* jim Linux needs this too */
56 /*  #ifdef __NeXT__ */
57 #if defined(__NeXT__) || defined(__linux) || defined(__FreeBSD__)
58 extern void strupr(char *s);
59 #endif
60
61 //--------------------------------------------------------------------------
62 //
63 // PROC P_SetMessage
64 //
65 //--------------------------------------------------------------------------
66
67 void P_SetMessage(player_t *player, char *message, boolean ultmsg)
68 {
69         extern boolean messageson;
70         
71         if((player->ultimateMessage || !messageson) && !ultmsg)
72         {
73                 return;
74         }
75         if(strlen(message) > 79)
76         {
77                 memcpy(player->message, message, 80);
78                 player->message[80] = 0;
79         }
80         else
81         {
82                 strcpy(player->message, message);
83         }
84         strupr(player->message);
85         player->messageTics = MESSAGETICS;
86         player->yellowMessage = false;
87         if(ultmsg)
88         {
89                 player->ultimateMessage = true;
90         }
91         if(player == &players[consoleplayer])
92         {
93                 BorderTopRefresh = true;
94         }
95 }
96
97 //==========================================================================
98 //
99 // P_SetYellowMessage
100 //
101 //==========================================================================
102
103 void P_SetYellowMessage(player_t *player, char *message, boolean ultmsg)
104 {
105         extern boolean messageson;
106         
107         if((player->ultimateMessage || !messageson) && !ultmsg)
108         {
109                 return;
110         }
111         if(strlen(message) > 79)
112         {
113                 memcpy(player->message, message, 80);
114                 player->message[80] = 0;
115         }
116         else
117         {
118                 strcpy(player->message, message);
119         }
120         player->messageTics = 5*MESSAGETICS; // Bold messages last longer
121         player->yellowMessage = true;
122         if(ultmsg)
123         {
124                 player->ultimateMessage = true;
125         }
126         if(player == &players[consoleplayer])
127         {
128                 BorderTopRefresh = true;
129         }
130 }
131
132 //==========================================================================
133 //
134 // P_ClearMessage
135 //
136 //==========================================================================
137
138 void P_ClearMessage(player_t *player)
139 {
140         player->messageTics = 0;
141         if(player == &players[consoleplayer])
142         {
143                 BorderTopRefresh = true;
144         }
145 }
146
147 //----------------------------------------------------------------------------
148 //
149 // PROC P_HideSpecialThing
150 //
151 //----------------------------------------------------------------------------
152
153 void P_HideSpecialThing(mobj_t *thing)
154 {
155         thing->flags &= ~MF_SPECIAL;
156         thing->flags2 |= MF2_DONTDRAW;
157         P_SetMobjState(thing, S_HIDESPECIAL1);
158 }
159
160 //--------------------------------------------------------------------------
161 //
162 // FUNC P_GiveMana
163 //
164 // Returns true if the player accepted the mana, false if it was
165 // refused (player has MAX_MANA).
166 //
167 //--------------------------------------------------------------------------
168
169 boolean P_GiveMana(player_t *player, manatype_t mana, int count)
170 {
171         int prevMana;
172         //weapontype_t changeWeapon;
173
174         if(mana == MANA_NONE || mana == MANA_BOTH)
175         {
176                 return(false);
177         }
178         if(mana < 0 || mana > NUMMANA)
179         {
180                 I_Error("P_GiveMana: bad type %i", mana);
181         }
182         if(player->mana[mana] == MAX_MANA)
183         {
184                 return(false);
185         }
186         if(gameskill == sk_baby || gameskill == sk_nightmare)
187         { // extra mana in baby mode and nightmare mode
188                 count += count>>1;
189         }
190         prevMana = player->mana[mana];
191
192         player->mana[mana] += count;
193         if(player->mana[mana] > MAX_MANA)
194         {
195                 player->mana[mana] = MAX_MANA;
196         }
197         if(player->class == PCLASS_FIGHTER && player->readyweapon == WP_SECOND
198         && mana == MANA_1 && prevMana <= 0)
199         {
200                 P_SetPsprite(player, ps_weapon, S_FAXEREADY_G);
201         }
202         return(true);
203 }
204
205 //==========================================================================
206 //
207 // TryPickupWeapon
208 //
209 //==========================================================================
210
211 static void TryPickupWeapon(player_t *player, pclass_t weaponClass,
212         weapontype_t weaponType, mobj_t *weapon, char *message)
213 {
214         boolean remove;
215         boolean gaveMana;
216         boolean gaveWeapon;
217
218         remove = true;
219         if(player->class != weaponClass
220                 && player->class != PCLASS_ASS
221                 )
222         { // Wrong class, but try to pick up for mana
223                 if(netgame && !deathmatch)
224                 { // Can't pick up weapons for other classes in coop netplay
225                         return;
226                 }
227                 if(weaponType == WP_SECOND)
228                 {
229                         if(!P_GiveMana(player, MANA_1, 25))
230                         {
231                                 return;
232                         }
233                 }
234                 else
235                 {
236                         if(!P_GiveMana(player, MANA_2, 25))
237                         {
238                                 return;
239                         }
240                 }
241         }
242         else if(netgame && !deathmatch)
243         { // Cooperative net-game
244                 if(player->weaponowned[weaponType])
245                 {
246                         return;
247                 }
248                 player->weaponowned[weaponType] = true;
249                 if(weaponType == WP_SECOND)
250                 {
251                         P_GiveMana(player, MANA_1, 25);
252                 }
253                 else
254                 {
255                         P_GiveMana(player, MANA_2, 25);
256                 }
257                 player->pendingweapon = weaponType;
258                 remove = false;
259         }
260         else
261         { // Deathmatch or single player game
262                 if(weaponType == WP_SECOND)
263                 {
264                         gaveMana = P_GiveMana(player, MANA_1, 25);
265                 }
266                 else 
267                 {
268                         gaveMana = P_GiveMana(player, MANA_2, 25);
269                 }
270                 if(player->weaponowned[weaponType])
271                 {
272                         gaveWeapon = false;
273                 }
274                 else
275                 {
276                         gaveWeapon = true;
277                         player->weaponowned[weaponType] = true;
278                         if(weaponType > player->readyweapon)
279                         { // Only switch to more powerful weapons
280                                 player->pendingweapon = weaponType;
281                         }
282                 }
283                 if(!(gaveWeapon || gaveMana))
284                 { // Player didn't need the weapon or any mana
285                         return;
286                 }
287         }
288
289         P_SetMessage(player, message, false);
290         if(weapon->special)
291         {
292                 P_ExecuteLineSpecial(weapon->special, weapon->args,
293                         NULL, 0, player->mo);
294                 weapon->special = 0;
295         }
296
297         if(remove)
298         {
299                 if(deathmatch && !(weapon->flags2&MF2_DROPPED))
300                 {
301                         P_HideSpecialThing(weapon);
302                 }
303                 else
304                 {
305                         P_RemoveMobj(weapon);
306                 }
307         }
308
309         player->bonuscount += BONUSADD;
310         if(player == &players[consoleplayer])
311         {
312                 S_StartSound(NULL, SFX_PICKUP_WEAPON);
313                 SB_PaletteFlash(false);
314         }
315 }
316
317 //--------------------------------------------------------------------------
318 //
319 // FUNC P_GiveWeapon
320 //
321 // Returns true if the weapon or its mana was accepted.
322 //
323 //--------------------------------------------------------------------------
324
325 /*
326 boolean P_GiveWeapon(player_t *player, pclass_t class, weapontype_t weapon)
327 {
328         boolean gaveMana;
329         boolean gaveWeapon;
330
331         if(player->class != class)
332         { // player cannot use this weapon, take it anyway, and get mana
333                 if(netgame && !deathmatch)
334                 { // Can't pick up weapons for other classes in coop netplay
335                         return false;
336                 }
337                 if(weapon == WP_SECOND)
338                 {
339                         return P_GiveMana(player, MANA_1, 25);
340                 }
341                 else
342                 {
343                         return P_GiveMana(player, MANA_2, 25);
344                 }               
345         }
346         if(netgame && !deathmatch)
347         { // Cooperative net-game
348                 if(player->weaponowned[weapon])
349                 {
350                         return(false);
351                 }
352                 player->bonuscount += BONUSADD;
353                 player->weaponowned[weapon] = true;
354                 if(weapon == WP_SECOND)
355                 {
356                         P_GiveMana(player, MANA_1, 25);
357                 }
358                 else 
359                 {
360                         P_GiveMana(player, MANA_2, 25);
361                 }
362                 player->pendingweapon = weapon;
363                 if(player == &players[consoleplayer])
364                 {
365                         S_StartSound(NULL, SFX_PICKUP_WEAPON);
366                 }
367                 return(false);
368         }
369         if(weapon == WP_SECOND)
370         {
371                 gaveMana = P_GiveMana(player, MANA_1, 25);
372         }
373         else 
374         {
375                 gaveMana = P_GiveMana(player, MANA_2, 25);
376         }
377         if(player->weaponowned[weapon])
378         {
379                 gaveWeapon = false;
380         }
381         else
382         {
383                 gaveWeapon = true;
384                 player->weaponowned[weapon] = true;
385                 if(weapon > player->readyweapon)
386                 { // Only switch to more powerful weapons
387                         player->pendingweapon = weapon;
388                 }
389         }
390         return(gaveWeapon || gaveMana);
391 }
392 */
393
394 //===========================================================================
395 //
396 // P_GiveWeaponPiece
397 //
398 //===========================================================================
399
400 /*
401 boolean P_GiveWeaponPiece(player_t *player, pclass_t class, int piece)
402 {
403         P_GiveMana(player, MANA_1, 20);
404         P_GiveMana(player, MANA_2, 20);
405         if(player->class != class)
406         {
407                 return true;
408         }
409         else if(player->pieces&piece)
410         { // player already has that weapon piece
411                 return true;
412         }
413         player->pieces |= piece;
414         if(player->pieces == 7)
415         { // player has built the fourth weapon!
416                 P_GiveWeapon(player, class, WP_FOURTH);
417                 S_StartSound(player->mo, SFX_WEAPON_BUILD);
418         }
419         return true;
420 }
421 */
422
423 //==========================================================================
424 //
425 // TryPickupWeaponPiece
426 //
427 //==========================================================================
428
429 static void TryPickupWeaponPiece(player_t *player, pclass_t matchClass,
430         int pieceValue, mobj_t *pieceMobj)
431 {
432         boolean remove;
433         boolean checkAssembled;
434         boolean gaveWeapon;
435         int gaveMana;
436         static char *fourthWeaponText[] =
437         {
438                 TXT_WEAPON_F4,
439                 TXT_WEAPON_C4,
440                 TXT_WEAPON_M4,
441                 TXT_WEAPON_A4
442         };
443         static char *weaponPieceText[] =
444         {
445                 TXT_QUIETUS_PIECE,
446                 TXT_WRAITHVERGE_PIECE,
447                 TXT_BLOODSCOURGE_PIECE,
448                 TXT_STAFFOFSET_PIECE
449         };
450         static int pieceValueTrans[] =
451         {
452                 0,                                                      // 0: never
453                 WPIECE1|WPIECE2|WPIECE3,        // WPIECE1 (1)
454                 WPIECE2|WPIECE3,                        // WPIECE2 (2)
455                 0,                                                      // 3: never
456                 WPIECE3                                         // WPIECE3 (4)
457         };
458
459         remove = true;
460         checkAssembled = true;
461         gaveWeapon = false;
462         // Allow assassin to pick up any weapons
463         if(player->class != matchClass && player->class != PCLASS_ASS)
464         { // Wrong class, but try to pick up for mana
465                 if(netgame && !deathmatch)
466                 { // Can't pick up wrong-class weapons in coop netplay
467                         return;
468                 }
469                 checkAssembled = false;
470                 gaveMana = P_GiveMana(player, MANA_1, 20)+
471                         P_GiveMana(player, MANA_2, 20);
472                 if(!gaveMana)
473                 { // Didn't need the mana, so don't pick it up
474                         return;
475                 }
476         }
477         else if(netgame && !deathmatch)
478         { // Cooperative net-game
479                 if(player->pieces&pieceValue)
480                 { // Already has the piece
481                         return;
482                 }
483                 pieceValue = pieceValueTrans[pieceValue];
484                 P_GiveMana(player, MANA_1, 20);
485                 P_GiveMana(player, MANA_2, 20);
486                 remove = false;
487         }
488         else
489         { // Deathmatch or single player game
490                 gaveMana = P_GiveMana(player, MANA_1, 20)+
491                         P_GiveMana(player, MANA_2, 20);
492                 if(player->pieces&pieceValue)
493                 { // Already has the piece, check if mana needed
494                         if(!gaveMana)
495                         { // Didn't need the mana, so don't pick it up
496                                 return;
497                         }
498                         checkAssembled = false;
499                 }
500         }
501
502         // Pick up the weapon piece
503         if(pieceMobj->special)
504         {
505                 P_ExecuteLineSpecial(pieceMobj->special, pieceMobj->args,
506                         NULL, 0, player->mo);
507                 pieceMobj->special = 0;
508         }
509         if(remove)
510         {
511                 if(deathmatch && !(pieceMobj->flags2&MF2_DROPPED))
512                 {
513                         P_HideSpecialThing(pieceMobj);
514                 }
515                 else
516                 {
517                         P_RemoveMobj(pieceMobj);
518                 }
519         }
520         player->bonuscount += BONUSADD;
521         if(player == &players[consoleplayer])
522         {
523                 SB_PaletteFlash(false);
524         }
525
526         // Check if fourth weapon assembled
527         if(checkAssembled)
528         {
529                 player->pieces |= pieceValue;
530                 if(player->pieces == (WPIECE1|WPIECE2|WPIECE3))
531                 {
532                         gaveWeapon = true;
533                         player->weaponowned[WP_FOURTH] = true;
534                         player->pendingweapon = WP_FOURTH;
535                 }
536         }
537
538         if(gaveWeapon)
539         {
540                 P_SetMessage(player, fourthWeaponText[matchClass], false);
541                 // Play the build-sound full volume for all players
542                 S_StartSound(NULL, SFX_WEAPON_BUILD);
543         }
544         else
545         {
546                 P_SetMessage(player, weaponPieceText[matchClass], false);
547                 if(player == &players[consoleplayer])
548                 {
549                         S_StartSound(NULL, SFX_PICKUP_WEAPON);
550                 }
551         }
552 }
553
554 //---------------------------------------------------------------------------
555 //
556 // FUNC P_GiveBody
557 //
558 // Returns false if the body isn't needed at all.
559 //
560 //---------------------------------------------------------------------------
561
562 boolean P_GiveBody(player_t *player, int num)
563 {
564         int max;
565
566         max = MAXHEALTH;
567         if(player->morphTics)
568         {
569                 max = MAXMORPHHEALTH;
570         }
571         if(player->health >= max)
572         {
573                 return(false);
574         }
575         player->health += num;
576         if(player->health > max)
577         {
578                 player->health = max;
579         }
580         player->mo->health = player->health;
581         return(true);
582 }
583
584 //---------------------------------------------------------------------------
585 //
586 // FUNC P_GiveArmor
587 //
588 // Returns false if the armor is worse than the current armor.
589 //
590 //---------------------------------------------------------------------------
591
592 boolean P_GiveArmor(player_t *player, armortype_t armortype, int amount)
593 {
594         int hits;
595         int totalArmor;
596
597         extern int ArmorMax[NUMCLASSES];
598
599         if(amount == -1)
600         {
601                 hits = ArmorIncrement[player->class][armortype];
602                 if(player->armorpoints[armortype] >= hits)
603                 {
604                         return false;
605                 }
606                 else
607                 {
608                         player->armorpoints[armortype] = hits;
609                 }
610         }
611         else
612         {
613                 hits = amount*5*FRACUNIT;
614                 totalArmor = player->armorpoints[ARMOR_ARMOR]
615                         +player->armorpoints[ARMOR_SHIELD]
616                         +player->armorpoints[ARMOR_HELMET]
617                         +player->armorpoints[ARMOR_AMULET]
618                         +AutoArmorSave[player->class];
619                 if(totalArmor < ArmorMax[player->class]*5*FRACUNIT)
620                 {
621                         player->armorpoints[armortype] += hits;
622                 }
623                 else
624                 {
625                         return false;
626                 }
627         }
628         return true;
629 }
630
631 //---------------------------------------------------------------------------
632 //
633 // PROC P_GiveKey
634 //
635 //---------------------------------------------------------------------------
636
637 int P_GiveKey(player_t *player, keytype_t key)
638 {
639         if(player->keys&(1<<key))
640         {
641                 return false;
642         }
643         player->bonuscount += BONUSADD;
644         player->keys |= 1<<key;
645         return true;
646 }
647
648 //---------------------------------------------------------------------------
649 //
650 // FUNC P_GivePower
651 //
652 // Returns true if power accepted.
653 //
654 //---------------------------------------------------------------------------
655
656 boolean P_GivePower(player_t *player, powertype_t power)
657 {
658         if(power == pw_invulnerability)
659         {
660                 if(player->powers[power] > BLINKTHRESHOLD)
661                 { // Already have it
662                         return(false);
663                 }
664                 player->powers[power] = INVULNTICS;
665                 player->mo->flags2 |= MF2_INVULNERABLE;
666                 if(player->class == PCLASS_MAGE)
667                 {
668                         player->mo->flags2 |= MF2_REFLECTIVE;
669                 }
670                 return(true);
671         }
672         if(power == pw_flight)
673         {
674                 if(player->powers[power] > BLINKTHRESHOLD)
675                 { // Already have it
676                         return(false);
677                 }
678                 player->powers[power] = FLIGHTTICS;
679                 player->mo->flags2 |= MF2_FLY;
680                 player->mo->flags |= MF_NOGRAVITY;
681                 if(player->mo->z <= player->mo->floorz)
682                 {
683                         player->flyheight = 10; // thrust the player in the air a bit
684                 }
685                 return(true);
686         }
687         if(power == pw_infrared)
688         {
689                 if(player->powers[power] > BLINKTHRESHOLD)
690                 { // Already have it
691                         return(false);
692                 }
693                 player->powers[power] = INFRATICS;
694                 return(true);
695         }
696         if(power == pw_speed)
697         {
698                 if(player->powers[power] > BLINKTHRESHOLD)
699                 { // Already have it
700                         return(false);
701                 }
702                 player->powers[power] = SPEEDTICS;
703                 return(true);
704         }
705         if(power == pw_minotaur)
706         {
707                 // Doesn't matter if already have power, renew ticker
708                 player->powers[power] = MAULATORTICS;
709                 return(true);
710         }
711 /*
712         if(power == pw_ironfeet)
713         {
714                 player->powers[power] = IRONTICS;
715                 return(true);
716         }
717         if(power == pw_strength)
718         {
719                 P_GiveBody(player, 100);
720                 player->powers[power] = 1;
721                 return(true);
722         }
723 */
724         if(player->powers[power])
725         {
726                 return(false); // already got it
727         }
728         player->powers[power] = 1;
729         return(true);
730 }
731
732 //==========================================================================
733 //
734 // TryPickupArtifact
735 //
736 //==========================================================================
737
738 static void TryPickupArtifact(player_t *player, artitype_t artifactType,
739         mobj_t *artifact)
740 {
741         static char *artifactMessages[NUMARTIFACTS] =
742         {
743                 NULL,
744                 TXT_ARTIINVULNERABILITY,
745                 TXT_ARTIHEALTH,
746                 TXT_ARTISUPERHEALTH,
747                 TXT_ARTIHEALINGRADIUS,
748                 TXT_ARTISUMMON,
749                 TXT_ARTITORCH,
750                 TXT_ARTIEGG,
751                 TXT_ARTIFLY,
752                 TXT_ARTIBLASTRADIUS,
753                 TXT_ARTIPOISONBAG,
754                 TXT_ARTITELEPORTOTHER,
755                 TXT_ARTISPEED,
756                 TXT_ARTIBOOSTMANA,
757                 TXT_ARTIBOOSTARMOR,
758                 TXT_ARTITELEPORT,
759                 TXT_ARTIPUZZSKULL,
760                 TXT_ARTIPUZZGEMBIG,
761                 TXT_ARTIPUZZGEMRED,
762                 TXT_ARTIPUZZGEMGREEN1,
763                 TXT_ARTIPUZZGEMGREEN2,
764                 TXT_ARTIPUZZGEMBLUE1,
765                 TXT_ARTIPUZZGEMBLUE2,
766                 TXT_ARTIPUZZBOOK1,
767                 TXT_ARTIPUZZBOOK2,
768                 TXT_ARTIPUZZSKULL2,
769                 TXT_ARTIPUZZFWEAPON,
770                 TXT_ARTIPUZZCWEAPON,
771                 TXT_ARTIPUZZMWEAPON,
772                 TXT_ARTIPUZZGEAR,       // All gear pickups use the same text
773                 TXT_ARTIPUZZGEAR,
774                 TXT_ARTIPUZZGEAR,
775                 TXT_ARTIPUZZGEAR
776         };
777
778         if(P_GiveArtifact(player, artifactType, artifact))
779         {
780                 if(artifact->special)
781                 {
782                         P_ExecuteLineSpecial(artifact->special, artifact->args,
783                                 NULL, 0, NULL);
784                         artifact->special = 0;
785                 }
786                 player->bonuscount += BONUSADD;
787                 if(artifactType < arti_firstpuzzitem)
788                 {
789                         SetDormantArtifact(artifact);
790                         S_StartSound(artifact, SFX_PICKUP_ARTIFACT);
791                         P_SetMessage(player, artifactMessages[artifactType], false);
792                 }
793                 else
794                 { // Puzzle item
795                         S_StartSound(NULL, SFX_PICKUP_ITEM);
796                         P_SetMessage(player, artifactMessages[artifactType], true);
797                         if(!netgame || deathmatch)
798                         { // Remove puzzle items if not cooperative netplay
799                                 P_RemoveMobj(artifact);
800                         }
801                 }
802         }
803 }
804
805 //---------------------------------------------------------------------------
806 //
807 // FUNC P_GiveArtifact
808 //
809 // Returns true if artifact accepted.
810 //
811 //---------------------------------------------------------------------------
812
813 boolean P_GiveArtifact(player_t *player, artitype_t arti, mobj_t *mo)
814 {
815         int i;
816         int j;
817         boolean slidePointer;
818
819         slidePointer = false;
820         i = 0;
821         while(player->inventory[i].type != arti && i < player->inventorySlotNum)
822         {
823                 i++;
824         }
825         if(i == player->inventorySlotNum)
826         {
827                 if(arti < arti_firstpuzzitem)
828                 {
829                         i = 0;
830                         while(player->inventory[i].type < arti_firstpuzzitem
831                         && i < player->inventorySlotNum)
832                         {
833                                 i++;
834                         }
835                         if(i != player->inventorySlotNum)
836                         {
837                                 for(j = player->inventorySlotNum; j > i; j--)
838                                 {
839                                         player->inventory[j].count = player->inventory[j-1].count;
840                                         player->inventory[j].type = player->inventory[j-1].type;
841                                         slidePointer = true;
842                                 }
843                         }
844                 }
845                 player->inventory[i].count = 1;
846                 player->inventory[i].type = arti;
847                 player->inventorySlotNum++;
848         }
849         else
850         {
851                 if(arti >= arti_firstpuzzitem && netgame && !deathmatch)
852                 { // Can't carry more than 1 puzzle item in coop netplay
853                         return false;
854                 }
855                 if(player->inventory[i].count >= 25)
856                 { // Player already has 25 of this item
857                         return false;
858                 }
859                 player->inventory[i].count++;
860         }
861         if(!player->artifactCount)
862         {
863                 player->readyArtifact = arti;
864         }
865         else if(player == &players[consoleplayer] && slidePointer
866                 && i <= inv_ptr)
867         {
868                 inv_ptr++;
869                 curpos++;
870                 if(curpos > 6)
871                 {
872                         curpos = 6;
873                 }
874         }
875         player->artifactCount++;
876         return(true);
877 }
878
879 //==========================================================================
880 //
881 // SetDormantArtifact
882 //
883 // Removes the MF_SPECIAL flag and initiates the artifact pickup
884 // animation.
885 //
886 //==========================================================================
887
888 static void SetDormantArtifact(mobj_t *arti)
889 {
890         arti->flags &= ~MF_SPECIAL;
891         if(deathmatch && !(arti->flags2 & MF2_DROPPED))
892         {
893                 if(arti->type == MT_ARTIINVULNERABILITY)
894                 {
895                         P_SetMobjState(arti, S_DORMANTARTI3_1);
896                 }
897                 else if(arti->type == MT_SUMMONMAULATOR
898                         || arti->type == MT_ARTIFLY)
899                 {
900                         P_SetMobjState(arti, S_DORMANTARTI2_1);
901                 }
902                 else
903                 {
904                         P_SetMobjState(arti, S_DORMANTARTI1_1);
905                 }
906         }
907         else
908         { // Don't respawn
909                 P_SetMobjState(arti, S_DEADARTI1);
910         }
911 }
912
913 //---------------------------------------------------------------------------
914 //
915 // PROC A_RestoreArtifact
916 //
917 //---------------------------------------------------------------------------
918
919 void A_RestoreArtifact(mobj_t *arti)
920 {
921         arti->flags |= MF_SPECIAL;
922         P_SetMobjState(arti, arti->info->spawnstate);
923         S_StartSound(arti, SFX_RESPAWN);
924 }
925
926 //---------------------------------------------------------------------------
927 //
928 // PROC A_RestoreSpecialThing1
929 //
930 // Make a special thing visible again.
931 //
932 //---------------------------------------------------------------------------
933
934 void A_RestoreSpecialThing1(mobj_t *thing)
935 {
936         thing->flags2 &= ~MF2_DONTDRAW;
937         S_StartSound(thing, SFX_RESPAWN);
938 }
939
940 //---------------------------------------------------------------------------
941 //
942 // PROC A_RestoreSpecialThing2
943 //
944 //---------------------------------------------------------------------------
945
946 void A_RestoreSpecialThing2(mobj_t *thing)
947 {
948         thing->flags |= MF_SPECIAL;
949         P_SetMobjState(thing, thing->info->spawnstate);
950 }
951
952 //---------------------------------------------------------------------------
953 //
954 // PROC P_TouchSpecialThing
955 //
956 //---------------------------------------------------------------------------
957
958 void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher)
959 {
960         player_t *player;
961         fixed_t delta;
962         int sound;
963         boolean respawn;
964
965         delta = special->z-toucher->z;
966         if(delta > toucher->height || delta < -32*FRACUNIT)
967         { // Out of reach
968                 return;
969         }
970         if(toucher->health <= 0)
971         { // Toucher is dead
972                 return;
973         }
974         sound = SFX_PICKUP_ITEM;
975         player = toucher->player;
976         respawn = true;
977         switch(special->sprite)
978         {
979                 // Items
980                 case SPR_PTN1: // Item_HealingPotion
981                         if(!P_GiveBody(player, 10))
982                         {
983                                 return;
984                         }
985                         P_SetMessage(player, TXT_ITEMHEALTH, false);
986                         break;
987                 case SPR_ARM1:
988                         if(!P_GiveArmor(player, ARMOR_ARMOR, -1))
989                         {
990                                 return;
991                         }
992                         P_SetMessage(player, TXT_ARMOR1, false);
993                         break;
994                 case SPR_ARM2:
995                         if(!P_GiveArmor(player, ARMOR_SHIELD, -1))
996                         {
997                                 return;
998                         }
999                         P_SetMessage(player, TXT_ARMOR2, false);
1000                         break;
1001                 case SPR_ARM3:
1002                         if(!P_GiveArmor(player, ARMOR_HELMET, -1))
1003                         {
1004                                 return;
1005                         }
1006                         P_SetMessage(player, TXT_ARMOR3, false);
1007                         break;
1008                 case SPR_ARM4:
1009                         if(!P_GiveArmor(player, ARMOR_AMULET, -1))
1010                         {
1011                                 return;
1012                         }
1013                         P_SetMessage(player, TXT_ARMOR4, false);
1014                         break;
1015
1016                 // Keys
1017                 case SPR_KEY1:
1018                 case SPR_KEY2:
1019                 case SPR_KEY3:
1020                 case SPR_KEY4:
1021                 case SPR_KEY5:
1022                 case SPR_KEY6:
1023                 case SPR_KEY7:
1024                 case SPR_KEY8:
1025                 case SPR_KEY9:
1026                 case SPR_KEYA:
1027                 case SPR_KEYB:
1028                         if(!P_GiveKey(player, special->sprite-SPR_KEY1))
1029                         {
1030                                 return;
1031                         }
1032                         P_SetMessage(player, TextKeyMessages[special->sprite-SPR_KEY1],
1033                                 true);
1034                         sound = SFX_PICKUP_KEY;
1035
1036                         // Check and process the special now in case the key doesn't
1037                         // get removed for coop netplay
1038                         if(special->special)
1039                         {
1040                                 P_ExecuteLineSpecial(special->special, special->args,
1041                                         NULL, 0, toucher);
1042                                 special->special = 0;
1043                         }
1044
1045                         if(!netgame)
1046                         { // Only remove keys in single player game
1047                                 break;
1048                         }
1049                         player->bonuscount += BONUSADD;
1050                         if(player == &players[consoleplayer])
1051                         {
1052                                 S_StartSound(NULL, sound);
1053                                 SB_PaletteFlash(false);
1054                         }
1055                         return;
1056
1057                 // Artifacts
1058                 case SPR_PTN2:
1059                         TryPickupArtifact(player, arti_health, special);
1060                         return;
1061                 case SPR_SOAR:
1062                         TryPickupArtifact(player, arti_fly, special);
1063                         return;
1064                 case SPR_INVU:
1065                         TryPickupArtifact(player, arti_invulnerability, special);
1066                         return;
1067                 case SPR_SUMN:
1068                         TryPickupArtifact(player, arti_summon, special);
1069                         return;
1070                 case SPR_PORK:
1071                         TryPickupArtifact(player, arti_egg, special);
1072                         return;
1073                 case SPR_SPHL:
1074                         TryPickupArtifact(player, arti_superhealth, special);
1075                         return;
1076                 case SPR_HRAD:
1077                         TryPickupArtifact(player, arti_healingradius, special);
1078                         return;
1079                 case SPR_TRCH:
1080                         TryPickupArtifact(player, arti_torch, special);
1081                         return;
1082                 case SPR_ATLP:
1083                         TryPickupArtifact(player, arti_teleport, special);
1084                         return;
1085                 case SPR_TELO:
1086                         TryPickupArtifact(player, arti_teleportother, special);
1087                         return;
1088                 case SPR_PSBG:
1089                         TryPickupArtifact(player, arti_poisonbag, special);
1090                         return;
1091                 case SPR_SPED:
1092                         TryPickupArtifact(player, arti_speed, special);
1093                         return;
1094                 case SPR_BMAN:
1095                         TryPickupArtifact(player, arti_boostmana, special);
1096                         return;
1097                 case SPR_BRAC:
1098                         TryPickupArtifact(player, arti_boostarmor, special);
1099                         return;
1100                 case SPR_BLST:
1101                         TryPickupArtifact(player, arti_blastradius, special);
1102                         return;
1103
1104                 // Puzzle artifacts
1105                 case SPR_ASKU:
1106                         TryPickupArtifact(player, arti_puzzskull, special);
1107                         return;
1108                 case SPR_ABGM:
1109                         TryPickupArtifact(player, arti_puzzgembig, special);
1110                         return;
1111                 case SPR_AGMR:
1112                         TryPickupArtifact(player, arti_puzzgemred, special);
1113                         return;
1114                 case SPR_AGMG:
1115                         TryPickupArtifact(player, arti_puzzgemgreen1, special);
1116                         return;
1117                 case SPR_AGG2:
1118                         TryPickupArtifact(player, arti_puzzgemgreen2, special);
1119                         return;
1120                 case SPR_AGMB:
1121                         TryPickupArtifact(player, arti_puzzgemblue1, special);
1122                         return;
1123                 case SPR_AGB2:
1124                         TryPickupArtifact(player, arti_puzzgemblue2, special);
1125                         return;
1126                 case SPR_ABK1:
1127                         TryPickupArtifact(player, arti_puzzbook1, special);
1128                         return;
1129                 case SPR_ABK2:
1130                         TryPickupArtifact(player, arti_puzzbook2, special);
1131                         return;
1132                 case SPR_ASK2:
1133                         TryPickupArtifact(player, arti_puzzskull2, special);
1134                         return;
1135                 case SPR_AFWP:
1136                         TryPickupArtifact(player, arti_puzzfweapon, special);
1137                         return;
1138                 case SPR_ACWP:
1139                         TryPickupArtifact(player, arti_puzzcweapon, special);
1140                         return;
1141                 case SPR_AMWP:
1142                         TryPickupArtifact(player, arti_puzzmweapon, special);
1143                         return;
1144                 case SPR_AGER:
1145                         TryPickupArtifact(player, arti_puzzgear1, special);
1146                         return;
1147                 case SPR_AGR2:
1148                         TryPickupArtifact(player, arti_puzzgear2, special);
1149                         return;
1150                 case SPR_AGR3:
1151                         TryPickupArtifact(player, arti_puzzgear3, special);
1152                         return;
1153                 case SPR_AGR4:
1154                         TryPickupArtifact(player, arti_puzzgear4, special);
1155                         return;
1156
1157                 // Mana
1158                 case SPR_MAN1:
1159                         if(!P_GiveMana(player, MANA_1, 15))
1160                         {
1161                                 return;
1162                         }
1163                         P_SetMessage(player, TXT_MANA_1, false);
1164                         break;
1165                 case SPR_MAN2: 
1166                         if(!P_GiveMana(player, MANA_2, 15))
1167                         {
1168                                 return;
1169                         }
1170                         P_SetMessage(player, TXT_MANA_2, false);
1171                         break;
1172                 case SPR_MAN3: // Double Mana Dodecahedron
1173                         if(!P_GiveMana(player, MANA_1, 20))
1174                         {
1175                                 if(!P_GiveMana(player, MANA_2, 20))
1176                                 {
1177                                         return;
1178                                 }
1179                         }
1180                         else
1181                         {
1182                                 P_GiveMana(player, MANA_2, 20);
1183                         }
1184                         P_SetMessage(player, TXT_MANA_BOTH, false);
1185                         break;
1186
1187                 // 2nd and 3rd Mage Weapons
1188                 case SPR_WMCS: // Frost Shards
1189                         TryPickupWeapon(player, PCLASS_MAGE, WP_SECOND,
1190                                 special, TXT_WEAPON_M2);
1191                         return;
1192                 case SPR_WMLG: // Arc of Death
1193                         TryPickupWeapon(player, PCLASS_MAGE, WP_THIRD,
1194                                 special, TXT_WEAPON_M3);
1195                         return;
1196
1197                 // 2nd and 3rd Fighter Weapons
1198                 case SPR_WFAX: // Timon's Axe
1199                         TryPickupWeapon(player, PCLASS_FIGHTER, WP_SECOND,
1200                                 special, TXT_WEAPON_F2);
1201                         return;
1202                 case SPR_WFHM: // Hammer of Retribution
1203                         TryPickupWeapon(player, PCLASS_FIGHTER, WP_THIRD,
1204                                 special, TXT_WEAPON_F3);
1205                         return;
1206
1207                 // 2nd and 3rd Cleric Weapons
1208                 case SPR_WCSS: // Serpent Staff
1209                         TryPickupWeapon(player, PCLASS_CLERIC, WP_SECOND,
1210                                 special, TXT_WEAPON_C2);
1211                         return;
1212                 case SPR_WCFM: // Firestorm
1213                         TryPickupWeapon(player, PCLASS_CLERIC, WP_THIRD,
1214                                 special, TXT_WEAPON_C3);
1215                         return;
1216
1217                 // Fourth Weapon Pieces
1218                 case SPR_WFR1:
1219                         TryPickupWeaponPiece(player, PCLASS_FIGHTER, WPIECE1,
1220                                 special);
1221                         return;
1222                 case SPR_WFR2:
1223                         TryPickupWeaponPiece(player, PCLASS_FIGHTER, WPIECE2,
1224                                 special);
1225                         return;
1226                 case SPR_WFR3:
1227                         TryPickupWeaponPiece(player, PCLASS_FIGHTER, WPIECE3,
1228                                 special);
1229                         return;
1230                 case SPR_WCH1:
1231                         TryPickupWeaponPiece(player, PCLASS_CLERIC, WPIECE1,
1232                                 special);
1233                         return;
1234                 case SPR_WCH2:
1235                         TryPickupWeaponPiece(player, PCLASS_CLERIC, WPIECE2,
1236                                 special);
1237                         return;
1238                 case SPR_WCH3:
1239                         TryPickupWeaponPiece(player, PCLASS_CLERIC, WPIECE3,
1240                                 special);
1241                         return;
1242                 case SPR_WMS1:
1243                         TryPickupWeaponPiece(player, PCLASS_MAGE, WPIECE1,
1244                                 special);
1245                         return;
1246                 case SPR_WMS2:
1247                         TryPickupWeaponPiece(player, PCLASS_MAGE, WPIECE2,
1248                                 special);
1249                         return;
1250                 case SPR_WMS3:
1251                         TryPickupWeaponPiece(player, PCLASS_MAGE, WPIECE3,
1252                                 special);
1253                         return;
1254 // Don't forget to fix this
1255 /*              case SPR_WAS1:
1256                         TryPickupWeaponPiece(player, PCLASS_ASS, WPIECE1,
1257                                  special);
1258                         return;
1259                 case SPR_WAS2:
1260                         TryPickupWeaponPiece(player, PCLASS_ASS, WPIECE2,
1261                                  special);
1262                         return;
1263                 case SPR_WAS3:
1264                         TryPickupWeaponPiece(player,PCLASS_ASS, WPIECE3,
1265                                  special);
1266                         return;
1267 */
1268
1269                 default:
1270                         I_Error("P_SpecialThing: Unknown gettable thing");
1271         }
1272         if(special->special)
1273         {
1274                 P_ExecuteLineSpecial(special->special, special->args, NULL,
1275                         0, toucher);
1276                 special->special = 0;
1277         }
1278         if(deathmatch && respawn && !(special->flags2&MF2_DROPPED))
1279         {
1280                 P_HideSpecialThing(special);
1281         }
1282         else
1283         {
1284                 P_RemoveMobj(special);
1285         }
1286         player->bonuscount += BONUSADD;
1287         if(player == &players[consoleplayer])
1288         {
1289                 S_StartSound(NULL, sound);
1290                 SB_PaletteFlash(false);
1291         }
1292 }
1293
1294 // Search thinker list for minotaur
1295 mobj_t *ActiveMinotaur(player_t *master)
1296 {
1297         mobj_t *mo;
1298         player_t *plr;
1299         thinker_t *think;
1300         unsigned int *starttime;
1301
1302         for(think = thinkercap.next; think != &thinkercap; think = think->next)
1303         {
1304                 if(think->function != P_MobjThinker) continue;
1305                 mo = (mobj_t *)think;
1306                 if(mo->type != MT_MINOTAUR) continue;
1307                 if(mo->health <= 0) continue;
1308                 if(!(mo->flags&MF_COUNTKILL)) continue;         // for morphed minotaurs
1309                 if(mo->flags&MF_CORPSE) continue;
1310                 starttime = (unsigned int *)mo->args;
1311                 if ((leveltime - *starttime) >= MAULATORTICS) continue;
1312                 plr = ((mobj_t *)mo->special1)->player;
1313                 if(plr == master) return(mo);
1314         }
1315         return(NULL);
1316 }
1317
1318
1319 //---------------------------------------------------------------------------
1320 //
1321 // PROC P_KillMobj
1322 //
1323 //---------------------------------------------------------------------------
1324
1325 void P_KillMobj(mobj_t *source, mobj_t *target)
1326 {
1327         int dummy;
1328         mobj_t *master;
1329
1330         target->flags &= ~(MF_SHOOTABLE|MF_FLOAT|MF_SKULLFLY|MF_NOGRAVITY);
1331         target->flags |= MF_CORPSE|MF_DROPOFF;
1332         target->flags2 &= ~MF2_PASSMOBJ;
1333         target->height >>= 2;
1334         if((target->flags&MF_COUNTKILL || target->type == MT_ZBELL) 
1335                  && target->special)
1336         { // Initiate monster death actions
1337                 if(target->type == MT_SORCBOSS)
1338                 {
1339                         dummy = 0;
1340                         P_StartACS(target->special, 0, (byte *)&dummy, target,
1341                                 NULL, 0);
1342                 }
1343                 else
1344                 {
1345                         P_ExecuteLineSpecial(target->special, target->args,
1346                                 NULL, 0, target);
1347                 }
1348         }
1349         if(source && source->player)
1350         { // Check for frag changes
1351                 if(target->player)
1352                 {
1353                         if(target == source)
1354                         { // Self-frag
1355                                 target->player->frags[target->player-players]--;
1356                                 if(cmdfrag && netgame
1357                                 && source->player == &players[consoleplayer])
1358                                 { // Send out a frag count packet
1359                                         NET_SendFrags(source->player);
1360                                 }
1361                         }
1362                         else
1363                         {
1364                                 source->player->frags[target->player-players]++;
1365                                 if(cmdfrag && netgame
1366                                 && source->player == &players[consoleplayer])
1367                                 { // Send out a frag count packet
1368                                         NET_SendFrags(source->player);
1369                                 }
1370                         }
1371                 }
1372         }
1373         if(target->player)
1374         { // Player death
1375                 if(!source)
1376                 { // Self-frag
1377                         target->player->frags[target->player-players]--;
1378                         if(cmdfrag && netgame
1379                         && target->player == &players[consoleplayer])
1380                         { // Send out a frag count packet
1381                                 NET_SendFrags(target->player);
1382                         }
1383                 }
1384                 target->flags &= ~MF_SOLID;
1385                 target->flags2 &= ~MF2_FLY;
1386                 target->player->powers[pw_flight] = 0;
1387                 target->player->playerstate = PST_DEAD;
1388                 P_DropWeapon(target->player);
1389                 if(target->flags2&MF2_FIREDAMAGE)
1390                 { // Player flame death
1391                         switch(target->player->class)
1392                         {
1393                                 case PCLASS_FIGHTER:
1394                                         S_StartSound(target, SFX_PLAYER_FIGHTER_BURN_DEATH);
1395                                         P_SetMobjState(target, S_PLAY_F_FDTH1);
1396                                         return;
1397                                 case PCLASS_CLERIC:
1398                                         S_StartSound(target, SFX_PLAYER_CLERIC_BURN_DEATH);
1399                                         P_SetMobjState(target, S_PLAY_C_FDTH1);
1400                                         return;
1401                                 case PCLASS_MAGE:
1402                                         S_StartSound(target, SFX_PLAYER_MAGE_BURN_DEATH);
1403                                         P_SetMobjState(target, S_PLAY_M_FDTH1);
1404                                         return;
1405                                 default:
1406                                         break;
1407                         }
1408                 }
1409                 if(target->flags2&MF2_ICEDAMAGE)
1410                 { // Player ice death
1411                         target->flags &= ~(7<<MF_TRANSSHIFT); //no translation
1412                         target->flags |= MF_ICECORPSE;
1413                         switch(target->player->class)
1414                         {
1415                                 case PCLASS_FIGHTER:
1416                                         P_SetMobjState(target, S_FPLAY_ICE);
1417                                         return;
1418                                 case PCLASS_CLERIC:
1419                                         P_SetMobjState(target, S_CPLAY_ICE);
1420                                         return;
1421                                 case PCLASS_MAGE:
1422                                         P_SetMobjState(target, S_MPLAY_ICE);
1423                                         return;
1424                                 case PCLASS_PIG:
1425                                         P_SetMobjState(target, S_PIG_ICE);
1426                                         return;
1427                                 default:
1428                                         break;
1429                         }
1430                 }
1431         }
1432         if(target->flags2&MF2_FIREDAMAGE)
1433         {
1434                 if(target->type == MT_FIGHTER_BOSS 
1435                         || target->type == MT_CLERIC_BOSS
1436                         || target->type == MT_MAGE_BOSS)
1437                 {
1438                         switch(target->type)
1439                         {
1440                                 case MT_FIGHTER_BOSS:
1441                                         S_StartSound(target, SFX_PLAYER_FIGHTER_BURN_DEATH);
1442                                         P_SetMobjState(target, S_PLAY_F_FDTH1);
1443                                         return;
1444                                 case MT_CLERIC_BOSS:
1445                                         S_StartSound(target, SFX_PLAYER_CLERIC_BURN_DEATH);
1446                                         P_SetMobjState(target, S_PLAY_C_FDTH1);
1447                                         return;
1448                                 case MT_MAGE_BOSS:
1449                                         S_StartSound(target, SFX_PLAYER_MAGE_BURN_DEATH);
1450                                         P_SetMobjState(target, S_PLAY_M_FDTH1);
1451                                         return;
1452                                 default:
1453                                         break;
1454                         }
1455                 }
1456                 else if(target->type == MT_TREEDESTRUCTIBLE)
1457                 {
1458                         P_SetMobjState(target, S_ZTREEDES_X1);
1459                         target->height = 24*FRACUNIT;
1460                         S_StartSound(target, SFX_TREE_EXPLODE);
1461                         return;
1462                 }
1463         }
1464         if(target->flags2&MF2_ICEDAMAGE)
1465         {
1466                 target->flags |= MF_ICECORPSE;
1467                 switch(target->type)
1468                 {
1469                         case MT_BISHOP:
1470                                 P_SetMobjState(target, S_BISHOP_ICE);
1471                                 return;         
1472                         case MT_CENTAUR:
1473                         case MT_CENTAURLEADER:
1474                                 P_SetMobjState(target, S_CENTAUR_ICE);
1475                                 return;         
1476                         case MT_DEMON:
1477                         case MT_DEMON2:
1478                                 P_SetMobjState(target, S_DEMON_ICE);
1479                                 return;         
1480                         case MT_SERPENT:
1481                         case MT_SERPENTLEADER:
1482                                 P_SetMobjState(target, S_SERPENT_ICE);
1483                                 return;         
1484                         case MT_WRAITH:
1485                         case MT_WRAITHB:
1486                                 P_SetMobjState(target, S_WRAITH_ICE);
1487                                 return;
1488                         case MT_ETTIN:
1489                                 P_SetMobjState(target, S_ETTIN_ICE1);
1490                                 return;
1491                         case MT_FIREDEMON:
1492                                 P_SetMobjState(target, S_FIRED_ICE1);
1493                                 return;
1494                         case MT_FIGHTER_BOSS:
1495                                 P_SetMobjState(target, S_FIGHTER_ICE);
1496                                 return;
1497                         case MT_CLERIC_BOSS:
1498                                 P_SetMobjState(target, S_CLERIC_ICE);
1499                                 return;
1500                         case MT_MAGE_BOSS:
1501                                 P_SetMobjState(target, S_MAGE_ICE);
1502                                 return;
1503                         case MT_PIG:
1504                                 P_SetMobjState(target, S_PIG_ICE);
1505                                 return;
1506                         default:
1507                                 target->flags &= ~MF_ICECORPSE;
1508                                 break;
1509                 }
1510         }
1511
1512         if(target->type == MT_MINOTAUR)
1513         {
1514                 master = (mobj_t *)target->special1;
1515                 if(master->health > 0)
1516                 {
1517                         if (!ActiveMinotaur(master->player))
1518                         {
1519                                 master->player->powers[pw_minotaur] = 0;
1520                         }
1521                 }               
1522         }
1523         else if(target->type == MT_TREEDESTRUCTIBLE)
1524         {
1525                 target->height = 24*FRACUNIT;
1526         }
1527         if(target->health < -(target->info->spawnhealth>>1)
1528                 && target->info->xdeathstate)
1529         { // Extreme death
1530                 P_SetMobjState(target, target->info->xdeathstate);
1531         }
1532         else
1533         { // Normal death
1534                 if ((target->type==MT_FIREDEMON) &&
1535                         (target->z <= target->floorz + 2*FRACUNIT) &&
1536                         (target->info->xdeathstate))
1537                 {
1538                         // This is to fix the imps' staying in fall state
1539                         P_SetMobjState(target, target->info->xdeathstate);
1540                 }
1541                 else
1542                 {
1543                         P_SetMobjState(target, target->info->deathstate);
1544                 }
1545         }
1546         target->tics -= P_Random()&3;
1547 //      I_StartSound(&actor->r, actor->info->deathsound);
1548 }
1549
1550 //---------------------------------------------------------------------------
1551 //
1552 // FUNC P_MinotaurSlam
1553 //
1554 //---------------------------------------------------------------------------
1555
1556 void P_MinotaurSlam(mobj_t *source, mobj_t *target)
1557 {
1558         angle_t angle;
1559         fixed_t thrust;
1560
1561         angle = R_PointToAngle2(source->x, source->y, target->x, target->y);
1562         angle >>= ANGLETOFINESHIFT;
1563         thrust = 16*FRACUNIT+(P_Random()<<10);
1564         target->momx += FixedMul(thrust, finecosine[angle]);
1565         target->momy += FixedMul(thrust, finesine[angle]);
1566         P_DamageMobj(target, NULL, source, HITDICE(4));
1567         if(target->player)
1568         {
1569                 target->reactiontime = 14+(P_Random()&7);
1570         }
1571         source->args[0] = 0;                    // Stop charging
1572 }
1573
1574
1575 //---------------------------------------------------------------------------
1576 //
1577 // FUNC P_MorphPlayer
1578 //
1579 // Returns true if the player gets turned into a pig
1580 //
1581 //---------------------------------------------------------------------------
1582
1583 boolean P_MorphPlayer(player_t *player)
1584 {
1585         mobj_t *pmo;
1586         mobj_t *fog;
1587         mobj_t *beastMo;
1588         fixed_t x;
1589         fixed_t y;
1590         fixed_t z;
1591         angle_t angle;
1592         int oldFlags2;
1593
1594         if(player->powers[pw_invulnerability])
1595         { // Immune when invulnerable
1596                 return(false);
1597         }
1598         if(player->morphTics)
1599         { // Player is already a beast
1600                 return false;
1601         }
1602         pmo = player->mo;
1603         x = pmo->x;
1604         y = pmo->y;
1605         z = pmo->z;
1606         angle = pmo->angle;
1607         oldFlags2 = pmo->flags2;
1608         P_SetMobjState(pmo, S_FREETARGMOBJ);
1609         fog = P_SpawnMobj(x, y, z+TELEFOGHEIGHT, MT_TFOG);
1610         S_StartSound(fog, SFX_TELEPORT);
1611         beastMo = P_SpawnMobj(x, y, z, MT_PIGPLAYER);
1612         beastMo->special1 = player->readyweapon;
1613         beastMo->angle = angle;
1614         beastMo->player = player;
1615         player->health = beastMo->health = MAXMORPHHEALTH;
1616         player->mo = beastMo;
1617         memset(&player->armorpoints[0], 0, NUMARMOR*sizeof(int));
1618         player->class = PCLASS_PIG;
1619         if(oldFlags2&MF2_FLY)
1620         {
1621                 beastMo->flags2 |= MF2_FLY;
1622         }
1623         player->morphTics = MORPHTICS;
1624         P_ActivateMorphWeapon(player);
1625         return(true);
1626 }
1627
1628 //---------------------------------------------------------------------------
1629 //
1630 // FUNC P_MorphMonster
1631 //
1632 //---------------------------------------------------------------------------
1633
1634 boolean P_MorphMonster(mobj_t *actor)
1635 {
1636         mobj_t *master, *monster, *fog;
1637         mobjtype_t moType;
1638         fixed_t x;
1639         fixed_t y;
1640         fixed_t z;
1641         mobj_t oldMonster;
1642
1643         if(actor->player) return(false);
1644         if(!(actor->flags&MF_COUNTKILL)) return false;
1645         if(actor->flags2&MF2_BOSS) return false;
1646         moType = actor->type;
1647         switch(moType)
1648         {
1649                 case MT_PIG:
1650                         return(false);
1651                 case MT_FIGHTER_BOSS:
1652                 case MT_CLERIC_BOSS:
1653                 case MT_MAGE_BOSS:
1654                         return(false);
1655                 default:
1656                         break;
1657         }
1658
1659         oldMonster = *actor;
1660         x = oldMonster.x;
1661         y = oldMonster.y;
1662         z = oldMonster.z;
1663         P_RemoveMobjFromTIDList(actor);
1664         P_SetMobjState(actor, S_FREETARGMOBJ);
1665         fog = P_SpawnMobj(x, y, z+TELEFOGHEIGHT, MT_TFOG);
1666         S_StartSound(fog, SFX_TELEPORT);
1667         monster = P_SpawnMobj(x, y, z, MT_PIG);
1668         monster->special2 = moType;
1669         monster->special1 = MORPHTICS+P_Random();
1670         monster->flags |= (oldMonster.flags&MF_SHADOW);
1671         monster->target = oldMonster.target;
1672         monster->angle = oldMonster.angle;
1673         monster->tid = oldMonster.tid;
1674         monster->special = oldMonster.special;
1675         P_InsertMobjIntoTIDList(monster, oldMonster.tid);
1676         memcpy(monster->args, oldMonster.args, 5);
1677
1678         // check for turning off minotaur power for active icon
1679         if (moType==MT_MINOTAUR)
1680         {
1681                 master = (mobj_t *)oldMonster.special1;
1682                 if(master->health > 0)
1683                 {
1684                         if (!ActiveMinotaur(master->player))
1685                         {
1686                                 master->player->powers[pw_minotaur] = 0;
1687                         }
1688                 }               
1689         }
1690         return(true);
1691 }
1692
1693 //---------------------------------------------------------------------------
1694 //
1695 // PROC P_AutoUseHealth
1696 //
1697 //---------------------------------------------------------------------------
1698
1699 void P_AutoUseHealth(player_t *player, int saveHealth)
1700 {
1701         int i;
1702         int count;
1703         int normalCount;
1704         int normalSlot=0;
1705         int superCount;
1706         int superSlot=0;
1707
1708         normalCount = superCount = 0;
1709         for(i = 0; i < player->inventorySlotNum; i++)
1710         {
1711                 if(player->inventory[i].type == arti_health)
1712                 {
1713                         normalSlot = i;
1714                         normalCount = player->inventory[i].count;
1715                 }
1716                 else if(player->inventory[i].type == arti_superhealth)
1717                 {
1718                         superSlot = i;
1719                         superCount = player->inventory[i].count;
1720                 }
1721         }
1722         if((gameskill == sk_baby) && (normalCount*25 >= saveHealth))
1723         { // Use quartz flasks
1724                 count = (saveHealth+24)/25;
1725                 for(i = 0; i < count; i++)
1726                 {
1727                         player->health += 25;
1728                         P_PlayerRemoveArtifact(player, normalSlot);
1729                 }
1730         }
1731         else if(superCount*100 >= saveHealth)
1732         { // Use mystic urns
1733                 count = (saveHealth+99)/100;
1734                 for(i = 0; i < count; i++)
1735                 {
1736                         player->health += 100;
1737                         P_PlayerRemoveArtifact(player, superSlot);
1738                 }
1739         }
1740         else if((gameskill == sk_baby)
1741                 && (superCount*100+normalCount*25 >= saveHealth))
1742         { // Use mystic urns and quartz flasks
1743                 count = (saveHealth+24)/25;
1744                 saveHealth -= count*25;
1745                 for(i = 0; i < count; i++)
1746                 {
1747                         player->health += 25;
1748                         P_PlayerRemoveArtifact(player, normalSlot);
1749                 }
1750                 count = (saveHealth+99)/100;
1751                 for(i = 0; i < count; i++)
1752                 {
1753                         player->health += 100;
1754                         P_PlayerRemoveArtifact(player, normalSlot);
1755                 }
1756         }
1757         player->mo->health = player->health;
1758 }
1759
1760 /*
1761 =================
1762 =
1763 = P_DamageMobj
1764 =
1765 = Damages both enemies and players
1766 = inflictor is the thing that caused the damage
1767 =               creature or missile, can be NULL (slime, etc)
1768 = source is the thing to target after taking damage
1769 =               creature or NULL
1770 = Source and inflictor are the same for melee attacks
1771 = source can be null for barrel explosions and other environmental stuff
1772 ==================
1773 */
1774
1775 void P_DamageMobj
1776 (
1777         mobj_t *target,
1778         mobj_t *inflictor,
1779         mobj_t *source,
1780         int     damage
1781 )
1782 {
1783         unsigned ang;
1784         int saved;
1785         fixed_t savedPercent;
1786         player_t *player;
1787         mobj_t *master;
1788         fixed_t thrust;
1789         int temp;
1790         int i;
1791
1792         if(!(target->flags&MF_SHOOTABLE))
1793         {
1794                 // Shouldn't happen
1795                 return;
1796         }
1797         if(target->health <= 0)
1798         {
1799                 if (inflictor && inflictor->flags2&MF2_ICEDAMAGE)
1800                 {
1801                         return;
1802                 }
1803                 else if (target->flags&MF_ICECORPSE) // frozen
1804                 {
1805                         target->tics = 1;
1806                         target->momx = target->momy = 0;
1807                 }
1808                 return;
1809         }
1810         if ((target->flags2&MF2_INVULNERABLE) && damage < 10000)
1811         { // mobj is invulnerable
1812                 if(target->player) return;      // for player, no exceptions
1813                 if(inflictor)
1814                 {
1815                         switch(inflictor->type)
1816                         {
1817                                 // These inflictors aren't foiled by invulnerability
1818                                 case MT_HOLY_FX:
1819                                 case MT_POISONCLOUD:
1820                                 case MT_FIREBOMB:
1821                                         break;
1822                                 default:
1823                                         return;
1824                         }
1825                 }
1826                 else
1827                 {
1828                         return;
1829                 }
1830         }
1831         if(target->player)
1832         {
1833                 if(damage < 1000 && ((target->player->cheats&CF_GODMODE)
1834                         || target->player->powers[pw_invulnerability]))
1835                 {
1836                         return;
1837                 }
1838         }
1839         if(target->flags&MF_SKULLFLY)
1840         {
1841                 target->momx = target->momy = target->momz = 0;
1842         }
1843         if(target->flags2&MF2_DORMANT)
1844         {
1845                 // Invulnerable, and won't wake up
1846                 return;
1847         }
1848         player = target->player;
1849         if(player && gameskill == sk_baby)
1850         {
1851                 // Take half damage in trainer mode
1852                 damage >>= 1;
1853         }
1854         // Special damage types
1855         if(inflictor)
1856         {
1857                 switch(inflictor->type)
1858                 {
1859                         case MT_EGGFX:
1860                                 if(player)
1861                                 {
1862                                         P_MorphPlayer(player);
1863                                 }
1864                                 else
1865                                 {
1866                                         P_MorphMonster(target);
1867                                 }
1868                                 return; // Always return
1869                         case MT_TELOTHER_FX1:
1870                         case MT_TELOTHER_FX2:
1871                         case MT_TELOTHER_FX3:
1872                         case MT_TELOTHER_FX4:
1873                         case MT_TELOTHER_FX5:
1874                                 if ((target->flags&MF_COUNTKILL) &&
1875                                         (target->type != MT_SERPENT) &&
1876                                         (target->type != MT_SERPENTLEADER) &&
1877                                         (!(target->flags2 & MF2_BOSS)))
1878                                 {
1879                                         P_TeleportOther(target);
1880                                 }
1881                                 return;
1882                         case MT_MINOTAUR:
1883                                 if(inflictor->flags&MF_SKULLFLY)
1884                                 { // Slam only when in charge mode
1885                                         P_MinotaurSlam(inflictor, target);
1886                                         return;
1887                                 }
1888                                 break;
1889                         case MT_BISH_FX:
1890                                 // Bishops are just too nasty
1891                                 damage >>= 1;
1892                                 break;
1893                         case MT_SHARDFX1:
1894                                 switch(inflictor->special2)
1895                                 {
1896                                         case 3:
1897                                                 damage <<= 3;
1898                                                 break;
1899                                         case 2:
1900                                                 damage <<= 2;
1901                                                 break;
1902                                         case 1:
1903                                                 damage <<= 1;
1904                                                 break;
1905                                         default:
1906                                                 break;
1907                                 }
1908                                 break;
1909                         case MT_CSTAFF_MISSILE:
1910                                 // Cleric Serpent Staff does poison damage
1911                                 if(target->player)
1912                                 {
1913                                         P_PoisonPlayer(target->player, source, 20);
1914                                         damage >>= 1;
1915                                 }
1916                                 break;
1917                         case MT_ICEGUY_FX2:
1918                                 damage >>= 1;
1919                                 break;
1920                         case MT_POISONDART:
1921                                 if(target->player)
1922                                 {
1923                                         P_PoisonPlayer(target->player, source, 20);
1924                                         damage >>= 1;
1925                                 }
1926                                 break;
1927                         case MT_POISONCLOUD:
1928                                 if(target->player)
1929                                 {
1930                                         if(target->player->poisoncount < 4)
1931                                         {
1932                                                 P_PoisonDamage(target->player, source,
1933                                                         15+(P_Random()&15), false); // Don't play painsound
1934                                                 P_PoisonPlayer(target->player, source, 50);
1935                                                 S_StartSound(target, SFX_PLAYER_POISONCOUGH);
1936                                         }       
1937                                         return;
1938                                 }
1939                                 else if(!(target->flags&MF_COUNTKILL))
1940                                 { // only damage monsters/players with the poison cloud
1941                                         return;
1942                                 }
1943                                 break;
1944                         case MT_FSWORD_MISSILE:
1945                                 if(target->player)
1946                                 {
1947                                         damage -= damage>>2;
1948                                 }
1949                                 break;
1950                         default:
1951                                 break;
1952                 }
1953         }
1954         // Push the target unless source is using the gauntlets
1955         if(inflictor && (!source || !source->player)
1956                 && !(inflictor->flags2&MF2_NODMGTHRUST))
1957         {
1958                 ang = R_PointToAngle2(inflictor->x, inflictor->y,
1959                         target->x, target->y);
1960                 //thrust = damage*(FRACUNIT>>3)*100/target->info->mass;
1961                 thrust = damage*(FRACUNIT>>3)*150/target->info->mass;
1962                 // make fall forwards sometimes
1963                 if((damage < 40) && (damage > target->health)
1964                         && (target->z-inflictor->z > 64*FRACUNIT) && (P_Random()&1))
1965                 {
1966                         ang += ANG180;
1967                         thrust *= 4;
1968                 }
1969                 ang >>= ANGLETOFINESHIFT;
1970                 target->momx += FixedMul(thrust, finecosine[ang]);
1971                 target->momy += FixedMul(thrust, finesine[ang]);
1972         }
1973
1974         //
1975         // player specific
1976         //
1977         if(player)
1978         {
1979                 savedPercent = AutoArmorSave[player->class]
1980                         +player->armorpoints[ARMOR_ARMOR]+player->armorpoints[ARMOR_SHIELD]
1981                         +player->armorpoints[ARMOR_HELMET]
1982                         +player->armorpoints[ARMOR_AMULET];
1983                 if(savedPercent)
1984                 { // armor absorbed some damage
1985                         if(savedPercent > 100*FRACUNIT)
1986                         {
1987                                 savedPercent = 100*FRACUNIT;
1988                         }
1989                         for(i = 0; i < NUMARMOR; i++)
1990                         {
1991                                 if(player->armorpoints[i])
1992                                 {
1993                                         player->armorpoints[i] -= 
1994                                                 FixedDiv(FixedMul(damage<<FRACBITS,
1995                                                 ArmorIncrement[player->class][i]), 300*FRACUNIT);
1996                                         if(player->armorpoints[i] < 2*FRACUNIT)
1997                                         {
1998                                                 player->armorpoints[i] = 0;
1999                                         }
2000                                 }
2001                         }
2002                         saved = FixedDiv(FixedMul(damage<<FRACBITS, savedPercent),
2003                                 100*FRACUNIT);
2004                         if(saved > savedPercent*2)
2005                         {       
2006                                 saved = savedPercent*2;
2007                         }
2008                         damage -= saved>>FRACBITS;
2009                 }
2010                 if(damage >= player->health
2011                         && ((gameskill == sk_baby) || deathmatch)
2012                         && !player->morphTics)
2013                 { // Try to use some inventory health
2014                         P_AutoUseHealth(player, damage-player->health+1);
2015                 }
2016                 player->health -= damage; // mirror mobj health here for Dave
2017                 if(player->health < 0)
2018                 {
2019                         player->health = 0;
2020                 }
2021                 player->attacker = source;
2022                 player->damagecount += damage; // add damage after armor / invuln
2023                 if(player->damagecount > 100)
2024                 {
2025                         player->damagecount = 100; // teleport stomp does 10k points...
2026                 }
2027                 temp = damage < 100 ? damage : 100;
2028                 if(player == &players[consoleplayer])
2029                 {
2030                         I_Tactile(40, 10, 40+temp*2);
2031                         SB_PaletteFlash(false);
2032                 }
2033         }
2034
2035         //
2036         // do the damage
2037         //
2038         target->health -= damage;
2039         if(target->health <= 0)
2040         { // Death
2041                 if(inflictor)
2042                 { // check for special fire damage or ice damage deaths
2043                         if(inflictor->flags2&MF2_FIREDAMAGE)
2044                         {
2045                                 if(player && !player->morphTics)
2046                                 { // Check for flame death
2047                                         if(target->health > -50 && damage > 25)
2048                                         {
2049                                                 target->flags2 |= MF2_FIREDAMAGE;
2050                                         }
2051                                 }
2052                                 else
2053                                 {
2054                                         target->flags2 |= MF2_FIREDAMAGE;
2055                                 }
2056                         }
2057                         else if(inflictor->flags2&MF2_ICEDAMAGE)
2058                         {
2059                                 target->flags2 |= MF2_ICEDAMAGE;
2060                         }
2061                 }
2062                 if(source && (source->type == MT_MINOTAUR))
2063                 { // Minotaur's kills go to his master
2064                         master = (mobj_t *)(source->special1);
2065                         // Make sure still alive and not a pointer to fighter head
2066                         if (master->player && (master->player->mo == master))
2067                         {
2068                                 source = master;
2069                         }
2070                 }
2071                 if(source && (source->player) &&
2072                         (source->player->readyweapon == WP_FOURTH))
2073                 {
2074                         // Always extreme death from fourth weapon
2075                         target->health = -5000;
2076                 }
2077                 P_KillMobj(source, target);
2078                 return;
2079         }
2080         if((P_Random() < target->info->painchance)
2081                 && !(target->flags&MF_SKULLFLY))
2082         {
2083                 if(inflictor && (inflictor->type >= MT_LIGHTNING_FLOOR
2084                         && inflictor->type <= MT_LIGHTNING_ZAP))
2085                 {
2086                         if(P_Random() < 96)
2087                         {
2088                                 target->flags |= MF_JUSTHIT; // fight back!
2089                                 P_SetMobjState(target, target->info->painstate);
2090                         }
2091                         else
2092                         { // "electrocute" the target
2093                                 target->frame |= FF_FULLBRIGHT;
2094                                 if(target->flags&MF_COUNTKILL && P_Random() < 128
2095                                 && !S_GetSoundPlayingInfo(target, SFX_PUPPYBEAT))
2096                                 {
2097                                         if ((target->type == MT_CENTAUR) ||
2098                                                 (target->type == MT_CENTAURLEADER) ||
2099                                                 (target->type == MT_ETTIN))
2100                                         {
2101                                                 S_StartSound(target, SFX_PUPPYBEAT);
2102                                         }
2103                                 }
2104                         }
2105                 }
2106                 else
2107                 {
2108                         target->flags |= MF_JUSTHIT; // fight back!
2109                         P_SetMobjState(target, target->info->painstate);        
2110                         if(inflictor && inflictor->type == MT_POISONCLOUD)
2111                         {
2112                                 if(target->flags&MF_COUNTKILL && P_Random() < 128
2113                                 && !S_GetSoundPlayingInfo(target, SFX_PUPPYBEAT))
2114                                 {
2115                                         if ((target->type == MT_CENTAUR) ||
2116                                                 (target->type == MT_CENTAURLEADER) ||
2117                                                 (target->type == MT_ETTIN))
2118                                         {
2119                                                 S_StartSound(target, SFX_PUPPYBEAT);
2120                                         }
2121                                 }
2122                         }
2123                 }
2124         }
2125         target->reactiontime = 0; // we're awake now...
2126         if(!target->threshold && source && !(source->flags2&MF2_BOSS)
2127                 && !(target->type == MT_BISHOP) && !(target->type == MT_MINOTAUR))
2128         {
2129                 // Target actor is not intent on another actor,
2130                 // so make him chase after source
2131                 if((target->type == MT_CENTAUR && source->type == MT_CENTAURLEADER)
2132                         || (target->type == MT_CENTAURLEADER 
2133                                 && source->type == MT_CENTAUR))
2134                 {
2135                         return;
2136                 }
2137                 target->target = source;
2138                 target->threshold = BASETHRESHOLD;
2139                 if(target->state == &states[target->info->spawnstate]
2140                         && target->info->seestate != S_NULL)
2141                 {
2142                         P_SetMobjState(target, target->info->seestate);
2143                 }
2144         }
2145 }
2146
2147 //==========================================================================
2148 //
2149 // P_FallingDamage
2150 //
2151 //==========================================================================
2152
2153 void P_FallingDamage(player_t *player)
2154 {
2155         int damage;
2156         int mom;
2157         int dist;
2158
2159         mom = abs(player->mo->momz);    
2160         dist = FixedMul(mom, 16*FRACUNIT/23);
2161
2162         if(mom >= 63*FRACUNIT)
2163         { // automatic death
2164                 P_DamageMobj(player->mo, NULL, NULL, 10000);
2165                 return;
2166         }
2167         damage = ((FixedMul(dist, dist)/10)>>FRACBITS)-24;
2168         if(player->mo->momz > -39*FRACUNIT && damage > player->mo->health
2169                 && player->mo->health != 1)
2170         { // No-death threshold
2171                 damage = player->mo->health-1;
2172         }
2173         S_StartSound(player->mo, SFX_PLAYER_LAND);
2174         P_DamageMobj(player->mo, NULL, NULL, damage);
2175 }
2176
2177 //==========================================================================
2178 //
2179 // P_PoisonPlayer - Sets up all data concerning poisoning
2180 //
2181 //==========================================================================
2182
2183 void P_PoisonPlayer(player_t *player, mobj_t *poisoner, int poison)
2184 {
2185         if((player->cheats&CF_GODMODE) || player->powers[pw_invulnerability])
2186         {
2187                 return;
2188         }
2189         player->poisoncount += poison;
2190         player->poisoner = poisoner;
2191         if(player->poisoncount > 100)
2192         {
2193                 player->poisoncount = 100;
2194         }
2195 }
2196
2197 //==========================================================================
2198 //
2199 // P_PoisonDamage - Similar to P_DamageMobj
2200 //
2201 //==========================================================================
2202
2203 void P_PoisonDamage(player_t *player, mobj_t *source, int damage,
2204         boolean playPainSound)
2205 {
2206         mobj_t *target;
2207         mobj_t *inflictor;
2208
2209         target = player->mo;
2210         inflictor = source;
2211         if(target->health <= 0)
2212         {
2213                 return;
2214         }
2215         if(target->flags2&MF2_INVULNERABLE && damage < 10000)
2216         { // mobj is invulnerable
2217                 return;
2218         }
2219         if(player && gameskill == sk_baby)
2220         {
2221                 // Take half damage in trainer mode
2222                 damage >>= 1;
2223         }
2224         if(damage < 1000 && ((player->cheats&CF_GODMODE)
2225                 || player->powers[pw_invulnerability]))
2226         {
2227                 return;
2228         }
2229         if(damage >= player->health
2230                 && ((gameskill == sk_baby) || deathmatch)
2231                 && !player->morphTics)
2232         { // Try to use some inventory health
2233                 P_AutoUseHealth(player, damage-player->health+1);
2234         }
2235         player->health -= damage; // mirror mobj health here for Dave
2236         if(player->health < 0)
2237         {
2238                 player->health = 0;
2239         }
2240         player->attacker = source;
2241
2242         //
2243         // do the damage
2244         //
2245         target->health -= damage;
2246         if(target->health <= 0)
2247         { // Death
2248                 target->special1 = damage;
2249                 if(player && inflictor && !player->morphTics)
2250                 { // Check for flame death
2251                         if((inflictor->flags2&MF2_FIREDAMAGE)
2252                                 && (target->health > -50) && (damage > 25))
2253                         {
2254                                 target->flags2 |= MF2_FIREDAMAGE;
2255                         }
2256                         if(inflictor->flags2&MF2_ICEDAMAGE)
2257                         {
2258                                 target->flags2 |= MF2_ICEDAMAGE;
2259                         }
2260                 }
2261                 P_KillMobj(source, target);
2262                 return;
2263         }
2264         if(!(leveltime&63) && playPainSound)
2265         {
2266                 P_SetMobjState(target, target->info->painstate);
2267         }
2268 /*
2269         if((P_Random() < target->info->painchance)
2270                 && !(target->flags&MF_SKULLFLY))
2271         {
2272                 target->flags |= MF_JUSTHIT; // fight back!
2273                 P_SetMobjState(target, target->info->painstate);
2274         }
2275 */
2276 }