Annotation of brogue-ce/src/brogue/Light.c, Revision 1.1
1.1 ! rubenllo 1: /*
! 2: * Light.c
! 3: * Brogue
! 4: *
! 5: * Created by Brian Walker on 1/21/09.
! 6: * Copyright 2012. All rights reserved.
! 7: *
! 8: * This file is part of Brogue.
! 9: *
! 10: * This program is free software: you can redistribute it and/or modify
! 11: * it under the terms of the GNU Affero General Public License as
! 12: * published by the Free Software Foundation, either version 3 of the
! 13: * License, or (at your option) any later version.
! 14: *
! 15: * This program is distributed in the hope that it will be useful,
! 16: * but WITHOUT ANY WARRANTY; without even the implied warranty of
! 17: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! 18: * GNU Affero General Public License for more details.
! 19: *
! 20: * You should have received a copy of the GNU Affero General Public License
! 21: * along with this program. If not, see <http://www.gnu.org/licenses/>.
! 22: */
! 23:
! 24: #include "Rogue.h"
! 25: #include "IncludeGlobals.h"
! 26:
! 27: void logLights() {
! 28:
! 29: short i, j;
! 30:
! 31: printf(" ");
! 32: for (i=0; i<COLS-2; i++) {
! 33: printf("%i", i % 10);
! 34: }
! 35: printf("\n");
! 36: for( j=0; j<DROWS-2; j++ ) {
! 37: if (j < 10) {
! 38: printf(" ");
! 39: }
! 40: printf("%i: ", j);
! 41: for( i=0; i<DCOLS-2; i++ ) {
! 42: if (tmap[i][j].light[0] == 0) {
! 43: printf(" ");
! 44: } else {
! 45: printf("%i", max(0, tmap[i][j].light[0] / 10 - 1));
! 46: }
! 47: }
! 48: printf("\n");
! 49: }
! 50: printf("\n");
! 51: }
! 52:
! 53: // Returns true if any part of the light hit cells that are in the player's field of view.
! 54: boolean paintLight(lightSource *theLight, short x, short y, boolean isMinersLight, boolean maintainShadows) {
! 55: short i, j, k;
! 56: short colorComponents[3], randComponent, lightMultiplier;
! 57: short fadeToPercent, radiusRounded;
! 58: fixpt radius;
! 59: char grid[DCOLS][DROWS];
! 60: boolean dispelShadows, overlappedFieldOfView;
! 61:
! 62: brogueAssert(rogue.RNG == RNG_SUBSTANTIVE);
! 63:
! 64: radius = randClump(theLight->lightRadius) * FP_FACTOR / 100;
! 65: radiusRounded = fp_round(radius);
! 66:
! 67: randComponent = rand_range(0, theLight->lightColor->rand);
! 68: colorComponents[0] = randComponent + theLight->lightColor->red + rand_range(0, theLight->lightColor->redRand);
! 69: colorComponents[1] = randComponent + theLight->lightColor->green + rand_range(0, theLight->lightColor->greenRand);
! 70: colorComponents[2] = randComponent + theLight->lightColor->blue + rand_range(0, theLight->lightColor->blueRand);
! 71:
! 72: // the miner's light does not dispel IS_IN_SHADOW,
! 73: // so the player can be in shadow despite casting his own light.
! 74: dispelShadows = !maintainShadows && (colorComponents[0] + colorComponents[1] + colorComponents[2]) > 0;
! 75:
! 76: fadeToPercent = theLight->radialFadeToPercent;
! 77:
! 78: // zero out only the relevant rectangle of the grid
! 79: for (i = max(0, x - radiusRounded); i < DCOLS && i < x + radiusRounded; i++) {
! 80: for (j = max(0, y - radiusRounded); j < DROWS && j < y + radiusRounded; j++) {
! 81: grid[i][j] = 0;
! 82: }
! 83: }
! 84:
! 85: getFOVMask(grid, x, y, radius, T_OBSTRUCTS_VISION, (theLight->passThroughCreatures ? 0 : (HAS_MONSTER | HAS_PLAYER)),
! 86: (!isMinersLight));
! 87:
! 88: overlappedFieldOfView = false;
! 89:
! 90: for (i = max(0, x - radiusRounded); i < DCOLS && i < x + radiusRounded; i++) {
! 91: for (j = max(0, y - radiusRounded); j < DROWS && j < y + radiusRounded; j++) {
! 92: if (grid[i][j]) {
! 93: lightMultiplier = 100 - (100 - fadeToPercent) * fp_sqrt(((i-x) * (i-x) + (j-y) * (j-y)) * FP_FACTOR) / radius;
! 94: for (k=0; k<3; k++) {
! 95: tmap[i][j].light[k] += colorComponents[k] * lightMultiplier / 100;;
! 96: }
! 97: if (dispelShadows) {
! 98: pmap[i][j].flags &= ~IS_IN_SHADOW;
! 99: }
! 100: if (pmap[i][j].flags & (IN_FIELD_OF_VIEW | ANY_KIND_OF_VISIBLE)) {
! 101: overlappedFieldOfView = true;
! 102: }
! 103: }
! 104: }
! 105: }
! 106:
! 107: tmap[x][y].light[0] += colorComponents[0];
! 108: tmap[x][y].light[1] += colorComponents[1];
! 109: tmap[x][y].light[2] += colorComponents[2];
! 110:
! 111: if (dispelShadows) {
! 112: pmap[x][y].flags &= ~IS_IN_SHADOW;
! 113: }
! 114:
! 115: return overlappedFieldOfView;
! 116: }
! 117:
! 118:
! 119: // sets miner's light strength and characteristics based on rings of illumination, scrolls of darkness and water submersion
! 120: void updateMinersLightRadius() {
! 121: fixpt base_fraction, fraction, lightRadius;
! 122:
! 123: lightRadius = 100 * rogue.minersLightRadius;
! 124:
! 125: if (rogue.lightMultiplier < 0) {
! 126: lightRadius = lightRadius / (-1 * rogue.lightMultiplier + 1);
! 127: } else {
! 128: lightRadius *= rogue.lightMultiplier;
! 129: lightRadius = max(lightRadius, (rogue.lightMultiplier * 2 + 2) * FP_FACTOR);
! 130: }
! 131:
! 132: if (player.status[STATUS_DARKNESS]) {
! 133: base_fraction = FP_FACTOR - player.status[STATUS_DARKNESS] * FP_FACTOR / player.maxStatus[STATUS_DARKNESS];
! 134: fraction = (base_fraction * base_fraction / FP_FACTOR) * base_fraction / FP_FACTOR;
! 135: //fraction = (double) pow(1.0 - (((double) player.status[STATUS_DARKNESS]) / player.maxStatus[STATUS_DARKNESS]), 3);
! 136: if (fraction < FP_FACTOR / 20) {
! 137: fraction = FP_FACTOR / 20;
! 138: }
! 139: lightRadius = lightRadius * fraction / FP_FACTOR;
! 140: } else {
! 141: fraction = FP_FACTOR;
! 142: }
! 143:
! 144: if (lightRadius < 2 * FP_FACTOR) {
! 145: lightRadius = 2 * FP_FACTOR;
! 146: }
! 147:
! 148: if (rogue.inWater && lightRadius > 3 * FP_FACTOR) {
! 149: lightRadius = max(lightRadius / 2, 3 * FP_FACTOR);
! 150: }
! 151:
! 152: rogue.minersLight.radialFadeToPercent = (35 + max(0, min(65, rogue.lightMultiplier * 5)) * fraction) / FP_FACTOR;
! 153: rogue.minersLight.lightRadius.upperBound = rogue.minersLight.lightRadius.lowerBound = clamp(lightRadius / FP_FACTOR, -30000, 30000);
! 154: }
! 155:
! 156: void updateDisplayDetail() {
! 157: short i, j;
! 158:
! 159: for (i = 0; i < DCOLS; i++) {
! 160: for (j = 0; j < DROWS; j++) {
! 161: if (tmap[i][j].light[0] < -10
! 162: && tmap[i][j].light[1] < -10
! 163: && tmap[i][j].light[2] < -10) {
! 164:
! 165: displayDetail[i][j] = DV_DARK;
! 166: } else if (pmap[i][j].flags & IS_IN_SHADOW) {
! 167: displayDetail[i][j] = DV_UNLIT;
! 168: } else {
! 169: displayDetail[i][j] = DV_LIT;
! 170: }
! 171: }
! 172: }
! 173: }
! 174:
! 175: void backUpLighting(short lights[DCOLS][DROWS][3]) {
! 176: short i, j, k;
! 177: for (i=0; i<DCOLS; i++) {
! 178: for (j=0; j<DROWS; j++) {
! 179: for (k=0; k<3; k++) {
! 180: lights[i][j][k] = tmap[i][j].light[k];
! 181: }
! 182: }
! 183: }
! 184: }
! 185:
! 186: void restoreLighting(short lights[DCOLS][DROWS][3]) {
! 187: short i, j, k;
! 188: for (i=0; i<DCOLS; i++) {
! 189: for (j=0; j<DROWS; j++) {
! 190: for (k=0; k<3; k++) {
! 191: tmap[i][j].light[k] = lights[i][j][k];
! 192: }
! 193: }
! 194: }
! 195: }
! 196:
! 197: void recordOldLights() {
! 198: short i, j, k;
! 199: for (i = 0; i < DCOLS; i++) {
! 200: for (j = 0; j < DROWS; j++) {
! 201: for (k=0; k<3; k++) {
! 202: tmap[i][j].oldLight[k] = tmap[i][j].light[k];
! 203: }
! 204: }
! 205: }
! 206: }
! 207:
! 208: void updateLighting() {
! 209: short i, j, k;
! 210: enum dungeonLayers layer;
! 211: enum tileType tile;
! 212: creature *monst;
! 213:
! 214: // Copy Light over oldLight
! 215: recordOldLights();
! 216:
! 217: // and then zero out Light.
! 218: for (i = 0; i < DCOLS; i++) {
! 219: for (j = 0; j < DROWS; j++) {
! 220: for (k=0; k<3; k++) {
! 221: tmap[i][j].light[k] = 0;
! 222: }
! 223: pmap[i][j].flags |= IS_IN_SHADOW;
! 224: }
! 225: }
! 226:
! 227: // Paint all glowing tiles.
! 228: for (i = 0; i < DCOLS; i++) {
! 229: for (j = 0; j < DROWS; j++) {
! 230: for (layer = 0; layer < NUMBER_TERRAIN_LAYERS; layer++) {
! 231: tile = pmap[i][j].layers[layer];
! 232: if (tileCatalog[tile].glowLight) {
! 233: paintLight(&(lightCatalog[tileCatalog[tile].glowLight]), i, j, false, false);
! 234: }
! 235: }
! 236: }
! 237: }
! 238:
! 239: // Cycle through monsters and paint their lights:
! 240: CYCLE_MONSTERS_AND_PLAYERS(monst) {
! 241: if (monst->info.intrinsicLightType) {
! 242: paintLight(&lightCatalog[monst->info.intrinsicLightType], monst->xLoc, monst->yLoc, false, false);
! 243: }
! 244: if (monst->mutationIndex >= 0 && mutationCatalog[monst->mutationIndex].light != NO_LIGHT) {
! 245: paintLight(&lightCatalog[mutationCatalog[monst->mutationIndex].light], monst->xLoc, monst->yLoc, false, false);
! 246: }
! 247:
! 248: if (monst->status[STATUS_BURNING] && !(monst->info.flags & MONST_FIERY)) {
! 249: paintLight(&lightCatalog[BURNING_CREATURE_LIGHT], monst->xLoc, monst->yLoc, false, false);
! 250: }
! 251:
! 252: if (monsterRevealed(monst)) {
! 253: paintLight(&lightCatalog[TELEPATHY_LIGHT], monst->xLoc, monst->yLoc, false, true);
! 254: }
! 255: }
! 256:
! 257: // Also paint telepathy lights for dormant monsters.
! 258: for (monst = dormantMonsters->nextCreature; monst != NULL; monst = monst->nextCreature) {
! 259: if (monsterRevealed(monst)) {
! 260: paintLight(&lightCatalog[TELEPATHY_LIGHT], monst->xLoc, monst->yLoc, false, true);
! 261: }
! 262: }
! 263:
! 264: updateDisplayDetail();
! 265:
! 266: // Miner's light:
! 267: paintLight(&rogue.minersLight, player.xLoc, player.yLoc, true, true);
! 268:
! 269: if (player.status[STATUS_INVISIBLE]) {
! 270: player.info.foreColor = &playerInvisibleColor;
! 271: } else if (playerInDarkness()) {
! 272: player.info.foreColor = &playerInDarknessColor;
! 273: } else if (pmap[player.xLoc][player.yLoc].flags & IS_IN_SHADOW) {
! 274: player.info.foreColor = &playerInShadowColor;
! 275: } else {
! 276: player.info.foreColor = &playerInLightColor;
! 277: }
! 278: }
! 279:
! 280: boolean playerInDarkness() {
! 281: return (tmap[player.xLoc][player.yLoc].light[0] + 10 < minersLightColor.red
! 282: && tmap[player.xLoc][player.yLoc].light[1] + 10 < minersLightColor.green
! 283: && tmap[player.xLoc][player.yLoc].light[2] + 10 < minersLightColor.blue);
! 284: }
! 285:
! 286: #define flarePrecision 1000
! 287:
! 288: flare *newFlare(lightSource *light, short x, short y, short changePerFrame, short limit) {
! 289: flare *theFlare = malloc(sizeof(flare));
! 290: memset(theFlare, '\0', sizeof(flare));
! 291: theFlare->light = light;
! 292: theFlare->xLoc = x;
! 293: theFlare->yLoc = y;
! 294: theFlare->coeffChangeAmount = changePerFrame;
! 295: if (theFlare->coeffChangeAmount == 0) {
! 296: theFlare->coeffChangeAmount = 1; // no change would mean it lasts forever, which usually breaks things
! 297: }
! 298: theFlare->coeffLimit = limit;
! 299: theFlare->coeff = 100 * flarePrecision;
! 300: theFlare->turnNumber = rogue.absoluteTurnNumber;
! 301: return theFlare;
! 302: }
! 303:
! 304: // Creates a new fading flare as described and sticks it into the stack so it will fire at the end of the turn.
! 305: void createFlare(short x, short y, enum lightType lightIndex) {
! 306: flare *theFlare;
! 307:
! 308: theFlare = newFlare(&(lightCatalog[lightIndex]), x, y, -15, 0);
! 309:
! 310: if (rogue.flareCount >= rogue.flareCapacity) {
! 311: rogue.flareCapacity += 10;
! 312: rogue.flares = realloc(rogue.flares, sizeof(flare *) * rogue.flareCapacity);
! 313: }
! 314: rogue.flares[rogue.flareCount] = theFlare;
! 315: rogue.flareCount++;
! 316: }
! 317:
! 318: boolean flareIsActive(flare *theFlare) {
! 319: const boolean increasing = (theFlare->coeffChangeAmount > 0);
! 320: boolean active = true;
! 321:
! 322: if (theFlare->turnNumber > 0 && theFlare->turnNumber < rogue.absoluteTurnNumber - 1) {
! 323: active = false;
! 324: }
! 325: if (increasing) {
! 326: if ((short) (theFlare->coeff / flarePrecision) > theFlare->coeffLimit) {
! 327: active = false;
! 328: }
! 329: } else {
! 330: if ((short) (theFlare->coeff / flarePrecision) < theFlare->coeffLimit) {
! 331: active = false;
! 332: }
! 333: }
! 334: return active;
! 335: }
! 336:
! 337: // Returns true if the flare is still active; false if it's not.
! 338: boolean updateFlare(flare *theFlare) {
! 339: if (!flareIsActive(theFlare)) {
! 340: return false;
! 341: }
! 342: theFlare->coeff += (theFlare->coeffChangeAmount) * flarePrecision / 10;
! 343: theFlare->coeffChangeAmount = theFlare->coeffChangeAmount * 12 / 10;
! 344: return flareIsActive(theFlare);
! 345: }
! 346:
! 347: // Returns whether it overlaps with the field of view.
! 348: boolean drawFlareFrame(flare *theFlare) {
! 349: boolean inView;
! 350: lightSource tempLight = *(theFlare->light);
! 351: color tempColor = *(tempLight.lightColor);
! 352:
! 353: if (!flareIsActive(theFlare)) {
! 354: return false;
! 355: }
! 356: tempLight.lightRadius.lowerBound = ((long) tempLight.lightRadius.lowerBound) * theFlare->coeff / (flarePrecision * 100);
! 357: tempLight.lightRadius.upperBound = ((long) tempLight.lightRadius.upperBound) * theFlare->coeff / (flarePrecision * 100);
! 358: applyColorScalar(&tempColor, theFlare->coeff / flarePrecision);
! 359: tempLight.lightColor = &tempColor;
! 360: inView = paintLight(&tempLight, theFlare->xLoc, theFlare->yLoc, false, true);
! 361:
! 362: return inView;
! 363: }
! 364:
! 365: // Frees the flares as they expire.
! 366: void animateFlares(flare **flares, short count) {
! 367: short lights[DCOLS][DROWS][3];
! 368: boolean inView, fastForward, atLeastOneFlareStillActive;
! 369: short i; // i iterates through the flare list
! 370:
! 371: brogueAssert(rogue.RNG == RNG_SUBSTANTIVE);
! 372:
! 373: backUpLighting(lights);
! 374: fastForward = rogue.trueColorMode || rogue.playbackFastForward;
! 375:
! 376: do {
! 377: inView = false;
! 378: atLeastOneFlareStillActive = false;
! 379: for (i = 0; i < count; i++) {
! 380: if (flares[i]) {
! 381: if (updateFlare(flares[i])) {
! 382: atLeastOneFlareStillActive = true;
! 383: if (drawFlareFrame(flares[i])) {
! 384: inView = true;
! 385: }
! 386: } else {
! 387: free(flares[i]);
! 388: flares[i] = NULL;
! 389: }
! 390: }
! 391: }
! 392: demoteVisibility();
! 393: updateFieldOfViewDisplay(false, true);
! 394: if (!fastForward && (inView || rogue.playbackOmniscience) && atLeastOneFlareStillActive) {
! 395: fastForward = pauseBrogue(10);
! 396: }
! 397: recordOldLights();
! 398: restoreLighting(lights);
! 399: } while (atLeastOneFlareStillActive);
! 400: updateFieldOfViewDisplay(false, true);
! 401: }
! 402:
! 403: void deleteAllFlares() {
! 404: short i;
! 405: for (i=0; i<rogue.flareCount; i++) {
! 406: free(rogue.flares[i]);
! 407: }
! 408: rogue.flareCount = 0;
! 409: }
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Light.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / brogue-ce / src / brogue