osezer patch 001
[theoddone33/hhexen.git] / base / p_user.c
1
2 //**************************************************************************
3 //**
4 //** p_user.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 void P_PlayerNextArtifact(player_t *player);
18
19 // Macros
20
21 #define MAXBOB 0x100000 // 16 pixels of bob
22
23 // Data
24
25 boolean onground;
26 int newtorch; // used in the torch flicker effect.
27 int newtorchdelta;
28
29 int PStateNormal[NUMCLASSES] = 
30 {
31         S_FPLAY,
32         S_CPLAY,
33         S_MPLAY,
34 #ifdef ASSASSIN
35         S_APLAY,
36 #endif
37         S_PIGPLAY
38 };
39
40 int PStateRun[NUMCLASSES] = 
41 {
42         S_FPLAY_RUN1,
43         S_CPLAY_RUN1,
44         S_MPLAY_RUN1,
45 #ifdef ASSASSIN
46         S_APLAY_RUN1,
47 #endif
48         S_PIGPLAY_RUN1
49 };
50
51 int PStateAttack[NUMCLASSES] = 
52 {
53         S_FPLAY_ATK1,
54         S_CPLAY_ATK1,
55         S_MPLAY_ATK1,
56 #ifdef ASSASSIN
57         S_APLAY_ATK1,
58 #endif
59         S_PIGPLAY_ATK1
60 };
61
62 int PStateAttackEnd[NUMCLASSES] = 
63 {
64         S_FPLAY_ATK2,
65         S_CPLAY_ATK3,
66         S_MPLAY_ATK2,
67 #ifdef ASSASSIN
68         S_APLAY_ATK3,
69 #endif
70         S_PIGPLAY_ATK1  
71 };
72
73 int ArmorMax[NUMCLASSES] = { 20, 18, 16,
74 #ifdef ASSASSIN
75                                         17,
76 #endif
77                                         1 };
78
79 /*
80 ==================
81 =
82 = P_Thrust
83 =
84 = moves the given origin along a given angle
85 =
86 ==================
87 */
88
89 void P_Thrust(player_t *player, angle_t angle, fixed_t move)
90 {
91         angle >>= ANGLETOFINESHIFT;
92         if(player->powers[pw_flight] && !(player->mo->z <= player->mo->floorz))
93         {
94                 player->mo->momx += FixedMul(move, finecosine[angle]);
95                 player->mo->momy += FixedMul(move, finesine[angle]);
96         }
97         else if(P_GetThingFloorType(player->mo) == FLOOR_ICE) // Friction_Low
98         {
99                 player->mo->momx += FixedMul(move>>1, finecosine[angle]);
100                 player->mo->momy += FixedMul(move>>1, finesine[angle]);
101         }
102         else
103         {
104                 player->mo->momx += FixedMul(move, finecosine[angle]);
105                 player->mo->momy += FixedMul(move, finesine[angle]);
106         }
107 }
108
109
110 /*
111 ==================
112 =
113 = P_CalcHeight
114 =
115 =
116 Calculate the walking / running height adjustment
117 =
118 ==================
119 */
120
121 void P_CalcHeight (player_t *player)
122 {
123         int             angle;
124         fixed_t bob;
125
126 //
127 // regular movement bobbing (needs to be calculated for gun swing even
128 // if not on ground)
129 // OPTIMIZE: tablify angle
130
131         player->bob = FixedMul (player->mo->momx, player->mo->momx)+
132         FixedMul (player->mo->momy,player->mo->momy);
133         player->bob >>= 2;
134         if (player->bob>MAXBOB)
135                 player->bob = MAXBOB;
136         if(player->mo->flags2&MF2_FLY && !onground)
137         {
138                 player->bob = FRACUNIT/2;
139         }       
140         
141         if ((player->cheats & CF_NOMOMENTUM))
142         {
143                 player->viewz = player->mo->z + VIEWHEIGHT;
144                 if (player->viewz > player->mo->ceilingz-4*FRACUNIT)
145                         player->viewz = player->mo->ceilingz-4*FRACUNIT;
146                 player->viewz = player->mo->z + player->viewheight;
147                 return;
148         }
149
150         angle = (FINEANGLES/20*leveltime)&FINEMASK;
151         bob = FixedMul ( player->bob/2, finesine[angle]);
152
153 //
154 // move viewheight
155 //
156         if (player->playerstate == PST_LIVE)
157         {
158                 player->viewheight += player->deltaviewheight;
159                 if (player->viewheight > VIEWHEIGHT)
160                 {
161                         player->viewheight = VIEWHEIGHT;
162                         player->deltaviewheight = 0;
163                 }
164                 if (player->viewheight < VIEWHEIGHT/2)
165                 {
166                         player->viewheight = VIEWHEIGHT/2;
167                         if (player->deltaviewheight <= 0)
168                                 player->deltaviewheight = 1;
169                 }
170
171                 if (player->deltaviewheight)
172                 {
173                         player->deltaviewheight += FRACUNIT/4;
174                         if (!player->deltaviewheight)
175                                 player->deltaviewheight = 1;
176                 }
177         }
178
179         if(player->morphTics)
180         {
181                 player->viewz = player->mo->z+player->viewheight-(20*FRACUNIT);
182         }
183         else
184         {
185                 player->viewz = player->mo->z+player->viewheight+bob;
186         }
187         if(player->mo->floorclip && player->playerstate != PST_DEAD
188                 && player->mo->z <= player->mo->floorz)
189         {
190                 player->viewz -= player->mo->floorclip;
191         }
192         if(player->viewz > player->mo->ceilingz-4*FRACUNIT)
193         {
194                 player->viewz = player->mo->ceilingz-4*FRACUNIT;
195         }
196         if(player->viewz < player->mo->floorz+4*FRACUNIT)
197         {
198                 player->viewz = player->mo->floorz+4*FRACUNIT;
199         }
200 }
201
202 /*
203 =================
204 =
205 = P_MovePlayer
206 =
207 =================
208 */
209
210 void P_MovePlayer(player_t *player)
211 {
212         int look;
213         int fly;
214         ticcmd_t *cmd;
215
216         cmd = &player->cmd;
217         player->mo->angle += (cmd->angleturn<<16);
218
219         onground = (player->mo->z <= player->mo->floorz
220                 || (player->mo->flags2&MF2_ONMOBJ));
221
222         if(cmd->forwardmove)
223         {
224                 if(onground || player->mo->flags2&MF2_FLY)
225                 {
226                         P_Thrust(player, player->mo->angle, cmd->forwardmove*2048);
227                 }
228                 else
229                 {
230                         P_Thrust(player, player->mo->angle, FRACUNIT>>8);
231                 }
232         }       
233         if(cmd->sidemove)
234         {
235                 if(onground || player->mo->flags2&MF2_FLY)
236                         {
237                         P_Thrust(player, player->mo->angle-ANG90, cmd->sidemove*2048);
238                 }
239                 else
240                 {
241                         P_Thrust(player, player->mo->angle, FRACUNIT>>8);
242                 }
243         }
244         if(cmd->forwardmove || cmd->sidemove)
245         {
246                 if(player->mo->state == &states[PStateNormal[player->class]])
247                 {
248                         P_SetMobjState(player->mo, PStateRun[player->class]);
249                 }
250         }
251
252         look = cmd->lookfly&15;
253         if(look > 7)
254         {
255                 look -= 16;
256         }
257         if(look)
258         {
259                 if(look == TOCENTER)
260                 {
261                         player->centering = true;
262                 }
263                 else
264                 {
265                         player->lookdir += 5*look;
266                         if(player->lookdir > 90 || player->lookdir < -110)
267                         {
268                                 player->lookdir -= 5*look;
269                         }
270                 }
271         }
272         if(player->centering)
273         {
274                 if(player->lookdir > 0)
275                 {
276                         player->lookdir -= 8;
277                 }
278                 else if(player->lookdir < 0)
279                 {
280                         player->lookdir += 8;
281                 }
282                 if(abs(player->lookdir) < 8)
283                 {
284                         player->lookdir = 0;
285                         player->centering = false;
286                 }
287         }
288         fly = cmd->lookfly>>4;
289         if(fly > 7)
290         {
291                 fly -= 16;
292         }
293         if(fly && player->powers[pw_flight])
294         {
295                 if(fly != TOCENTER)
296                 {
297                         player->flyheight = fly*2;
298                         if(!(player->mo->flags2&MF2_FLY))
299                         {
300                                 player->mo->flags2 |= MF2_FLY;
301                                 player->mo->flags |= MF_NOGRAVITY;
302                                 if(player->mo->momz <= -39*FRACUNIT)
303                                 { // stop falling scream
304                                         S_StopSound(player->mo);
305                                 }
306                         }
307                 }
308                 else
309                 {
310                         player->mo->flags2 &= ~MF2_FLY;
311                         player->mo->flags &= ~MF_NOGRAVITY;
312                 }
313         }
314         else if(fly > 0)
315         {
316                 P_PlayerUseArtifact(player, arti_fly);
317         }
318         if(player->mo->flags2&MF2_FLY)
319         {
320                 player->mo->momz = player->flyheight*FRACUNIT;
321                 if(player->flyheight)
322                 {
323                         player->flyheight /= 2;
324                 }
325         }
326 }
327
328 //==========================================================================
329 //
330 // P_DeathThink
331 //
332 //==========================================================================
333
334 void P_DeathThink(player_t *player)
335 {
336         int dir;
337         angle_t delta;
338         int lookDelta;
339         extern int inv_ptr;
340         extern int curpos;
341
342         P_MovePsprites(player);
343
344         onground = (player->mo->z <= player->mo->floorz);
345         if(player->mo->type == MT_BLOODYSKULL || player->mo->type == MT_ICECHUNK)
346         { // Flying bloody skull or flying ice chunk
347                 player->viewheight = 6*FRACUNIT;
348                 player->deltaviewheight = 0;
349                 //player->damagecount = 20;
350                 if(onground)
351                 {
352                         if(player->lookdir < 60)
353                         {
354                                 lookDelta = (60-player->lookdir)/8;
355                                 if(lookDelta < 1 && (leveltime&1))
356                                 {
357                                         lookDelta = 1;
358                                 }
359                                 else if(lookDelta > 6)
360                                 {
361                                         lookDelta = 6;
362                                 }
363                                 player->lookdir += lookDelta;
364                         }
365                 }
366         }
367         else if(!(player->mo->flags2&MF2_ICEDAMAGE))
368         { // Fall to ground (if not frozen)
369                 player->deltaviewheight = 0;
370                 if(player->viewheight > 6*FRACUNIT)
371                 {
372                         player->viewheight -= FRACUNIT;
373                 }
374                 if(player->viewheight < 6*FRACUNIT)
375                 {
376                         player->viewheight = 6*FRACUNIT;
377                 }
378                 if(player->lookdir > 0)
379                 {
380                         player->lookdir -= 6;
381                 }
382                 else if(player->lookdir < 0)
383                 {
384                         player->lookdir += 6;
385                 }
386                 if(abs(player->lookdir) < 6)
387                 {
388                         player->lookdir = 0;
389                 }
390         }
391         P_CalcHeight(player);
392
393         if(player->attacker && player->attacker != player->mo)
394         { // Watch killer
395                 dir = P_FaceMobj(player->mo, player->attacker, &delta);
396                 if(delta < ANGLE_1*10)
397                 { // Looking at killer, so fade damage and poison counters
398                         if(player->damagecount)
399                         {
400                                 player->damagecount--;
401                         }
402                         if(player->poisoncount)
403                         {
404                                 player->poisoncount--;
405                         }
406                 }
407                 delta = delta/8;
408                 if(delta > ANGLE_1*5)
409                 {
410                         delta = ANGLE_1*5;
411                 }
412                 if(dir)
413                 { // Turn clockwise
414                         player->mo->angle += delta;
415                 }
416                 else
417                 { // Turn counter clockwise
418                         player->mo->angle -= delta;
419                 }
420         }
421         else if(player->damagecount || player->poisoncount)
422         {
423                 if(player->damagecount)
424                 {
425                         player->damagecount--;
426                 }
427                 else
428                 {
429                         player->poisoncount--;
430                 }
431         }
432
433         if(player->cmd.buttons&BT_USE)
434         {
435                 if(player == &players[consoleplayer])
436                 {
437                         I_SetPalette((byte *)W_CacheLumpName("PLAYPAL", PU_CACHE));
438                         inv_ptr = 0;
439                         curpos = 0;
440                         newtorch = 0;
441                         newtorchdelta = 0;
442                 }
443                 player->playerstate = PST_REBORN;
444                 player->mo->special1 = player->class;
445                 if(player->mo->special1 > 2)
446                 {
447                         player->mo->special1 = 0;
448                 }
449                 // Let the mobj know the player has entered the reborn state.  Some
450                 // mobjs need to know when it's ok to remove themselves.
451                 player->mo->special2 = 666;
452         }
453 }
454
455 //----------------------------------------------------------------------------
456 //
457 // PROC P_MorphPlayerThink
458 //
459 //----------------------------------------------------------------------------
460
461 void P_MorphPlayerThink(player_t *player)
462 {
463         mobj_t *pmo;
464
465         if(player->morphTics&15)
466         {
467                 return;
468         }
469         pmo = player->mo;
470         if(!(pmo->momx+pmo->momy) && P_Random() < 64)
471         { // Snout sniff
472                 P_SetPspriteNF(player, ps_weapon, S_SNOUTATK2);
473                 S_StartSound(pmo, SFX_PIG_ACTIVE1); // snort
474                 return;
475         }
476         if(P_Random() < 48)
477         {
478                 if(P_Random() < 128)
479                 {
480                         S_StartSound(pmo, SFX_PIG_ACTIVE1);
481                 }
482                 else
483                 {
484                         S_StartSound(pmo, SFX_PIG_ACTIVE2);
485                 }
486         }               
487 }
488
489 //----------------------------------------------------------------------------
490 //
491 // FUNC P_GetPlayerNum
492 //
493 //----------------------------------------------------------------------------
494
495 int P_GetPlayerNum(player_t *player)
496 {
497         int i;
498
499         for(i = 0; i < MAXPLAYERS; i++)
500         {
501                 if(player == &players[i])
502                 {
503                         return(i);
504                 }
505         }
506         return(0);
507 }
508
509 //----------------------------------------------------------------------------
510 //
511 // FUNC P_UndoPlayerMorph
512 //
513 //----------------------------------------------------------------------------
514
515 boolean P_UndoPlayerMorph(player_t *player)
516 {
517         mobj_t *fog;
518         mobj_t *mo;
519         mobj_t *pmo;
520         fixed_t x;
521         fixed_t y;
522         fixed_t z;
523         angle_t angle;
524         int playerNum;
525         weapontype_t weapon;
526         int oldFlags;
527         int oldFlags2;
528         int oldBeast;
529
530         pmo = player->mo;
531         x = pmo->x;
532         y = pmo->y;
533         z = pmo->z;
534         angle = pmo->angle;
535         weapon = pmo->special1;
536         oldFlags = pmo->flags;
537         oldFlags2 = pmo->flags2;
538         oldBeast = pmo->type;
539         P_SetMobjState(pmo, S_FREETARGMOBJ);
540         playerNum = P_GetPlayerNum(player);
541         switch(PlayerClass[playerNum])
542         {
543                 case PCLASS_FIGHTER:
544                         mo = P_SpawnMobj(x, y, z, MT_PLAYER_FIGHTER);
545                         break;
546                 case PCLASS_CLERIC:
547                         mo = P_SpawnMobj(x, y, z, MT_PLAYER_CLERIC);
548                         break;
549                 case PCLASS_MAGE:
550                         mo = P_SpawnMobj(x, y, z, MT_PLAYER_MAGE);
551                         break;
552 #ifdef ASSASSIN
553                 case PCLASS_ASS:
554                         mo = P_SpawnMobj(x, y, z, MT_PLAYER_ASS);
555                         break;
556 #endif
557                 default:
558                         I_Error("P_UndoPlayerMorph:  Unknown player class %d\n", 
559                                 player->class);
560                         /* jim never happens but keeps gcc happy */
561                         mo = NULL;
562                         break;
563         }
564         if(P_TestMobjLocation(mo) == false)
565         { // Didn't fit
566                 P_RemoveMobj(mo);
567                 mo = P_SpawnMobj(x, y, z, oldBeast);
568                 mo->angle = angle;
569                 mo->health = player->health;
570                 mo->special1 = weapon;
571                 mo->player = player;
572                 mo->flags = oldFlags;
573                 mo->flags2 = oldFlags2;
574                 player->mo = mo;
575                 player->morphTics = 2*35;
576                 return(false);
577         }
578         if(player->class == PCLASS_FIGHTER)
579         { 
580                 // The first type should be blue, and the third should be the
581                 // Fighter's original gold color
582                 if(playerNum == 0)
583                 {
584                         mo->flags |= 2<<MF_TRANSSHIFT;
585                 }
586                 else if(playerNum != 2)
587                 {
588                         mo->flags |= playerNum<<MF_TRANSSHIFT;
589                 }
590         }
591         else if(playerNum)
592         { // Set color translation bits for player sprites
593                 mo->flags |= playerNum<<MF_TRANSSHIFT;
594         }
595         mo->angle = angle;
596         mo->player = player;
597         mo->reactiontime = 18;
598         if(oldFlags2&MF2_FLY)
599         {
600                 mo->flags2 |= MF2_FLY;
601                 mo->flags |= MF_NOGRAVITY;
602         }
603         player->morphTics = 0;
604         player->health = mo->health = MAXHEALTH;
605         player->mo = mo;
606         player->class = PlayerClass[playerNum];
607         angle >>= ANGLETOFINESHIFT;
608         fog = P_SpawnMobj(x+20*finecosine[angle],
609                 y+20*finesine[angle], z+TELEFOGHEIGHT, MT_TFOG);
610         S_StartSound(fog, SFX_TELEPORT);
611         P_PostMorphWeapon(player, weapon);
612         return(true);
613 }
614
615
616 //----------------------------------------------------------------------------
617 //
618 // PROC P_PlayerThink
619 //
620 //----------------------------------------------------------------------------
621
622 void P_PlayerThink(player_t *player)
623 {
624         ticcmd_t *cmd;
625         weapontype_t newweapon;
626         int floorType;          
627         mobj_t *pmo;            
628         
629         // No-clip cheat
630         if(player->cheats&CF_NOCLIP)
631         {
632                 player->mo->flags |= MF_NOCLIP;
633         }
634         else
635         {
636                 player->mo->flags &= ~MF_NOCLIP;
637         }
638         cmd = &player->cmd;
639         if(player->mo->flags&MF_JUSTATTACKED)
640         { // Gauntlets attack auto forward motion
641                 cmd->angleturn = 0;
642                 cmd->forwardmove = 0xc800/512;
643                 cmd->sidemove = 0;
644                 player->mo->flags &= ~MF_JUSTATTACKED;
645         }
646 // messageTics is above the rest of the counters so that messages will 
647 //              go away, even in death.
648         player->messageTics--; // Can go negative
649         if(!player->messageTics || player->messageTics == -1)
650         { // Refresh the screen when a message goes away
651                 player->ultimateMessage = false; // clear out any chat messages.
652                 player->yellowMessage = false;
653                 if(player == &players[consoleplayer])
654                 {
655                         BorderTopRefresh = true;
656                 }
657         }
658         player->worldTimer++;
659         if(player->playerstate == PST_DEAD)
660         {
661                 P_DeathThink(player);
662                 return;
663         }
664         if(player->jumpTics)
665         {
666                 player->jumpTics--;
667         }
668         if(player->morphTics)
669         {
670                 P_MorphPlayerThink(player);
671         }
672         // Handle movement
673         if(player->mo->reactiontime)
674         { // Player is frozen
675                 player->mo->reactiontime--;
676         }
677         else
678         {
679                 P_MovePlayer(player);
680                 pmo = player->mo;
681                 if(player->powers[pw_speed] && !(leveltime&1)
682                         && P_AproxDistance(pmo->momx, pmo->momy) > 12*FRACUNIT)
683                 {
684                         mobj_t *speedMo;
685                         int playerNum;
686
687                         speedMo = P_SpawnMobj(pmo->x, pmo->y, pmo->z, MT_PLAYER_SPEED);
688                         if(speedMo)
689                         {
690                                 speedMo->angle = pmo->angle;
691                                 playerNum = P_GetPlayerNum(player);
692                                 if(player->class == PCLASS_FIGHTER)
693                                 { 
694                                         // The first type should be blue, and the 
695                                         // third should be the Fighter's original gold color
696                                         if(playerNum == 0)
697                                         {
698                                                 speedMo->flags |= 2<<MF_TRANSSHIFT;
699                                         }
700                                         else if(playerNum != 2)
701                                         {
702                                                 speedMo->flags |= playerNum<<MF_TRANSSHIFT;
703                                         }
704                                 }
705                                 else if(playerNum)
706                                 { // Set color translation bits for player sprites
707                                         speedMo->flags |= playerNum<<MF_TRANSSHIFT;
708                                 }
709                                 speedMo->target = pmo;
710                                 speedMo->special1 = player->class;
711                                 if(speedMo->special1 > 2)
712                                 {
713                                         speedMo->special1 = 0;
714                                 }
715                                 speedMo->sprite = pmo->sprite;
716                                 speedMo->floorclip = pmo->floorclip;
717                                 if(player == &players[consoleplayer])
718                                 {
719                                         speedMo->flags2 |= MF2_DONTDRAW;
720                                 }
721                         }
722                 }
723         }
724         P_CalcHeight(player);
725         if(player->mo->subsector->sector->special)
726         {
727                 P_PlayerInSpecialSector(player);
728         }
729         if((floorType = P_GetThingFloorType(player->mo)) != FLOOR_SOLID)
730         {
731                 P_PlayerOnSpecialFlat(player, floorType);
732         }
733         switch(player->class)
734         {
735                 case PCLASS_FIGHTER:
736                         if(player->mo->momz <= -35*FRACUNIT 
737                                 && player->mo->momz >= -40*FRACUNIT && !player->morphTics
738                                 && !S_GetSoundPlayingInfo(player->mo,
739                                 SFX_PLAYER_FIGHTER_FALLING_SCREAM))
740                                 {
741                                         S_StartSound(player->mo, 
742                                                 SFX_PLAYER_FIGHTER_FALLING_SCREAM);
743                                 }
744                         break;
745                 case PCLASS_CLERIC:
746                         if(player->mo->momz <= -35*FRACUNIT 
747                                 && player->mo->momz >= -40*FRACUNIT && !player->morphTics
748                                 && !S_GetSoundPlayingInfo(player->mo,
749                                 SFX_PLAYER_CLERIC_FALLING_SCREAM))
750                                 {
751                                         S_StartSound(player->mo, 
752                                                 SFX_PLAYER_CLERIC_FALLING_SCREAM);
753                                 }
754                         break;
755                 case PCLASS_MAGE:
756                         if(player->mo->momz <= -35*FRACUNIT 
757                                 && player->mo->momz >= -40*FRACUNIT && !player->morphTics
758                                 && !S_GetSoundPlayingInfo(player->mo,
759                                 SFX_PLAYER_MAGE_FALLING_SCREAM))
760                                 {
761                                         S_StartSound(player->mo, 
762                                                 SFX_PLAYER_MAGE_FALLING_SCREAM);
763                                 }
764 #ifdef ASSASSIN
765                 case PCLASS_ASS:
766                         if(player->mo->momz <= -35*FRACUNIT 
767                                 && player->mo->momz >= -40*FRACUNIT && !player->morphTics
768                                 && !S_GetSoundPlayingInfo(player->mo,
769                                 SFX_PLAYER_MAGE_FALLING_SCREAM))
770                                 {
771                                         S_StartSound(player->mo, 
772                                                 SFX_PLAYER_MAGE_FALLING_SCREAM);
773                                 }
774                         break;
775 #endif
776                 default:
777                         break;
778         }
779         if(cmd->arti)
780         { // Use an artifact
781                 if((cmd->arti&AFLAG_JUMP) && onground && !player->jumpTics)
782                 {
783                         if(player->morphTics)
784                         {
785                                 player->mo->momz = 6*FRACUNIT;
786                         }
787                         else 
788                         {
789                                 player->mo->momz = 9*FRACUNIT;
790                         }
791                         player->mo->flags2 &= ~MF2_ONMOBJ;
792                         player->jumpTics = 18; 
793                 }
794                 else if(cmd->arti&AFLAG_SUICIDE)
795                 {
796                         P_DamageMobj(player->mo, NULL, NULL, 10000);
797                 }
798                 if(cmd->arti == NUMARTIFACTS)
799                 { // use one of each artifact (except puzzle artifacts)
800                         int i;
801
802                         for(i = 1; i < arti_firstpuzzitem; i++)
803                         {
804                                 P_PlayerUseArtifact(player, i);
805                         }
806                 }
807                 else
808                 {
809                         P_PlayerUseArtifact(player, cmd->arti&AFLAG_MASK);
810                 }
811         }
812         // Check for weapon change
813         if(cmd->buttons&BT_SPECIAL)
814         { // A special event has no other buttons
815                 cmd->buttons = 0;
816         }
817         if(cmd->buttons&BT_CHANGE && !player->morphTics)
818         {
819                 // The actual changing of the weapon is done when the weapon
820                 // psprite can do it (A_WeaponReady), so it doesn't happen in
821                 // the middle of an attack.
822                 newweapon = (cmd->buttons&BT_WEAPONMASK)>>BT_WEAPONSHIFT;
823                 if(player->weaponowned[newweapon]
824                         && newweapon != player->readyweapon)
825                 {
826                         player->pendingweapon = newweapon;
827                 }
828         }
829         // Check for use
830         if(cmd->buttons&BT_USE)
831         {
832                 if(!player->usedown)
833                 {
834                         P_UseLines(player);
835                         player->usedown = true;
836                 }
837         }
838         else
839         {
840                 player->usedown = false;
841         }
842         // Morph counter
843         if(player->morphTics)
844         {
845                 if(!--player->morphTics)
846                 { // Attempt to undo the pig
847                         P_UndoPlayerMorph(player);
848                 }
849         }
850         // Cycle psprites
851         P_MovePsprites(player);
852         // Other Counters
853         if(player->powers[pw_invulnerability])
854         {
855                 if(player->class == PCLASS_CLERIC)
856                 {
857                         if(!(leveltime&7) && player->mo->flags&MF_SHADOW
858                                 && !(player->mo->flags2&MF2_DONTDRAW))
859                         {
860                                 player->mo->flags &= ~MF_SHADOW;
861                                 if(!(player->mo->flags&MF_ALTSHADOW))
862                                 {
863                                         player->mo->flags2 |= MF2_DONTDRAW|MF2_NONSHOOTABLE;
864                                 }
865                         }
866                         if(!(leveltime&31))
867                         {
868                                 if(player->mo->flags2&MF2_DONTDRAW)
869                                 {
870                                         if(!(player->mo->flags&MF_SHADOW))
871                                         {
872                                                 player->mo->flags |= MF_SHADOW|MF_ALTSHADOW;
873                                         }
874                                         else
875                                         {
876                                                 player->mo->flags2 &= ~(MF2_DONTDRAW|MF2_NONSHOOTABLE);
877                                         }
878                                 }
879                                 else
880                                 {
881                                         player->mo->flags |= MF_SHADOW;
882                                         player->mo->flags &= ~MF_ALTSHADOW;
883                                 }
884                         }               
885                 }
886                 if(!(--player->powers[pw_invulnerability]))
887                 {
888                         player->mo->flags2 &= ~(MF2_INVULNERABLE|MF2_REFLECTIVE);
889                         if(player->class == PCLASS_CLERIC)
890                         {
891                                 player->mo->flags2 &= ~(MF2_DONTDRAW|MF2_NONSHOOTABLE);
892                                 player->mo->flags &= ~(MF_SHADOW|MF_ALTSHADOW);
893                         }
894                 }
895         }
896         if(player->powers[pw_minotaur])
897         {
898                 player->powers[pw_minotaur]--;
899         }
900         if(player->powers[pw_infrared])
901         {
902                 player->powers[pw_infrared]--;
903         }
904         if(player->powers[pw_flight] && netgame)
905         {
906                 if(!--player->powers[pw_flight])
907                 {
908 //                      if(player->mo->z != player->mo->floorz) { }
909                         player->mo->flags2 &= ~MF2_FLY;
910                         player->mo->flags &= ~MF_NOGRAVITY;
911                         BorderTopRefresh = true; //make sure the sprite's cleared out
912                 }
913         }
914         if(player->powers[pw_speed])
915         {
916                 player->powers[pw_speed]--;
917         }
918         if(player->damagecount)
919         {
920                 player->damagecount--;
921         }
922         if(player->bonuscount)
923         {
924                 player->bonuscount--;
925         }
926         if(player->poisoncount && !(leveltime&15))
927         {
928                 player->poisoncount -= 5;
929                 if(player->poisoncount < 0)
930                 {
931                         player->poisoncount = 0;
932                 }
933                 P_PoisonDamage(player, player->poisoner, 1, true); 
934         }
935         // Colormaps
936 //      if(player->powers[pw_invulnerability])
937 //      {
938 //              if(player->powers[pw_invulnerability] > BLINKTHRESHOLD
939 //                      || (player->powers[pw_invulnerability]&8))
940 //              {
941 //                      player->fixedcolormap = INVERSECOLORMAP;
942 //              }
943 //              else
944 //              {
945 //                      player->fixedcolormap = 0;
946 //              }
947 //      }
948 //      else 
949         if(player->powers[pw_infrared])
950         {
951                 if (player->powers[pw_infrared] <= BLINKTHRESHOLD)
952                 {
953                         if(player->powers[pw_infrared]&8)
954                         {
955                                 player->fixedcolormap = 0;
956                         }
957                         else
958                         {
959                                 player->fixedcolormap = 1;
960                         }
961                 }
962                 else if(!(leveltime&16) && player == &players[consoleplayer])
963                 {
964                         if(newtorch)
965                         {
966                                 if(player->fixedcolormap+newtorchdelta > 7 
967                                         || player->fixedcolormap+newtorchdelta < 1
968                                         || newtorch == player->fixedcolormap)
969                                 {
970                                         newtorch = 0;
971                                 }
972                                 else
973                                 {
974                                         player->fixedcolormap += newtorchdelta;
975                                 }
976                         }
977                         else
978                         {
979                                 newtorch = (M_Random()&7)+1;
980                                 newtorchdelta = (newtorch == player->fixedcolormap) ?
981                                                 0 : ((newtorch > player->fixedcolormap) ? 1 : -1);
982                         }
983                 }
984         }
985         else
986         {
987                 player->fixedcolormap = 0;
988         }
989 }
990
991 //----------------------------------------------------------------------------
992 //
993 // PROC P_ArtiTele
994 //
995 //----------------------------------------------------------------------------
996
997 void P_ArtiTele(player_t *player)
998 {
999         int i;
1000         int selections;
1001         fixed_t destX;
1002         fixed_t destY;
1003         angle_t destAngle;
1004
1005         if(deathmatch)
1006         {
1007                 selections = deathmatch_p-deathmatchstarts;
1008                 i = P_Random()%selections;
1009                 destX = deathmatchstarts[i].x<<FRACBITS;
1010                 destY = deathmatchstarts[i].y<<FRACBITS;
1011                 destAngle = ANG45*(deathmatchstarts[i].angle/45);
1012         }
1013         else
1014         {
1015                 destX = playerstarts[0][0].x<<FRACBITS;
1016                 destY = playerstarts[0][0].y<<FRACBITS;
1017                 destAngle = ANG45*(playerstarts[0][0].angle/45);
1018         }
1019         P_Teleport(player->mo, destX, destY, destAngle, true);
1020         if(player->morphTics)
1021         { // Teleporting away will undo any morph effects (pig)
1022                 P_UndoPlayerMorph(player);
1023         }
1024         //S_StartSound(NULL, sfx_wpnup); // Full volume laugh
1025 }
1026
1027
1028 //----------------------------------------------------------------------------
1029 //
1030 // PROC P_ArtiTeleportOther
1031 //
1032 //----------------------------------------------------------------------------
1033
1034 void P_ArtiTeleportOther(player_t *player)
1035 {
1036         mobj_t *mo;
1037
1038         mo=P_SpawnPlayerMissile(player->mo, MT_TELOTHER_FX1);
1039         if (mo)
1040         {
1041                 mo->target = player->mo;
1042         }
1043 }
1044
1045
1046 void P_TeleportToPlayerStarts(mobj_t *victim)
1047 {
1048         int i,selections=0;
1049         fixed_t destX,destY;
1050         angle_t destAngle;
1051
1052         for (i=0;i<MAXPLAYERS;i++)
1053         {
1054             if (!playeringame[i]) continue;
1055                 selections++;
1056         }
1057         i = P_Random()%selections;
1058         destX = playerstarts[0][i].x<<FRACBITS;
1059         destY = playerstarts[0][i].y<<FRACBITS;
1060         destAngle = ANG45*(playerstarts[0][i].angle/45);
1061         P_Teleport(victim, destX, destY, destAngle, true);
1062         //S_StartSound(NULL, sfx_wpnup); // Full volume laugh
1063 }
1064
1065 void P_TeleportToDeathmatchStarts(mobj_t *victim)
1066 {
1067         int i,selections;
1068         fixed_t destX,destY;
1069         angle_t destAngle;
1070
1071         selections = deathmatch_p-deathmatchstarts;
1072         if (selections)
1073         {
1074                 i = P_Random()%selections;
1075                 destX = deathmatchstarts[i].x<<FRACBITS;
1076                 destY = deathmatchstarts[i].y<<FRACBITS;
1077                 destAngle = ANG45*(deathmatchstarts[i].angle/45);
1078                 P_Teleport(victim, destX, destY, destAngle, true);
1079                 //S_StartSound(NULL, sfx_wpnup); // Full volume laugh
1080         }
1081         else
1082         {
1083                 P_TeleportToPlayerStarts(victim);
1084         }
1085 }
1086
1087
1088
1089 //----------------------------------------------------------------------------
1090 //
1091 // PROC P_TeleportOther
1092 //
1093 //----------------------------------------------------------------------------
1094 void P_TeleportOther(mobj_t *victim)
1095 {
1096         if (victim->player)
1097         {
1098                 if (deathmatch)
1099                         P_TeleportToDeathmatchStarts(victim);
1100                 else
1101                         P_TeleportToPlayerStarts(victim);
1102         }
1103         else
1104         {
1105                 // If death action, run it upon teleport
1106                 if (victim->flags&MF_COUNTKILL && victim->special)
1107                 {
1108                         P_RemoveMobjFromTIDList(victim);
1109                         P_ExecuteLineSpecial(victim->special, victim->args,
1110                                         NULL, 0, victim);
1111                         victim->special = 0;
1112                 }
1113
1114                 // Send all monsters to deathmatch spots
1115                 P_TeleportToDeathmatchStarts(victim);
1116         }
1117 }
1118
1119
1120
1121 #define BLAST_RADIUS_DIST       255*FRACUNIT
1122 #define BLAST_SPEED                     20*FRACUNIT
1123 #define BLAST_FULLSTRENGTH      255
1124
1125 void ResetBlasted(mobj_t *mo)
1126 {
1127         mo->flags2 &= ~MF2_BLASTED;
1128         if (!(mo->flags&MF_ICECORPSE))
1129         {
1130                 mo->flags2 &= ~MF2_SLIDE;
1131         }
1132 }
1133
1134 void P_BlastMobj(mobj_t *source, mobj_t *victim, fixed_t strength)
1135 {
1136         angle_t angle,ang;
1137         mobj_t *mo;
1138         fixed_t x,y,z;
1139
1140         angle = R_PointToAngle2(source->x, source->y, victim->x, victim->y);
1141         angle >>= ANGLETOFINESHIFT;
1142         if (strength < BLAST_FULLSTRENGTH)
1143         {
1144                 victim->momx = FixedMul(strength, finecosine[angle]);
1145                 victim->momy = FixedMul(strength, finesine[angle]);
1146                 if (victim->player)
1147                 {
1148                         // Players handled automatically
1149                 }
1150                 else
1151                 {
1152                         victim->flags2 |= MF2_SLIDE;
1153                         victim->flags2 |= MF2_BLASTED;
1154                 }
1155         }
1156         else            // full strength blast from artifact
1157         {
1158                 if (victim->flags&MF_MISSILE)
1159                 {
1160                         switch(victim->type)
1161                         {
1162                                 case MT_SORCBALL1:      // don't blast sorcerer balls
1163                                 case MT_SORCBALL2:
1164                                 case MT_SORCBALL3:
1165                                         return;
1166                                         break;
1167                                 case MT_MSTAFF_FX2:     // Reflect to originator
1168                                         victim->special1 = (int)victim->target; 
1169                                         victim->target = source;
1170                                         break;
1171                                 default:
1172                                         break;
1173                         }
1174                 }
1175                 if (victim->type == MT_HOLY_FX)
1176                 {
1177                         if ((mobj_t *)(victim->special1) == source)
1178                         {
1179                                 victim->special1 = (int)victim->target; 
1180                                 victim->target = source;
1181                         }
1182                 }
1183                 victim->momx = FixedMul(BLAST_SPEED, finecosine[angle]);
1184                 victim->momy = FixedMul(BLAST_SPEED, finesine[angle]);
1185
1186                 // Spawn blast puff
1187                 ang = R_PointToAngle2(victim->x, victim->y, source->x, source->y);
1188                 ang >>= ANGLETOFINESHIFT;
1189                 x = victim->x + FixedMul(victim->radius+FRACUNIT, finecosine[ang]);
1190                 y = victim->y + FixedMul(victim->radius+FRACUNIT, finesine[ang]);
1191                 z = victim->z - victim->floorclip + (victim->height>>1);
1192                 mo=P_SpawnMobj(x, y, z, MT_BLASTEFFECT);
1193                 if (mo)
1194                 {
1195                         mo->momx = victim->momx;
1196                         mo->momy = victim->momy;
1197                 }
1198
1199                 if (victim->flags&MF_MISSILE)
1200                 {
1201                         victim->momz = 8*FRACUNIT;
1202                         mo->momz = victim->momz;
1203                 }
1204                 else
1205                 {
1206                         victim->momz = (1000/victim->info->mass)<<FRACBITS;
1207                 }
1208                 if (victim->player)
1209                 {
1210                         // Players handled automatically
1211                 }
1212                 else
1213                 {
1214                         victim->flags2 |= MF2_SLIDE;
1215                         victim->flags2 |= MF2_BLASTED;
1216                 }
1217         }
1218 }
1219
1220
1221 // Blast all mobj things away
1222 void P_BlastRadius(player_t *player)
1223 {
1224         mobj_t *mo;
1225         mobj_t *pmo=player->mo;
1226         thinker_t *think;
1227         fixed_t dist;
1228
1229         S_StartSound(pmo, SFX_ARTIFACT_BLAST);
1230         P_NoiseAlert(player->mo, player->mo);
1231
1232         for(think = thinkercap.next; think != &thinkercap; think = think->next)
1233         {
1234                 if(think->function != P_MobjThinker)
1235                 { // Not a mobj thinker
1236                         continue;
1237                 }
1238                 mo = (mobj_t *)think;
1239                 if((mo == pmo) || (mo->flags2&MF2_BOSS))
1240                 { // Not a valid monster
1241                         continue;
1242                 }
1243                 if ((mo->type == MT_POISONCLOUD) ||             // poison cloud
1244                         (mo->type == MT_HOLY_FX) ||                     // holy fx
1245                         (mo->flags&MF_ICECORPSE))                       // frozen corpse
1246                 {
1247                         // Let these special cases go
1248                 }
1249                 else if ((mo->flags&MF_COUNTKILL) &&
1250                         (mo->health <= 0))
1251                 {
1252                         continue;
1253                 }
1254                 else if (!(mo->flags&MF_COUNTKILL) &&
1255                         !(mo->player) &&
1256                         !(mo->flags&MF_MISSILE))
1257                 {       // Must be monster, player, or missile
1258                         continue;
1259                 }
1260                 if (mo->flags2&MF2_DORMANT)
1261                 {
1262                         continue;               // no dormant creatures
1263                 }
1264                 if ((mo->type == MT_WRAITHB) && (mo->flags2&MF2_DONTDRAW))
1265                 {
1266                         continue;               // no underground wraiths
1267                 }
1268                 if ((mo->type == MT_SPLASHBASE) ||
1269                         (mo->type == MT_SPLASH))
1270                 {
1271                         continue;
1272                 }
1273                 if(mo->type == MT_SERPENT || mo->type == MT_SERPENTLEADER)
1274                 {
1275                         continue;
1276                 }
1277                 dist = P_AproxDistance(pmo->x - mo->x, pmo->y - mo->y);
1278                 if(dist > BLAST_RADIUS_DIST)
1279                 { // Out of range
1280                         continue;
1281                 }
1282                 P_BlastMobj(pmo, mo, BLAST_FULLSTRENGTH);
1283         }
1284 }
1285
1286
1287 #define HEAL_RADIUS_DIST        255*FRACUNIT
1288
1289 // Do class specific effect for everyone in radius
1290 boolean P_HealRadius(player_t *player)
1291 {
1292         mobj_t *mo;
1293         mobj_t *pmo=player->mo;
1294         thinker_t *think;
1295         fixed_t dist;
1296         int effective=false;
1297         int amount;
1298
1299         for(think = thinkercap.next; think != &thinkercap; think = think->next)
1300         {
1301                 if(think->function != P_MobjThinker)
1302                 { // Not a mobj thinker
1303                         continue;
1304                 }
1305                 mo = (mobj_t *)think;
1306
1307                 if (!mo->player) continue;
1308                 if (mo->health <= 0) continue;
1309                 dist = P_AproxDistance(pmo->x - mo->x, pmo->y - mo->y);
1310                 if(dist > HEAL_RADIUS_DIST)
1311                 { // Out of range
1312                         continue;
1313                 }
1314
1315                 switch(player->class)
1316                 {
1317                         case PCLASS_FIGHTER:            // Radius armor boost
1318                                 if ((P_GiveArmor(mo->player, ARMOR_ARMOR, 1)) ||
1319                                         (P_GiveArmor(mo->player, ARMOR_SHIELD, 1)) ||
1320                                         (P_GiveArmor(mo->player, ARMOR_HELMET, 1)) ||
1321                                         (P_GiveArmor(mo->player, ARMOR_AMULET, 1)))
1322                                 {
1323                                         effective=true;
1324                                         S_StartSound(mo, SFX_MYSTICINCANT);
1325                                 }
1326                                 break;
1327                         case PCLASS_CLERIC:                     // Radius heal
1328                                 amount = 50 + (P_Random()%50);
1329                                 if (P_GiveBody(mo->player, amount))
1330                                 {
1331                                         effective=true;
1332                                         S_StartSound(mo, SFX_MYSTICINCANT);
1333                                 }
1334                                 break;
1335                         case PCLASS_MAGE:                       // Radius mana boost
1336                                 amount = 50 + (P_Random()%50);
1337                                 if ((P_GiveMana(mo->player, MANA_1, amount)) ||
1338                                         (P_GiveMana(mo->player, MANA_2, amount)))
1339                                 {
1340                                         effective=true;
1341                                         S_StartSound(mo, SFX_MYSTICINCANT);
1342                                 }
1343                                 break;
1344 #ifdef ASSASSIN
1345                         case PCLASS_ASS:                // Also Radius heal
1346                                 amount = 50 + (P_Random()%50);
1347                                 if (P_GiveBody(mo->player, amount))
1348                                 {
1349                                         effective=true;
1350                                         S_StartSound(mo, SFX_MYSTICINCANT);
1351                                 }
1352                                 break;
1353 #endif
1354                         case PCLASS_PIG:
1355                         default:
1356                                 break;
1357                 }
1358         }
1359         return(effective);
1360 }
1361
1362
1363 //----------------------------------------------------------------------------
1364 //
1365 // PROC P_PlayerNextArtifact
1366 //
1367 //----------------------------------------------------------------------------
1368
1369 void P_PlayerNextArtifact(player_t *player)
1370 {
1371         extern int inv_ptr;
1372         extern int curpos;
1373
1374         if(player == &players[consoleplayer])
1375         {
1376                 inv_ptr--;
1377                 if(inv_ptr < 6)
1378                 {
1379                         curpos--;
1380                         if(curpos < 0)
1381                         {
1382                                 curpos = 0;
1383                         }
1384                 }
1385                 if(inv_ptr < 0)
1386                 {
1387                         inv_ptr = player->inventorySlotNum-1;
1388                         if(inv_ptr < 6)
1389                         {
1390                                 curpos = inv_ptr;
1391                         }
1392                         else
1393                         {
1394                                 curpos = 6;
1395                         }
1396                 }
1397                 player->readyArtifact =
1398                         player->inventory[inv_ptr].type;
1399         }
1400 }
1401
1402 //----------------------------------------------------------------------------
1403 //
1404 // PROC P_PlayerRemoveArtifact
1405 //
1406 //----------------------------------------------------------------------------
1407
1408 void P_PlayerRemoveArtifact(player_t *player, int slot)
1409 {
1410         int i;
1411         extern int inv_ptr;
1412         extern int curpos;
1413
1414         player->artifactCount--;
1415         if(!(--player->inventory[slot].count))
1416         { // Used last of a type - compact the artifact list
1417                 player->readyArtifact = arti_none;
1418                 player->inventory[slot].type = arti_none;
1419                 for(i = slot+1; i < player->inventorySlotNum; i++)
1420                 {
1421                         player->inventory[i-1] = player->inventory[i];
1422                 }
1423                 player->inventorySlotNum--;
1424                 if(player == &players[consoleplayer])
1425                 { // Set position markers and get next readyArtifact
1426                         inv_ptr--;
1427                         if(inv_ptr < 6)
1428                         {
1429                                 curpos--;
1430                                 if(curpos < 0)
1431                                 {
1432                                         curpos = 0;
1433                                 }
1434                         }
1435                         if(inv_ptr >= player->inventorySlotNum)
1436                         {
1437                                 inv_ptr = player->inventorySlotNum-1;
1438                         }
1439                         if(inv_ptr < 0)
1440                         {
1441                                 inv_ptr = 0;
1442                         }
1443                         player->readyArtifact =
1444                                 player->inventory[inv_ptr].type;
1445                 }
1446         }
1447 }
1448
1449 //----------------------------------------------------------------------------
1450 //
1451 // PROC P_PlayerUseArtifact
1452 //
1453 //----------------------------------------------------------------------------
1454
1455 void P_PlayerUseArtifact(player_t *player, artitype_t arti)
1456 {
1457         int i;
1458
1459         for(i = 0; i < player->inventorySlotNum; i++)
1460         {
1461                 if(player->inventory[i].type == arti)
1462                 { // Found match - try to use
1463                         if(P_UseArtifact(player, arti))
1464                         { // Artifact was used - remove it from inventory
1465                                 P_PlayerRemoveArtifact(player, i);
1466                                 if(player == &players[consoleplayer])
1467                                 {
1468                                         if(arti < arti_firstpuzzitem)
1469                                         {
1470                                                 S_StartSound(NULL, SFX_ARTIFACT_USE);
1471                                         }
1472                                         else
1473                                         {
1474                                                 S_StartSound(NULL, SFX_PUZZLE_SUCCESS);
1475                                         }
1476                                         ArtifactFlash = 4;
1477                                 }
1478                         }
1479                         else if(arti < arti_firstpuzzitem)
1480                         { // Unable to use artifact, advance pointer
1481                                 P_PlayerNextArtifact(player);
1482                         }
1483                         break;
1484                 }
1485         }
1486 }
1487
1488 //==========================================================================
1489 //
1490 // P_UseArtifact
1491 //
1492 // Returns true if the artifact was used.
1493 //
1494 //==========================================================================
1495
1496 boolean P_UseArtifact(player_t *player, artitype_t arti)
1497 {
1498         mobj_t *mo;
1499         angle_t angle;
1500         int i;
1501         int count;
1502
1503         switch(arti)
1504         {
1505                 case arti_invulnerability:
1506                         if(!P_GivePower(player, pw_invulnerability))
1507                         {
1508                                 return(false);
1509                         }
1510                         break;
1511                 case arti_health:
1512                         if(!P_GiveBody(player, 25))
1513                         {
1514                                 return(false);
1515                         }
1516                         break;
1517                 case arti_superhealth:
1518                         if(!P_GiveBody(player, 100))
1519                         {
1520                                 return(false);
1521                         }
1522                         break;
1523                 case arti_healingradius:
1524                         if (!P_HealRadius(player))
1525                         {
1526                                 return(false);
1527                         }
1528                         break;
1529                 case arti_torch:
1530                         if(!P_GivePower(player, pw_infrared))
1531                         {
1532                                 return(false);
1533                         }
1534                         break;
1535                 case arti_egg:
1536                         mo = player->mo;
1537                         P_SpawnPlayerMissile(mo, MT_EGGFX);
1538                         P_SPMAngle(mo, MT_EGGFX, mo->angle-(ANG45/6));
1539                         P_SPMAngle(mo, MT_EGGFX, mo->angle+(ANG45/6));
1540                         P_SPMAngle(mo, MT_EGGFX, mo->angle-(ANG45/3));
1541                         P_SPMAngle(mo, MT_EGGFX, mo->angle+(ANG45/3));
1542                         break;
1543                 case arti_fly:
1544                         if(!P_GivePower(player, pw_flight))
1545                         {
1546                                 return(false);
1547                         }
1548                         if(player->mo->momz <= -35*FRACUNIT)
1549                         { // stop falling scream
1550                                 S_StopSound(player->mo);
1551                         }
1552                         break;
1553                 case arti_summon:
1554                         mo = P_SpawnPlayerMissile(player->mo, MT_SUMMON_FX);
1555                         if (mo)
1556                         {
1557                                 mo->target = player->mo;
1558                                 mo->special1 = (int)(player->mo);
1559                                 mo->momz = 5*FRACUNIT;
1560                         }
1561                         break;
1562                 case arti_teleport:
1563                         P_ArtiTele(player);
1564                         break;
1565                 case arti_teleportother:
1566                         P_ArtiTeleportOther(player);
1567                         break;
1568                 case arti_poisonbag:
1569                         angle = player->mo->angle>>ANGLETOFINESHIFT;
1570                         if(player->class == PCLASS_CLERIC)
1571                         {
1572                                 mo = P_SpawnMobj(player->mo->x+16*finecosine[angle],
1573                                         player->mo->y+24*finesine[angle], player->mo->z-
1574                                         player->mo->floorclip+8*FRACUNIT, MT_POISONBAG);
1575                                 if(mo)
1576                                 {
1577                                         mo->target = player->mo;
1578                                 }
1579                         }
1580                         else if(player->class == PCLASS_MAGE)
1581                         {
1582                                 mo = P_SpawnMobj(player->mo->x+16*finecosine[angle],
1583                                         player->mo->y+24*finesine[angle], player->mo->z-
1584                                         player->mo->floorclip+8*FRACUNIT, MT_FIREBOMB);
1585                                 if(mo)
1586                                 {
1587                                         mo->target = player->mo;
1588                                 }
1589                         }                       
1590                         else // PCLASS_FIGHTER, obviously (also pig, not so obviously)
1591                         {
1592                                 mo = P_SpawnMobj(player->mo->x, player->mo->y, 
1593                                         player->mo->z-player->mo->floorclip+35*FRACUNIT,
1594                                         MT_THROWINGBOMB);
1595                                 if(mo)
1596                                 {
1597                                         mo->angle = player->mo->angle+(((P_Random()&7)-4)<<24);
1598                                         mo->momz = 4*FRACUNIT+((player->lookdir)<<(FRACBITS-4));
1599                                         mo->z += player->lookdir<<(FRACBITS-4);
1600                                         P_ThrustMobj(mo, mo->angle, mo->info->speed);
1601                                         mo->momx += player->mo->momx>>1;
1602                                         mo->momy += player->mo->momy>>1;
1603                                         mo->target = player->mo;
1604                                         mo->tics -= P_Random()&3;
1605                                         P_CheckMissileSpawn(mo);                                                                                        
1606                                 } 
1607                         }
1608                         break;
1609                 case arti_speed:
1610                         if(!P_GivePower(player, pw_speed))
1611                         {
1612                                 return(false);
1613                         }
1614                         break;
1615                 case arti_boostmana:
1616                         if(!P_GiveMana(player, MANA_1, MAX_MANA))
1617                         {
1618                                 if(!P_GiveMana(player, MANA_2, MAX_MANA))
1619                                 {
1620                                         return false;
1621                                 }
1622                                 
1623                         }
1624                         else 
1625                         {
1626                                 P_GiveMana(player, MANA_2, MAX_MANA);
1627                         }
1628                         break;
1629                 case arti_boostarmor:
1630                         count = 0;
1631
1632                         for(i = 0; i < NUMARMOR; i++)
1633                         {
1634                                 count += P_GiveArmor(player, i, 1); // 1 point per armor type
1635                         }
1636                         if(!count)
1637                         {
1638                                 return false;
1639                         }
1640                         break;
1641                 case arti_blastradius:
1642                         P_BlastRadius(player);
1643                         break;
1644
1645                 case arti_puzzskull:
1646                 case arti_puzzgembig:
1647                 case arti_puzzgemred:
1648                 case arti_puzzgemgreen1:
1649                 case arti_puzzgemgreen2:
1650                 case arti_puzzgemblue1:
1651                 case arti_puzzgemblue2:
1652                 case arti_puzzbook1:
1653                 case arti_puzzbook2:
1654                 case arti_puzzskull2:
1655                 case arti_puzzfweapon:
1656                 case arti_puzzcweapon:
1657                 case arti_puzzmweapon:
1658                 case arti_puzzgear1:
1659                 case arti_puzzgear2:
1660                 case arti_puzzgear3:
1661                 case arti_puzzgear4:
1662                         if(P_UsePuzzleItem(player, arti-arti_firstpuzzitem))
1663                         {
1664                                 return true;
1665                         }
1666                         else
1667                         {
1668                                 P_SetYellowMessage(player, TXT_USEPUZZLEFAILED, false);
1669                                 return false;
1670                         }
1671                         break;
1672                 default:
1673                         return false;
1674         }
1675         return true;
1676 }
1677
1678 //============================================================================
1679 //
1680 // A_SpeedFade
1681 //
1682 //============================================================================
1683
1684 void A_SpeedFade(mobj_t *actor)
1685 {
1686         actor->flags |= MF_SHADOW;
1687         actor->flags &= ~MF_ALTSHADOW;
1688         actor->sprite = actor->target->sprite;
1689 }
1690