Games/Doom/p_lights.c

   1 // Emacs style mode select   -*- C++ -*-
   2 //-----------------------------------------------------------------------------
   3 //
   4 // $Id$
   5 //
   6 // Copyright (C) 1993-1996 by id Software, Inc.
   7 //
   8 // This source is available for distribution and/or modification
   9 // only under the terms of the DOOM Source Code License as
  10 // published by id Software. All rights reserved.
  11 //
  12 // The source is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15 // for more details.
  16 //
  17 // $Log$
  18 // Revision 1.1  2000/02/29 18:21:04  stegerg
  19 // Doom port based on ADoomPPC. Read README.AROS!
  20 //
  21 //
  22 // DESCRIPTION:
  23 //      Handle Sector base lighting effects.
  24 //      Muzzle flash?
  25 //
  26 //-----------------------------------------------------------------------------
  27
  28 static const char
  29 rcsid[] = "$Id$";
  30
  31
  32 #include "z_zone.h"
  33 #include "m_random.h"
  34
  35 #include "doomdef.h"
  36 #include "p_local.h"
  37
  38
  39 // State.
  40 #include "r_state.h"
  41
  42 //
  43 // FIRELIGHT FLICKER
  44 //
  45
  46 //
  47 // T_FireFlicker
  48 //
  49 void T_FireFlicker (fireflicker_t* flick)
  50 {
  51     int amount;
  52
  53     if (--flick->count)
  54         return;
  55
  56     amount = (P_Random()&3)*16;
  57
  58     if (flick->sector->lightlevel - amount < flick->minlight)
  59         flick->sector->lightlevel = flick->minlight;
  60     else
  61         flick->sector->lightlevel = flick->maxlight - amount;
  62
  63     flick->count = 4;
  64 }
  65
  66
  67
  68 //
  69 // P_SpawnFireFlicker
  70 //
  71 void P_SpawnFireFlicker (sector_t*      sector)
  72 {
  73     fireflicker_t*      flick;
  74
  75     // Note that we are resetting sector attributes.
  76     // Nothing special about it during gameplay.
  77     sector->special = 0;
  78
  79     flick = Z_Malloc ( sizeof(*flick), PU_LEVSPEC, 0);
  80
  81     P_AddThinker (&flick->thinker);
  82
  83     flick->thinker.function.acp1 = (actionf_p1) T_FireFlicker;
  84     flick->sector = sector;
  85     flick->maxlight = sector->lightlevel;
  86     flick->minlight = P_FindMinSurroundingLight(sector,sector->lightlevel)+16;
  87     flick->count = 4;
  88 }
  89
  90
  91
  92 //
  93 // BROKEN LIGHT FLASHING
  94 //
  95
  96
  97 //
  98 // T_LightFlash
  99 // Do flashing lights.
 100 //
 101 void T_LightFlash (lightflash_t* flash)
 102 {
 103     if (--flash->count)
 104         return;
 105
 106     if (flash->sector->lightlevel == flash->maxlight)
 107     {
 108         flash-> sector->lightlevel = flash->minlight;
 109         flash->count = (P_Random()&flash->mintime)+1;
 110     }
 111     else
 112     {
 113         flash-> sector->lightlevel = flash->maxlight;
 114         flash->count = (P_Random()&flash->maxtime)+1;
 115     }
 116
 117 }
 118
 119
 120
 121
 122 //
 123 // P_SpawnLightFlash
 124 // After the map has been loaded, scan each sector
 125 // for specials that spawn thinkers
 126 //
 127 void P_SpawnLightFlash (sector_t*       sector)
 128 {
 129     lightflash_t*       flash;
 130
 131     // nothing special about it during gameplay
 132     sector->special = 0;
 133
 134     flash = Z_Malloc ( sizeof(*flash), PU_LEVSPEC, 0);
 135
 136     P_AddThinker (&flash->thinker);
 137
 138     flash->thinker.function.acp1 = (actionf_p1) T_LightFlash;
 139     flash->sector = sector;
 140     flash->maxlight = sector->lightlevel;
 141
 142     flash->minlight = P_FindMinSurroundingLight(sector,sector->lightlevel);
 143     flash->maxtime = 64;
 144     flash->mintime = 7;
 145     flash->count = (P_Random()&flash->maxtime)+1;
 146 }
 147
 148
 149
 150 //
 151 // STROBE LIGHT FLASHING
 152 //
 153
 154
 155 //
 156 // T_StrobeFlash
 157 //
 158 void T_StrobeFlash (strobe_t*           flash)
 159 {
 160     if (--flash->count)
 161         return;
 162
 163     if (flash->sector->lightlevel == flash->minlight)
 164     {
 165         flash-> sector->lightlevel = flash->maxlight;
 166         flash->count = flash->brighttime;
 167     }
 168     else
 169     {
 170         flash-> sector->lightlevel = flash->minlight;
 171         flash->count =flash->darktime;
 172     }
 173
 174 }
 175
 176
 177
 178 //
 179 // P_SpawnStrobeFlash
 180 // After the map has been loaded, scan each sector
 181 // for specials that spawn thinkers
 182 //
 183 void
 184 P_SpawnStrobeFlash
 185 ( sector_t*     sector,
 186   int           fastOrSlow,
 187   int           inSync )
 188 {
 189     strobe_t*   flash;
 190
 191     flash = Z_Malloc ( sizeof(*flash), PU_LEVSPEC, 0);
 192
 193     P_AddThinker (&flash->thinker);
 194
 195     flash->sector = sector;
 196     flash->darktime = fastOrSlow;
 197     flash->brighttime = STROBEBRIGHT;
 198     flash->thinker.function.acp1 = (actionf_p1) T_StrobeFlash;
 199     flash->maxlight = sector->lightlevel;
 200     flash->minlight = P_FindMinSurroundingLight(sector, sector->lightlevel);
 201
 202     if (flash->minlight == flash->maxlight)
 203         flash->minlight = 0;
 204
 205     // nothing special about it during gameplay
 206     sector->special = 0;
 207
 208     if (!inSync)
 209         flash->count = (P_Random()&7)+1;
 210     else
 211         flash->count = 1;
 212 }
 213
 214
 215 //
 216 // Start strobing lights (usually from a trigger)
 217 //
 218 void EV_StartLightStrobing(line_t*      line)
 219 {
 220     int         secnum;
 221     sector_t*   sec;
 222
 223     secnum = -1;
 224     while ((secnum = P_FindSectorFromLineTag(line,secnum)) >= 0)
 225     {
 226         sec = &sectors[secnum];
 227         if (sec->specialdata)
 228             continue;
 229
 230         P_SpawnStrobeFlash (sec,SLOWDARK, 0);
 231     }
 232 }
 233
 234
 235
 236 //
 237 // TURN LINE'S TAG LIGHTS OFF
 238 //
 239 void EV_TurnTagLightsOff(line_t* line)
 240 {
 241     int                 i;
 242     int                 j;
 243     int                 min;
 244     sector_t*           sector;
 245     sector_t*           tsec;
 246     line_t*             templine;
 247
 248     sector = sectors;
 249
 250     for (j = 0;j < numsectors; j++, sector++)
 251     {
 252         if (sector->tag == line->tag)
 253         {
 254             min = sector->lightlevel;
 255             for (i = 0;i < sector->linecount; i++)
 256             {
 257                 templine = sector->lines[i];
 258                 tsec = getNextSector(templine,sector);
 259                 if (!tsec)
 260                     continue;
 261                 if (tsec->lightlevel < min)
 262                     min = tsec->lightlevel;
 263             }
 264             sector->lightlevel = min;
 265         }
 266     }
 267 }
 268
 269
 270 //
 271 // TURN LINE'S TAG LIGHTS ON
 272 //
 273 void
 274 EV_LightTurnOn
 275 ( line_t*       line,
 276   int           bright )
 277 {
 278     int         i;
 279     int         j;
 280     sector_t*   sector;
 281     sector_t*   temp;
 282     line_t*     templine;
 283
 284     sector = sectors;
 285
 286     for (i=0;i<numsectors;i++, sector++)
 287     {
 288         if (sector->tag == line->tag)
 289         {
 290             // bright = 0 means to search
 291             // for highest light level
 292             // surrounding sector
 293             if (!bright)
 294             {
 295                 for (j = 0;j < sector->linecount; j++)
 296                 {
 297                     templine = sector->lines[j];
 298                     temp = getNextSector(templine,sector);
 299
 300                     if (!temp)
 301                         continue;
 302
 303                     if (temp->lightlevel > bright)
 304                         bright = temp->lightlevel;
 305                 }
 306             }
 307             sector-> lightlevel = bright;
 308         }
 309     }
 310 }
 311
 312
 313 //
 314 // Spawn glowing light
 315 //
 316
 317 void T_Glow(glow_t*     g)
 318 {
 319     switch(g->direction)
 320     {
 321       case -1:
 322         // DOWN
 323         g->sector->lightlevel -= GLOWSPEED;
 324         if (g->sector->lightlevel <= g->minlight)
 325         {
 326             g->sector->lightlevel += GLOWSPEED;
 327             g->direction = 1;
 328         }
 329         break;
 330
 331       case 1:
 332         // UP
 333         g->sector->lightlevel += GLOWSPEED;
 334         if (g->sector->lightlevel >= g->maxlight)
 335         {
 336             g->sector->lightlevel -= GLOWSPEED;
 337             g->direction = -1;
 338         }
 339         break;
 340     }
 341 }
 342
 343
 344 void P_SpawnGlowingLight(sector_t*      sector)
 345 {
 346     glow_t*     g;
 347
 348     g = Z_Malloc( sizeof(*g), PU_LEVSPEC, 0);
 349
 350     P_AddThinker(&g->thinker);
 351
 352     g->sector = sector;
 353     g->minlight = P_FindMinSurroundingLight(sector,sector->lightlevel);
 354     g->maxlight = sector->lightlevel;
 355     g->thinker.function.acp1 = (actionf_p1) T_Glow;
 356     g->direction = -1;
 357
 358     sector->special = 0;
 359 }
 360