Annotation of brogue-ce/src/brogue/IO.c, Revision 1.1.1.1
1.1 rubenllo 1: /*
2: * IO.c
3: * Brogue
4: *
5: * Created by Brian Walker on 1/10/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 <math.h>
25: #include <time.h>
26:
27: #include "Rogue.h"
28: #include "IncludeGlobals.h"
29:
30: // Populates path[][] with a list of coordinates starting at origin and traversing down the map. Returns the number of steps in the path.
31: short getPlayerPathOnMap(short path[1000][2], short **map, short originX, short originY) {
32: short dir, x, y, steps;
33:
34: x = originX;
35: y = originY;
36:
37: dir = 0;
38:
39: for (steps = 0; dir != -1;) {
40: dir = nextStep(map, x, y, &player, false);
41: if (dir != -1) {
42: x += nbDirs[dir][0];
43: y += nbDirs[dir][1];
44: path[steps][0] = x;
45: path[steps][1] = y;
46: steps++;
47: brogueAssert(coordinatesAreInMap(x, y));
48: }
49: }
50: return steps;
51: }
52:
53: void reversePath(short path[1000][2], short steps) {
54: short i, x, y;
55:
56: for (i=0; i<steps / 2; i++) {
57: x = path[steps - i - 1][0];
58: y = path[steps - i - 1][1];
59:
60: path[steps - i - 1][0] = path[i][0];
61: path[steps - i - 1][1] = path[i][1];
62:
63: path[i][0] = x;
64: path[i][1] = y;
65: }
66: }
67:
68: void hilitePath(short path[1000][2], short steps, boolean unhilite) {
69: short i;
70: if (unhilite) {
71: for (i=0; i<steps; i++) {
72: brogueAssert(coordinatesAreInMap(path[i][0], path[i][1]));
73: pmap[path[i][0]][path[i][1]].flags &= ~IS_IN_PATH;
74: refreshDungeonCell(path[i][0], path[i][1]);
75: }
76: } else {
77: for (i=0; i<steps; i++) {
78: brogueAssert(coordinatesAreInMap(path[i][0], path[i][1]));
79: pmap[path[i][0]][path[i][1]].flags |= IS_IN_PATH;
80: refreshDungeonCell(path[i][0], path[i][1]);
81: }
82: }
83: }
84:
85: // More expensive than hilitePath(__, __, true), but you don't need access to the path itself.
86: void clearCursorPath() {
87: short i, j;
88:
89: if (!rogue.playbackMode) { // There are no cursor paths during playback.
90: for (i=1; i<DCOLS; i++) {
91: for (j=1; j<DROWS; j++) {
92: if (pmap[i][j].flags & IS_IN_PATH) {
93: pmap[i][j].flags &= ~IS_IN_PATH;
94: refreshDungeonCell(i, j);
95: }
96: }
97: }
98: }
99: }
100:
101: void hideCursor() {
102: // Drop out of cursor mode if we're in it, and hide the path either way.
103: rogue.cursorMode = false;
104: rogue.cursorPathIntensity = (rogue.cursorMode ? 50 : 20);
105: rogue.cursorLoc[0] = -1;
106: rogue.cursorLoc[1] = -1;
107: }
108:
109: void showCursor() {
110: // Return or enter turns on cursor mode. When the path is hidden, move the cursor to the player.
111: if (!coordinatesAreInMap(rogue.cursorLoc[0], rogue.cursorLoc[1])) {
112: rogue.cursorLoc[0] = player.xLoc;
113: rogue.cursorLoc[1] = player.yLoc;
114: rogue.cursorMode = true;
115: rogue.cursorPathIntensity = (rogue.cursorMode ? 50 : 20);
116: } else {
117: rogue.cursorMode = true;
118: rogue.cursorPathIntensity = (rogue.cursorMode ? 50 : 20);
119: }
120: }
121:
122: void getClosestValidLocationOnMap(short loc[2], short **map, short x, short y) {
123: short i, j, dist, closestDistance, lowestMapScore;
124:
125: closestDistance = 10000;
126: lowestMapScore = 10000;
127: for (i=1; i<DCOLS-1; i++) {
128: for (j=1; j<DROWS-1; j++) {
129: if (map[i][j] >= 0
130: && map[i][j] < 30000) {
131:
132: dist = (i - x)*(i - x) + (j - y)*(j - y);
133: //hiliteCell(i, j, &purple, min(dist / 2, 100), false);
134: if (dist < closestDistance
135: || dist == closestDistance && map[i][j] < lowestMapScore) {
136:
137: loc[0] = i;
138: loc[1] = j;
139: closestDistance = dist;
140: lowestMapScore = map[i][j];
141: }
142: }
143: }
144: }
145: }
146:
147: void processSnapMap(short **map) {
148: short **costMap;
149: enum directions dir;
150: short i, j, newX, newY;
151:
152: costMap = allocGrid();
153:
154: populateCreatureCostMap(costMap, &player);
155: fillGrid(map, 30000);
156: map[player.xLoc][player.yLoc] = 0;
157: dijkstraScan(map, costMap, true);
158: for (i = 0; i < DCOLS; i++) {
159: for (j = 0; j < DROWS; j++) {
160: if (cellHasTMFlag(i, j, TM_INVERT_WHEN_HIGHLIGHTED)) {
161: for (dir = 0; dir < 4; dir++) {
162: newX = i + nbDirs[dir][0];
163: newY = j + nbDirs[dir][1];
164: if (coordinatesAreInMap(newX, newY)
165: && map[newX][newY] >= 0
166: && map[newX][newY] < map[i][j]) {
167:
168: map[i][j] = map[newX][newY];
169: }
170: }
171: }
172: }
173: }
174:
175: freeGrid(costMap);
176: }
177:
178: // Displays a menu of buttons for various commands.
179: // Buttons will be disabled if not permitted based on the playback state.
180: // Returns the keystroke to effect the button's command, or -1 if canceled.
181: // Some buttons take effect in this function instead of returning a value,
182: // i.e. true colors mode and display stealth mode.
183: short actionMenu(short x, boolean playingBack) {
184: short buttonCount;
185: short y;
186: boolean takeActionOurselves[ROWS] = {false};
187: rogueEvent theEvent;
188:
189: brogueButton buttons[ROWS] = {{{0}}};
190: char yellowColorEscape[5] = "", whiteColorEscape[5] = "", darkGrayColorEscape[5] = "";
191: short i, j, longestName = 0, buttonChosen;
192: cellDisplayBuffer dbuf[COLS][ROWS], rbuf[COLS][ROWS];
193:
194: encodeMessageColor(yellowColorEscape, 0, &itemMessageColor);
195: encodeMessageColor(whiteColorEscape, 0, &white);
196: encodeMessageColor(darkGrayColorEscape, 0, &black);
197:
198: do {
199: for (i=0; i<ROWS; i++) {
200: initializeButton(&(buttons[i]));
201: buttons[i].buttonColor = interfaceBoxColor;
202: buttons[i].opacity = INTERFACE_OPACITY;
203: }
204:
205: buttonCount = 0;
206:
207: if (playingBack) {
208: #ifdef ENABLE_PLAYBACK_SWITCH
209: if (KEYBOARD_LABELS) {
210: sprintf(buttons[buttonCount].text, " %sP: %sPlay from here ", yellowColorEscape, whiteColorEscape);
211: } else {
212: strcpy(buttons[buttonCount].text, " Play from here ");
213: }
214: buttons[buttonCount].hotkey[0] = SWITCH_TO_PLAYING_KEY;
215: buttonCount++;
216:
217: sprintf(buttons[buttonCount].text, " %s---", darkGrayColorEscape);
218: buttons[buttonCount].flags &= ~B_ENABLED;
219: buttonCount++;
220: #endif
221: if (KEYBOARD_LABELS) {
222: sprintf(buttons[buttonCount].text, " %sk: %sFaster playback ", yellowColorEscape, whiteColorEscape);
223: } else {
224: strcpy(buttons[buttonCount].text, " Faster playback ");
225: }
226: buttons[buttonCount].hotkey[0] = UP_KEY;
227: buttons[buttonCount].hotkey[1] = UP_ARROW;
228: buttons[buttonCount].hotkey[2] = NUMPAD_8;
229: buttonCount++;
230: if (KEYBOARD_LABELS) {
231: sprintf(buttons[buttonCount].text, " %sj: %sSlower playback ", yellowColorEscape, whiteColorEscape);
232: } else {
233: strcpy(buttons[buttonCount].text, " Slower playback ");
234: }
235: buttons[buttonCount].hotkey[0] = DOWN_KEY;
236: buttons[buttonCount].hotkey[1] = DOWN_ARROW;
237: buttons[buttonCount].hotkey[2] = NUMPAD_2;
238: buttonCount++;
239: sprintf(buttons[buttonCount].text, " %s---", darkGrayColorEscape);
240: buttons[buttonCount].flags &= ~B_ENABLED;
241: buttonCount++;
242:
243: if (KEYBOARD_LABELS) {
244: sprintf(buttons[buttonCount].text, "%s0-9: %sFast forward to turn ", yellowColorEscape, whiteColorEscape);
245: } else {
246: strcpy(buttons[buttonCount].text, " Fast forward to turn ");
247: }
248: buttons[buttonCount].hotkey[0] = '0';
249: buttonCount++;
250: if (KEYBOARD_LABELS) {
251: sprintf(buttons[buttonCount].text, " %s<:%s Previous Level ", yellowColorEscape, whiteColorEscape);
252: } else {
253: strcpy(buttons[buttonCount].text, " Previous Level ");
254: }
255: buttons[buttonCount].hotkey[0] = ASCEND_KEY;
256: buttonCount++;
257: if (KEYBOARD_LABELS) {
258: sprintf(buttons[buttonCount].text, " %s>:%s Next Level ", yellowColorEscape, whiteColorEscape);
259: } else {
260: strcpy(buttons[buttonCount].text, " Next Level ");
261: }
262: buttons[buttonCount].hotkey[0] = DESCEND_KEY;
263: buttonCount++;
264: sprintf(buttons[buttonCount].text, " %s---", darkGrayColorEscape);
265: buttons[buttonCount].flags &= ~B_ENABLED;
266: buttonCount++;
267: } else {
268: if (KEYBOARD_LABELS) {
269: sprintf(buttons[buttonCount].text, " %sZ: %sRest until better ", yellowColorEscape, whiteColorEscape);
270: } else {
271: strcpy(buttons[buttonCount].text, " Rest until better ");
272: }
273: buttons[buttonCount].hotkey[0] = AUTO_REST_KEY;
274: buttonCount++;
275:
276: if (KEYBOARD_LABELS) {
277: sprintf(buttons[buttonCount].text, " %sA: %sAutopilot ", yellowColorEscape, whiteColorEscape);
278: } else {
279: strcpy(buttons[buttonCount].text, " Autopilot ");
280: }
281: buttons[buttonCount].hotkey[0] = AUTOPLAY_KEY;
282: buttonCount++;
283:
284: if (KEYBOARD_LABELS) {
285: sprintf(buttons[buttonCount].text, " %sT: %sRe-throw at last monster ", yellowColorEscape, whiteColorEscape);
286: } else {
287: strcpy(buttons[buttonCount].text, " Re-throw at last monster ");
288: }
289: buttons[buttonCount].hotkey[0] = RETHROW_KEY;
290: buttonCount++;
291:
292: if (!rogue.easyMode) {
293: if (KEYBOARD_LABELS) {
294: sprintf(buttons[buttonCount].text, " %s&: %sEasy mode ", yellowColorEscape, whiteColorEscape);
295: } else {
296: strcpy(buttons[buttonCount].text, " Easy mode ");
297: }
298: buttons[buttonCount].hotkey[0] = EASY_MODE_KEY;
299: buttonCount++;
300: }
301:
302: sprintf(buttons[buttonCount].text, " %s---", darkGrayColorEscape);
303: buttons[buttonCount].flags &= ~B_ENABLED;
304: buttonCount++;
305:
306: if(!serverMode) {
307: if (KEYBOARD_LABELS) {
308: sprintf(buttons[buttonCount].text, " %sS: %sSuspend game and quit ", yellowColorEscape, whiteColorEscape);
309: } else {
310: strcpy(buttons[buttonCount].text, " Suspend game and quit ");
311: }
312: buttons[buttonCount].hotkey[0] = SAVE_GAME_KEY;
313: buttonCount++;
314: if (KEYBOARD_LABELS) {
315: sprintf(buttons[buttonCount].text, " %sO: %sOpen suspended game ", yellowColorEscape, whiteColorEscape);
316: } else {
317: strcpy(buttons[buttonCount].text, " Open suspended game ");
318: }
319: buttons[buttonCount].hotkey[0] = LOAD_SAVED_GAME_KEY;
320: buttonCount++;
321: if (KEYBOARD_LABELS) {
322: sprintf(buttons[buttonCount].text, " %sV: %sView saved recording ", yellowColorEscape, whiteColorEscape);
323: } else {
324: strcpy(buttons[buttonCount].text, " View saved recording ");
325: }
326: buttons[buttonCount].hotkey[0] = VIEW_RECORDING_KEY;
327: buttonCount++;
328:
329: sprintf(buttons[buttonCount].text, " %s---", darkGrayColorEscape);
330: buttons[buttonCount].flags &= ~B_ENABLED;
331: buttonCount++;
332: }
333: }
334:
335: if (KEYBOARD_LABELS) {
336: sprintf(buttons[buttonCount].text, " %s\\: %s[%s] Hide color effects ", yellowColorEscape, whiteColorEscape, rogue.trueColorMode ? "X" : " ");
337: } else {
338: sprintf(buttons[buttonCount].text, " [%s] Hide color effects ", rogue.trueColorMode ? " " : "X");
339: }
340: buttons[buttonCount].hotkey[0] = TRUE_COLORS_KEY;
341: takeActionOurselves[buttonCount] = true;
342: buttonCount++;
343: if (KEYBOARD_LABELS) {
344: sprintf(buttons[buttonCount].text, " %s]: %s[%s] Display stealth range ", yellowColorEscape, whiteColorEscape, rogue.displayAggroRangeMode ? "X" : " ");
345: } else {
346: sprintf(buttons[buttonCount].text, " [%s] Show stealth range ", rogue.displayAggroRangeMode ? "X" : " ");
347: }
348: buttons[buttonCount].hotkey[0] = AGGRO_DISPLAY_KEY;
349: takeActionOurselves[buttonCount] = true;
350: buttonCount++;
351:
352: if (hasGraphics) {
353: if (KEYBOARD_LABELS) {
354: sprintf(buttons[buttonCount].text, " %sG: %s[%s] Enable graphics ", yellowColorEscape, whiteColorEscape, graphicsEnabled ? "X" : " ");
355: } else {
356: sprintf(buttons[buttonCount].text, " [%s] Enable graphics ", graphicsEnabled ? "X" : " ");
357: }
358: buttons[buttonCount].hotkey[0] = GRAPHICS_KEY;
359: takeActionOurselves[buttonCount] = true;
360: buttonCount++;
361: }
362:
363: sprintf(buttons[buttonCount].text, " %s---", darkGrayColorEscape);
364: buttons[buttonCount].flags &= ~B_ENABLED;
365: buttonCount++;
366:
367: if (KEYBOARD_LABELS) {
368: sprintf(buttons[buttonCount].text, " %sD: %sDiscovered items ", yellowColorEscape, whiteColorEscape);
369: } else {
370: strcpy(buttons[buttonCount].text, " Discovered items ");
371: }
372: buttons[buttonCount].hotkey[0] = DISCOVERIES_KEY;
373: buttonCount++;
374: if (KEYBOARD_LABELS) {
375: sprintf(buttons[buttonCount].text, " %s~: %sView dungeon seed ", yellowColorEscape, whiteColorEscape);
376: } else {
377: strcpy(buttons[buttonCount].text, " View dungeon seed ");
378: }
379: buttons[buttonCount].hotkey[0] = SEED_KEY;
380: buttonCount++;
381: if (KEYBOARD_LABELS) { // No help button if we're not in keyboard mode.
382: sprintf(buttons[buttonCount].text, " %s?: %sHelp ", yellowColorEscape, whiteColorEscape);
383: buttons[buttonCount].hotkey[0] = BROGUE_HELP_KEY;
384: buttonCount++;
385: }
386: sprintf(buttons[buttonCount].text, " %s---", darkGrayColorEscape);
387: buttons[buttonCount].flags &= ~B_ENABLED;
388: buttonCount++;
389:
390: if (KEYBOARD_LABELS) {
391: sprintf(buttons[buttonCount].text, " %sQ: %sQuit %s ", yellowColorEscape, whiteColorEscape, (playingBack ? "to title screen" : "without saving"));
392: } else {
393: sprintf(buttons[buttonCount].text, " Quit %s ", (playingBack ? "to title screen" : "without saving"));
394: }
395: buttons[buttonCount].hotkey[0] = QUIT_KEY;
396: buttonCount++;
397:
398: strcpy(buttons[buttonCount].text, " ");
399: buttons[buttonCount].flags &= ~B_ENABLED;
400: buttonCount++;
401:
402: for (i=0; i<buttonCount; i++) {
403: longestName = max(longestName, strLenWithoutEscapes(buttons[i].text));
404: }
405: if (x + longestName >= COLS) {
406: x = COLS - longestName - 1;
407: }
408: y = ROWS - buttonCount;
409: for (i=0; i<buttonCount; i++) {
410: buttons[i].x = x;
411: buttons[i].y = y + i;
412: for (j = strLenWithoutEscapes(buttons[i].text); j < longestName; j++) {
413: strcat(buttons[i].text, " "); // Schlemiel the Painter, but who cares.
414: }
415: }
416:
417: clearDisplayBuffer(dbuf);
418: rectangularShading(x - 1, y, longestName + 2, buttonCount, &black, INTERFACE_OPACITY / 2, dbuf);
419: overlayDisplayBuffer(dbuf, rbuf);
420: buttonChosen = buttonInputLoop(buttons, buttonCount, x - 1, y, longestName + 2, buttonCount, NULL);
421: overlayDisplayBuffer(rbuf, NULL);
422: if (buttonChosen == -1) {
423: return -1;
424: } else if (takeActionOurselves[buttonChosen]) {
425:
426: theEvent.eventType = KEYSTROKE;
427: theEvent.param1 = buttons[buttonChosen].hotkey[0];
428: theEvent.param2 = 0;
429: theEvent.shiftKey = theEvent.controlKey = false;
430: executeEvent(&theEvent);
431: } else {
432: return buttons[buttonChosen].hotkey[0];
433: }
434: } while (takeActionOurselves[buttonChosen]);
435: brogueAssert(false);
436: return -1;
437: }
438:
439: #define MAX_MENU_BUTTON_COUNT 5
440:
441: void initializeMenuButtons(buttonState *state, brogueButton buttons[5]) {
442: short i, x, buttonCount;
443: char goldTextEscape[MAX_MENU_BUTTON_COUNT] = "";
444: char whiteTextEscape[MAX_MENU_BUTTON_COUNT] = "";
445: color tempColor;
446:
447: encodeMessageColor(goldTextEscape, 0, KEYBOARD_LABELS ? &yellow : &white);
448: encodeMessageColor(whiteTextEscape, 0, &white);
449:
450: for (i=0; i<MAX_MENU_BUTTON_COUNT; i++) {
451: initializeButton(&(buttons[i]));
452: buttons[i].opacity = 75;
453: buttons[i].buttonColor = interfaceButtonColor;
454: buttons[i].y = ROWS - 1;
455: buttons[i].flags |= B_WIDE_CLICK_AREA;
456: buttons[i].flags &= ~B_KEYPRESS_HIGHLIGHT;
457: }
458:
459: buttonCount = 0;
460:
461: if (rogue.playbackMode) {
462: if (KEYBOARD_LABELS) {
463: sprintf(buttons[buttonCount].text, " Unpause (%sspace%s) ", goldTextEscape, whiteTextEscape);
464: } else {
465: strcpy(buttons[buttonCount].text, " Unpause ");
466: }
467: buttons[buttonCount].hotkey[0] = ACKNOWLEDGE_KEY;
468: buttonCount++;
469:
470: if (KEYBOARD_LABELS) {
471: sprintf(buttons[buttonCount].text, "Omniscience (%stab%s)", goldTextEscape, whiteTextEscape);
472: } else {
473: strcpy(buttons[buttonCount].text, " Omniscience ");
474: }
475: buttons[buttonCount].hotkey[0] = TAB_KEY;
476: buttonCount++;
477:
478: if (KEYBOARD_LABELS) {
479: sprintf(buttons[buttonCount].text, " Next Turn (%sl%s) ", goldTextEscape, whiteTextEscape);
480: } else {
481: strcpy(buttons[buttonCount].text, " Next Turn ");
482: }
483: buttons[buttonCount].hotkey[0] = RIGHT_KEY;
484: buttons[buttonCount].hotkey[1] = RIGHT_ARROW;
485: buttonCount++;
486:
487: strcpy(buttons[buttonCount].text, " Menu ");
488: buttonCount++;
489: } else {
490: sprintf(buttons[buttonCount].text, " E%sx%splore ", goldTextEscape, whiteTextEscape);
491: buttons[buttonCount].hotkey[0] = EXPLORE_KEY;
492: buttons[buttonCount].hotkey[1] = 'X';
493: buttonCount++;
494:
495: if (KEYBOARD_LABELS) {
496: sprintf(buttons[buttonCount].text, " Rest (%sz%s) ", goldTextEscape, whiteTextEscape);
497: } else {
498: strcpy(buttons[buttonCount].text, " Rest ");
499: }
500: buttons[buttonCount].hotkey[0] = REST_KEY;
501: buttonCount++;
502:
503: if (KEYBOARD_LABELS) {
504: sprintf(buttons[buttonCount].text, " Search (%ss%s) ", goldTextEscape, whiteTextEscape);
505: } else {
506: strcpy(buttons[buttonCount].text, " Search ");
507: }
508: buttons[buttonCount].hotkey[0] = SEARCH_KEY;
509: buttonCount++;
510:
511: strcpy(buttons[buttonCount].text, " Menu ");
512: buttonCount++;
513: }
514:
515: sprintf(buttons[4].text, " %sI%snventory ", goldTextEscape, whiteTextEscape);
516: buttons[4].hotkey[0] = INVENTORY_KEY;
517: buttons[4].hotkey[1] = 'I';
518:
519: x = mapToWindowX(0);
520: for (i=0; i<5; i++) {
521: buttons[i].x = x;
522: x += strLenWithoutEscapes(buttons[i].text) + 2; // Gap between buttons.
523: }
524:
525: initializeButtonState(state,
526: buttons,
527: 5,
528: mapToWindowX(0),
529: ROWS - 1,
530: COLS - mapToWindowX(0),
531: 1);
532:
533: for (i=0; i < 5; i++) {
534: drawButton(&(state->buttons[i]), BUTTON_NORMAL, state->rbuf);
535: }
536: for (i=0; i<COLS; i++) { // So the buttons stay (but are dimmed and desaturated) when inactive.
537: tempColor = colorFromComponents(state->rbuf[i][ROWS - 1].backColorComponents);
538: desaturate(&tempColor, 60);
539: applyColorAverage(&tempColor, &black, 50);
540: storeColorComponents(state->rbuf[i][ROWS - 1].backColorComponents, &tempColor);
541: tempColor = colorFromComponents(state->rbuf[i][ROWS - 1].foreColorComponents);
542: desaturate(&tempColor, 60);
543: applyColorAverage(&tempColor, &black, 50);
544: storeColorComponents(state->rbuf[i][ROWS - 1].foreColorComponents, &tempColor);
545: }
546: }
547:
548:
549: // This is basically the main loop for the game.
550: void mainInputLoop() {
551: short originLoc[2], pathDestination[2], oldTargetLoc[2] = { 0, 0 },
552: path[1000][2], steps, oldRNG, dir, newX, newY;
553: creature *monst;
554: item *theItem;
555: cellDisplayBuffer rbuf[COLS][ROWS];
556:
557: boolean canceled, targetConfirmed, tabKey, focusedOnMonster, focusedOnItem, focusedOnTerrain,
558: playingBack, doEvent, textDisplayed;
559:
560: rogueEvent theEvent;
561: short **costMap, **playerPathingMap, **cursorSnapMap;
562: brogueButton buttons[5] = {{{0}}};
563: buttonState state;
564: short buttonInput;
565: short backupCost;
566:
567: short *cursor = rogue.cursorLoc; // shorthand
568:
569: canceled = false;
570: rogue.cursorMode = false; // Controls whether the keyboard moves the cursor or the character.
571: steps = 0;
572:
573: rogue.cursorPathIntensity = (rogue.cursorMode ? 50 : 20);
574:
575: // Initialize buttons.
576: initializeMenuButtons(&state, buttons);
577:
578: playingBack = rogue.playbackMode;
579: rogue.playbackMode = false;
580: costMap = allocGrid();
581: playerPathingMap = allocGrid();
582: cursorSnapMap = allocGrid();
583:
584: cursor[0] = cursor[1] = -1;
585:
586: while (!rogue.gameHasEnded && (!playingBack || !canceled)) { // repeats until the game ends
587:
588: oldRNG = rogue.RNG;
589: rogue.RNG = RNG_COSMETIC;
590:
591: focusedOnMonster = focusedOnItem = focusedOnTerrain = false;
592: steps = 0;
593: clearCursorPath();
594:
595: originLoc[0] = player.xLoc;
596: originLoc[1] = player.yLoc;
597:
598: if (playingBack && rogue.cursorMode) {
599: temporaryMessage("Examine what? (<hjklyubn>, mouse, or <tab>)", false);
600: }
601:
602: if (!playingBack
603: && player.xLoc == cursor[0]
604: && player.yLoc == cursor[1]
605: && oldTargetLoc[0] == cursor[0]
606: && oldTargetLoc[1] == cursor[1]) {
607:
608: // Path hides when you reach your destination.
609: rogue.cursorMode = false;
610: rogue.cursorPathIntensity = (rogue.cursorMode ? 50 : 20);
611: cursor[0] = -1;
612: cursor[1] = -1;
613: }
614:
615: oldTargetLoc[0] = cursor[0];
616: oldTargetLoc[1] = cursor[1];
617:
618: populateCreatureCostMap(costMap, &player);
619:
620: fillGrid(playerPathingMap, 30000);
621: playerPathingMap[player.xLoc][player.yLoc] = 0;
622: dijkstraScan(playerPathingMap, costMap, true);
623: processSnapMap(cursorSnapMap);
624:
625: do {
626: textDisplayed = false;
627:
628: // Draw the cursor and path
629: if (coordinatesAreInMap(oldTargetLoc[0], oldTargetLoc[1])) {
630: refreshDungeonCell(oldTargetLoc[0], oldTargetLoc[1]); // Remove old cursor.
631: }
632: if (!playingBack) {
633: if (coordinatesAreInMap(oldTargetLoc[0], oldTargetLoc[1])) {
634: hilitePath(path, steps, true); // Unhilite old path.
635: }
636: if (coordinatesAreInMap(cursor[0], cursor[1])) {
637: if (cursorSnapMap[cursor[0]][cursor[1]] >= 0
638: && cursorSnapMap[cursor[0]][cursor[1]] < 30000) {
639:
640: pathDestination[0] = cursor[0];
641: pathDestination[1] = cursor[1];
642: } else {
643: // If the cursor is aimed at an inaccessible area, find the nearest accessible area to path toward.
644: getClosestValidLocationOnMap(pathDestination, cursorSnapMap, cursor[0], cursor[1]);
645: }
646:
647: fillGrid(playerPathingMap, 30000);
648: playerPathingMap[pathDestination[0]][pathDestination[1]] = 0;
649: backupCost = costMap[pathDestination[0]][pathDestination[1]];
650: costMap[pathDestination[0]][pathDestination[1]] = 1;
651: dijkstraScan(playerPathingMap, costMap, true);
652: costMap[pathDestination[0]][pathDestination[1]] = backupCost;
653: steps = getPlayerPathOnMap(path, playerPathingMap, player.xLoc, player.yLoc);
654:
655: // steps = getPlayerPathOnMap(path, playerPathingMap, pathDestination[0], pathDestination[1]) - 1; // Get new path.
656: // reversePath(path, steps); // Flip it around, back-to-front.
657:
658: if (steps >= 0) {
659: path[steps][0] = pathDestination[0];
660: path[steps][1] = pathDestination[1];
661: }
662: steps++;
663: // if (playerPathingMap[cursor[0]][cursor[1]] != 1
664: if (playerPathingMap[player.xLoc][player.yLoc] != 1
665: || pathDestination[0] != cursor[0]
666: || pathDestination[1] != cursor[1]) {
667:
668: hilitePath(path, steps, false); // Hilite new path.
669: }
670: }
671: }
672:
673: if (coordinatesAreInMap(cursor[0], cursor[1])) {
674: hiliteCell(cursor[0],
675: cursor[1],
676: &white,
677: (steps <= 0
678: || (path[steps-1][0] == cursor[0] && path[steps-1][1] == cursor[1])
679: || (!playingBack && distanceBetween(player.xLoc, player.yLoc, cursor[0], cursor[1]) <= 1) ? 100 : 25),
680: true);
681:
682: oldTargetLoc[0] = cursor[0];
683: oldTargetLoc[1] = cursor[1];
684:
685: monst = monsterAtLoc(cursor[0], cursor[1]);
686: theItem = itemAtLoc(cursor[0], cursor[1]);
687: if (monst != NULL && (canSeeMonster(monst) || rogue.playbackOmniscience)) {
688: rogue.playbackMode = playingBack;
689: refreshSideBar(cursor[0], cursor[1], false);
690: rogue.playbackMode = false;
691:
692: focusedOnMonster = true;
693: if (monst != &player && (!player.status[STATUS_HALLUCINATING] || rogue.playbackOmniscience)) {
694: printMonsterDetails(monst, rbuf);
695: textDisplayed = true;
696: }
697: } else if (theItem != NULL && playerCanSeeOrSense(cursor[0], cursor[1])) {
698: rogue.playbackMode = playingBack;
699: refreshSideBar(cursor[0], cursor[1], false);
700: rogue.playbackMode = false;
701:
702: focusedOnItem = true;
703: if (!player.status[STATUS_HALLUCINATING] || rogue.playbackOmniscience) {
704: printFloorItemDetails(theItem, rbuf);
705: textDisplayed = true;
706: }
707: } else if (cellHasTMFlag(cursor[0], cursor[1], TM_LIST_IN_SIDEBAR) && playerCanSeeOrSense(cursor[0], cursor[1])) {
708: rogue.playbackMode = playingBack;
709: refreshSideBar(cursor[0], cursor[1], false);
710: rogue.playbackMode = false;
711: focusedOnTerrain = true;
712: }
713:
714: printLocationDescription(cursor[0], cursor[1]);
715: }
716:
717: // Get the input!
718: rogue.playbackMode = playingBack;
719: doEvent = moveCursor(&targetConfirmed, &canceled, &tabKey, cursor, &theEvent, &state, !textDisplayed, rogue.cursorMode, true);
720: rogue.playbackMode = false;
721:
722: if (state.buttonChosen == 3) { // Actions menu button.
723: buttonInput = actionMenu(buttons[3].x - 4, playingBack); // Returns the corresponding keystroke.
724: if (buttonInput == -1) { // Canceled.
725: doEvent = false;
726: } else {
727: theEvent.eventType = KEYSTROKE;
728: theEvent.param1 = buttonInput;
729: theEvent.param2 = 0;
730: theEvent.shiftKey = theEvent.controlKey = false;
731: doEvent = true;
732: }
733: } else if (state.buttonChosen > -1) {
734: theEvent.eventType = KEYSTROKE;
735: theEvent.param1 = buttons[state.buttonChosen].hotkey[0];
736: theEvent.param2 = 0;
737: }
738: state.buttonChosen = -1;
739:
740: if (playingBack) {
741: if (canceled) {
742: rogue.cursorMode = false;
743: rogue.cursorPathIntensity = (rogue.cursorMode ? 50 : 20);
744: }
745:
746: if (theEvent.eventType == KEYSTROKE
747: && theEvent.param1 == ACKNOWLEDGE_KEY) { // To unpause by button during playback.
748: canceled = true;
749: } else {
750: canceled = false;
751: }
752: }
753:
754: if (focusedOnMonster || focusedOnItem || focusedOnTerrain) {
755: focusedOnMonster = false;
756: focusedOnItem = false;
757: focusedOnTerrain = false;
758: if (textDisplayed) {
759: overlayDisplayBuffer(rbuf, 0); // Erase the monster info window.
760: }
761: rogue.playbackMode = playingBack;
762: refreshSideBar(-1, -1, false);
763: rogue.playbackMode = false;
764: }
765:
766: if (tabKey && !playingBack) { // The tab key cycles the cursor through monsters, items and terrain features.
767: if (nextTargetAfter(&newX, &newY, cursor[0], cursor[1], true, true, true, true, false, theEvent.shiftKey)) {
768: cursor[0] = newX;
769: cursor[1] = newY;
770: }
771: }
772:
773: if (theEvent.eventType == KEYSTROKE
774: && (theEvent.param1 == ASCEND_KEY && cursor[0] == rogue.upLoc[0] && cursor[1] == rogue.upLoc[1]
775: || theEvent.param1 == DESCEND_KEY && cursor[0] == rogue.downLoc[0] && cursor[1] == rogue.downLoc[1])) {
776:
777: targetConfirmed = true;
778: doEvent = false;
779: }
780: } while (!targetConfirmed && !canceled && !doEvent && !rogue.gameHasEnded);
781:
782: if (coordinatesAreInMap(oldTargetLoc[0], oldTargetLoc[1])) {
783: refreshDungeonCell(oldTargetLoc[0], oldTargetLoc[1]); // Remove old cursor.
784: }
785:
786: restoreRNG;
787:
788: if (canceled && !playingBack) {
789: hideCursor();
790: confirmMessages();
791: } else if (targetConfirmed && !playingBack && coordinatesAreInMap(cursor[0], cursor[1])) {
792: if (theEvent.eventType == MOUSE_UP
793: && theEvent.controlKey
794: && steps > 1) {
795: // Control-clicking moves the player one step along the path.
796: for (dir=0;
797: dir < DIRECTION_COUNT && (player.xLoc + nbDirs[dir][0] != path[0][0] || player.yLoc + nbDirs[dir][1] != path[0][1]);
798: dir++);
799: playerMoves(dir);
800: } else if (D_WORMHOLING) {
801: travel(cursor[0], cursor[1], true);
802: } else {
803: confirmMessages();
804: if (originLoc[0] == cursor[0]
805: && originLoc[1] == cursor[1]) {
806:
807: confirmMessages();
808: } else if (abs(player.xLoc - cursor[0]) + abs(player.yLoc - cursor[1]) == 1 // horizontal or vertical
809: || (distanceBetween(player.xLoc, player.yLoc, cursor[0], cursor[1]) == 1 // includes diagonals
810: && (!diagonalBlocked(player.xLoc, player.yLoc, cursor[0], cursor[1], !rogue.playbackOmniscience)
811: || ((pmap[cursor[0]][cursor[1]].flags & HAS_MONSTER) && (monsterAtLoc(cursor[0], cursor[1])->info.flags & MONST_ATTACKABLE_THRU_WALLS)) // there's a turret there
812: || ((terrainFlags(cursor[0], cursor[1]) & T_OBSTRUCTS_PASSABILITY) && (terrainMechFlags(cursor[0], cursor[1]) & TM_PROMOTES_ON_PLAYER_ENTRY))))) { // there's a lever there
813: // Clicking one space away will cause the player to try to move there directly irrespective of path.
814: for (dir=0;
815: dir < DIRECTION_COUNT && (player.xLoc + nbDirs[dir][0] != cursor[0] || player.yLoc + nbDirs[dir][1] != cursor[1]);
816: dir++);
817: playerMoves(dir);
818: } else if (steps) {
819: travelRoute(path, steps);
820: }
821: }
822: } else if (doEvent) {
823: // If the player entered input during moveCursor() that wasn't a cursor movement command.
824: // Mainly, we want to filter out directional keystrokes when we're in cursor mode, since
825: // those should move the cursor but not the player.
826: brogueAssert(rogue.RNG == RNG_SUBSTANTIVE);
827: if (playingBack) {
828: rogue.playbackMode = true;
829: executePlaybackInput(&theEvent);
830: #ifdef ENABLE_PLAYBACK_SWITCH
831: if (!rogue.playbackMode) {
832: // Playback mode is off, user must have taken control
833: // Redraw buttons to reflect that
834: initializeMenuButtons(&state, buttons);
835: }
836: #endif
837: playingBack = rogue.playbackMode;
838: rogue.playbackMode = false;
839: } else {
840: executeEvent(&theEvent);
841: if (rogue.playbackMode) {
842: playingBack = true;
843: rogue.playbackMode = false;
844: confirmMessages();
845: break;
846: }
847: }
848: }
849: }
850:
851: rogue.playbackMode = playingBack;
852: refreshSideBar(-1, -1, false);
853: freeGrid(costMap);
854: freeGrid(playerPathingMap);
855: freeGrid(cursorSnapMap);
856: }
857:
858: // accuracy depends on how many clock cycles occur per second
859: #define MILLISECONDS (clock() * 1000 / CLOCKS_PER_SEC)
860:
861: #define MILLISECONDS_FOR_CAUTION 100
862:
863: void considerCautiousMode() {
864: /*
865: signed long oldMilliseconds = rogue.milliseconds;
866: rogue.milliseconds = MILLISECONDS;
867: clock_t i = clock();
868: printf("\n%li", i);
869: if (rogue.milliseconds - oldMilliseconds < MILLISECONDS_FOR_CAUTION) {
870: rogue.cautiousMode = true;
871: }*/
872: }
873:
874: // flags the entire window as needing to be redrawn at next flush.
875: // very low level -- does not interface with the guts of the game.
876: void refreshScreen() {
877: short i, j;
878:
879: for( i=0; i<COLS; i++ ) {
880: for( j=0; j<ROWS; j++ ) {
881: displayBuffer[i][j].needsUpdate = true;
882: }
883: }
884: commitDraws();
885: }
886:
887: // higher-level redraw
888: void displayLevel() {
889: short i, j;
890:
891: for( i=0; i<DCOLS; i++ ) {
892: for (j = DROWS-1; j >= 0; j--) {
893: refreshDungeonCell(i, j);
894: }
895: }
896: }
897:
898: // converts colors into components
899: void storeColorComponents(char components[3], const color *theColor) {
900: short rand = rand_range(0, theColor->rand);
901: components[0] = max(0, min(100, theColor->red + rand_range(0, theColor->redRand) + rand));
902: components[1] = max(0, min(100, theColor->green + rand_range(0, theColor->greenRand) + rand));
903: components[2] = max(0, min(100, theColor->blue + rand_range(0, theColor->blueRand) + rand));
904: }
905:
906: void bakeTerrainColors(color *foreColor, color *backColor, short x, short y) {
907: const short *vals;
908: const short neutralColors[8] = {1000, 1000, 1000, 1000, 0, 0, 0, 0};
909: if (rogue.trueColorMode) {
910: vals = neutralColors;
911: } else {
912: vals = &(terrainRandomValues[x][y][0]);
913: }
914:
915: const short foreRand = foreColor->rand * vals[6] / 1000;
916: const short backRand = backColor->rand * vals[7] / 1000;
917:
918: foreColor->red += foreColor->redRand * vals[0] / 1000 + foreRand;
919: foreColor->green += foreColor->greenRand * vals[1] / 1000 + foreRand;
920: foreColor->blue += foreColor->blueRand * vals[2] / 1000 + foreRand;
921: foreColor->redRand = foreColor->greenRand = foreColor->blueRand = foreColor->rand = 0;
922:
923: backColor->red += backColor->redRand * vals[3] / 1000 + backRand;
924: backColor->green += backColor->greenRand * vals[4] / 1000 + backRand;
925: backColor->blue += backColor->blueRand * vals[5] / 1000 + backRand;
926: backColor->redRand = backColor->greenRand = backColor->blueRand = backColor->rand = 0;
927:
928: if (foreColor->colorDances || backColor->colorDances) {
929: pmap[x][y].flags |= TERRAIN_COLORS_DANCING;
930: } else {
931: pmap[x][y].flags &= ~TERRAIN_COLORS_DANCING;
932: }
933: }
934:
935: void bakeColor(color *theColor) {
936: short rand;
937: rand = rand_range(0, theColor->rand);
938: theColor->red += rand_range(0, theColor->redRand) + rand;
939: theColor->green += rand_range(0, theColor->greenRand) + rand;
940: theColor->blue += rand_range(0, theColor->blueRand) + rand;
941: theColor->redRand = theColor->greenRand = theColor->blueRand = theColor->rand = 0;
942: }
943:
944: void shuffleTerrainColors(short percentOfCells, boolean refreshCells) {
945: enum directions dir;
946: short i, j;
947:
948: assureCosmeticRNG;
949:
950: for (i=0; i<DCOLS; i++) {
951: for(j=0; j<DROWS; j++) {
952: if (playerCanSeeOrSense(i, j)
953: && (!rogue.automationActive || !(rogue.playerTurnNumber % 5))
954: && ((pmap[i][j].flags & TERRAIN_COLORS_DANCING)
955: || (player.status[STATUS_HALLUCINATING] && playerCanDirectlySee(i, j)))
956: && (i != rogue.cursorLoc[0] || j != rogue.cursorLoc[1])
957: && (percentOfCells >= 100 || rand_range(1, 100) <= percentOfCells)) {
958:
959: for (dir=0; dir<DIRECTION_COUNT; dir++) {
960: terrainRandomValues[i][j][dir] += rand_range(-600, 600);
961: terrainRandomValues[i][j][dir] = clamp(terrainRandomValues[i][j][dir], 0, 1000);
962: }
963:
964: if (refreshCells) {
965: refreshDungeonCell(i, j);
966: }
967: }
968: }
969: }
970: restoreRNG;
971: }
972:
973: // if forecolor is too similar to back, darken or lighten it and return true.
974: // Assumes colors have already been baked (no random components).
975: boolean separateColors(color *fore, color *back) {
976: color f, b, *modifier;
977: short failsafe;
978: boolean madeChange;
979:
980: f = *fore;
981: b = *back;
982: f.red = clamp(f.red, 0, 100);
983: f.green = clamp(f.green, 0, 100);
984: f.blue = clamp(f.blue, 0, 100);
985: b.red = clamp(b.red, 0, 100);
986: b.green = clamp(b.green, 0, 100);
987: b.blue = clamp(b.blue, 0, 100);
988:
989: if (f.red + f.blue + f.green > 50 * 3) {
990: modifier = &black;
991: } else {
992: modifier = &white;
993: }
994:
995: madeChange = false;
996: failsafe = 10;
997:
998: while(COLOR_DIFF(f, b) < MIN_COLOR_DIFF && --failsafe) {
999: applyColorAverage(&f, modifier, 20);
1000: madeChange = true;
1001: }
1002:
1003: if (madeChange) {
1004: *fore = f;
1005: return true;
1006: } else {
1007: return false;
1008: }
1009: }
1010:
1011: void normColor(color *baseColor, const short aggregateMultiplier, const short colorTranslation) {
1012:
1013: baseColor->red += colorTranslation;
1014: baseColor->green += colorTranslation;
1015: baseColor->blue += colorTranslation;
1016: const short vectorLength = baseColor->red + baseColor->green + baseColor->blue;
1017:
1018: if (vectorLength != 0) {
1019: baseColor->red = baseColor->red * 300 / vectorLength * aggregateMultiplier / 100;
1020: baseColor->green = baseColor->green * 300 / vectorLength * aggregateMultiplier / 100;
1021: baseColor->blue = baseColor->blue * 300 / vectorLength * aggregateMultiplier / 100;
1022: }
1023: baseColor->redRand = 0;
1024: baseColor->greenRand = 0;
1025: baseColor->blueRand = 0;
1026: baseColor->rand = 0;
1027: }
1028:
1029: // Used to determine whether to draw a wall top glyph above
1030: static boolean glyphIsWallish(enum displayGlyph glyph) {
1031: switch (glyph) {
1032: case G_WALL:
1033: case G_OPEN_DOOR:
1034: case G_CLOSED_DOOR:
1035: case G_UP_STAIRS:
1036: case G_DOORWAY:
1037: case G_WALL_TOP:
1038: case G_LEVER:
1039: case G_LEVER_PULLED:
1040: case G_CLOSED_IRON_DOOR:
1041: case G_OPEN_IRON_DOOR:
1042: case G_TURRET:
1043: case G_GRANITE:
1044: case G_TORCH:
1045: case G_PORTCULLIS:
1046: return true;
1047:
1048: default:
1049: return false;
1050: }
1051: }
1052:
1053: static enum monsterTypes randomAnimateMonster() {
1054: /* Randomly pick an animate and vulnerable monster type. Used by
1055: getCellAppearance for hallucination effects. */
1056: static int listLength = 0;
1057: static enum monsterTypes animate[NUMBER_MONSTER_KINDS];
1058:
1059: if (listLength == 0) {
1060: for (int i=0; i < NUMBER_MONSTER_KINDS; i++) {
1061: if (!(monsterCatalog[i].flags & (MONST_INANIMATE | MONST_INVULNERABLE))) {
1062: animate[listLength++] = i;
1063: }
1064: }
1065: }
1066:
1067: return animate[rand_range(0, listLength - 1)];
1068: }
1069:
1070: // okay, this is kind of a beast...
1071: void getCellAppearance(short x, short y, enum displayGlyph *returnChar, color *returnForeColor, color *returnBackColor) {
1072: short bestBCPriority, bestFCPriority, bestCharPriority;
1073: short distance;
1074: enum displayGlyph cellChar = 0;
1075: color cellForeColor, cellBackColor, lightMultiplierColor = black, gasAugmentColor;
1076: boolean monsterWithDetectedItem = false, needDistinctness = false;
1077: short gasAugmentWeight = 0;
1078: creature *monst = NULL;
1079: item *theItem = NULL;
1080: enum tileType tile = NOTHING;
1081: const enum displayGlyph itemChars[] = {G_POTION, G_SCROLL, G_FOOD, G_WAND,
1082: G_STAFF, G_GOLD, G_ARMOR, G_WEAPON, G_RING, G_CHARM};
1083: enum dungeonLayers layer, maxLayer;
1084:
1085: assureCosmeticRNG;
1086:
1087: brogueAssert(coordinatesAreInMap(x, y));
1088:
1089: if (pmap[x][y].flags & HAS_MONSTER) {
1090: monst = monsterAtLoc(x, y);
1091: } else if (pmap[x][y].flags & HAS_DORMANT_MONSTER) {
1092: monst = dormantMonsterAtLoc(x, y);
1093: }
1094: if (monst) {
1095: monsterWithDetectedItem = (monst->carriedItem && (monst->carriedItem->flags & ITEM_MAGIC_DETECTED)
1096: && itemMagicPolarity(monst->carriedItem) && !canSeeMonster(monst));
1097: }
1098:
1099: if (monsterWithDetectedItem) {
1100: theItem = monst->carriedItem;
1101: } else {
1102: theItem = itemAtLoc(x, y);
1103: }
1104:
1105: if (!playerCanSeeOrSense(x, y)
1106: && !(pmap[x][y].flags & (ITEM_DETECTED | HAS_PLAYER))
1107: && (!monst || !monsterRevealed(monst))
1108: && !monsterWithDetectedItem
1109: && (pmap[x][y].flags & (DISCOVERED | MAGIC_MAPPED))
1110: && (pmap[x][y].flags & STABLE_MEMORY)) {
1111:
1112: // restore memory
1113: cellChar = pmap[x][y].rememberedAppearance.character;
1114: cellForeColor = colorFromComponents(pmap[x][y].rememberedAppearance.foreColorComponents);
1115: cellBackColor = colorFromComponents(pmap[x][y].rememberedAppearance.backColorComponents);
1116: } else {
1117: // Find the highest-priority fore color, back color and character.
1118: bestFCPriority = bestBCPriority = bestCharPriority = 10000;
1119:
1120: // Default to the appearance of floor.
1121: cellForeColor = *(tileCatalog[FLOOR].foreColor);
1122: cellBackColor = *(tileCatalog[FLOOR].backColor);
1123: cellChar = tileCatalog[FLOOR].displayChar;
1124:
1125: if (!(pmap[x][y].flags & DISCOVERED) && !rogue.playbackOmniscience) {
1126: if (pmap[x][y].flags & MAGIC_MAPPED) {
1127: maxLayer = LIQUID + 1; // Can see only dungeon and liquid layers with magic mapping.
1128: } else {
1129: maxLayer = 0; // Terrain shouldn't influence the tile appearance at all if it hasn't been discovered.
1130: }
1131: } else {
1132: maxLayer = NUMBER_TERRAIN_LAYERS;
1133: }
1134:
1135: for (layer = 0; layer < maxLayer; layer++) {
1136: // Gas shows up as a color average, not directly.
1137: if (pmap[x][y].layers[layer] && layer != GAS) {
1138: tile = pmap[x][y].layers[layer];
1139: if (rogue.playbackOmniscience && (tileCatalog[tile].mechFlags & TM_IS_SECRET)) {
1140: tile = dungeonFeatureCatalog[tileCatalog[tile].discoverType].tile;
1141: }
1142:
1143: if (tileCatalog[tile].drawPriority < bestFCPriority
1144: && tileCatalog[tile].foreColor) {
1145:
1146: cellForeColor = *(tileCatalog[tile].foreColor);
1147: bestFCPriority = tileCatalog[tile].drawPriority;
1148: }
1149: if (tileCatalog[tile].drawPriority < bestBCPriority
1150: && tileCatalog[tile].backColor) {
1151:
1152: cellBackColor = *(tileCatalog[tile].backColor);
1153: bestBCPriority = tileCatalog[tile].drawPriority;
1154: }
1155: if (tileCatalog[tile].drawPriority < bestCharPriority
1156: && tileCatalog[tile].displayChar) {
1157:
1158: cellChar = tileCatalog[tile].displayChar;
1159: bestCharPriority = tileCatalog[tile].drawPriority;
1160: needDistinctness = (tileCatalog[tile].mechFlags & TM_VISUALLY_DISTINCT) ? true : false;
1161: }
1162: }
1163: }
1164:
1165: if (rogue.trueColorMode) {
1166: lightMultiplierColor = colorMultiplier100;
1167: } else {
1168: colorMultiplierFromDungeonLight(x, y, &lightMultiplierColor);
1169: }
1170:
1171: if (pmap[x][y].layers[GAS]
1172: && tileCatalog[pmap[x][y].layers[GAS]].backColor) {
1173:
1174: gasAugmentColor = *(tileCatalog[pmap[x][y].layers[GAS]].backColor);
1175: if (rogue.trueColorMode) {
1176: gasAugmentWeight = 30;
1177: } else {
1178: gasAugmentWeight = min(90, 30 + pmap[x][y].volume);
1179: }
1180: }
1181:
1182: if (D_DISABLE_BACKGROUND_COLORS) {
1183: if (COLOR_DIFF(cellBackColor, black) > COLOR_DIFF(cellForeColor, black)) {
1184: cellForeColor = cellBackColor;
1185: }
1186: cellBackColor = black;
1187: needDistinctness = true;
1188: }
1189:
1190: if (pmap[x][y].flags & HAS_PLAYER) {
1191: cellChar = player.info.displayChar;
1192: cellForeColor = *(player.info.foreColor);
1193: needDistinctness = true;
1194: } else if (((pmap[x][y].flags & HAS_ITEM) && (pmap[x][y].flags & ITEM_DETECTED)
1195: && itemMagicPolarity(theItem)
1196: && !playerCanSeeOrSense(x, y))
1197: || monsterWithDetectedItem){
1198:
1199: int polarity = itemMagicPolarity(theItem);
1200: if (theItem->category == AMULET) {
1201: cellChar = G_AMULET;
1202: cellForeColor = white;
1203: } else if (polarity == -1) {
1204: cellChar = G_BAD_MAGIC;
1205: cellForeColor = badMessageColor;
1206: } else if (polarity == 1) {
1207: cellChar = G_GOOD_MAGIC;
1208: cellForeColor = goodMessageColor;
1209: } else {
1210: cellChar = 0;
1211: cellForeColor = white;
1212: }
1213:
1214: needDistinctness = true;
1215: } else if ((pmap[x][y].flags & HAS_MONSTER)
1216: && (playerCanSeeOrSense(x, y) || ((monst->info.flags & MONST_IMMOBILE) && (pmap[x][y].flags & DISCOVERED)))
1217: && (!monsterIsHidden(monst, &player) || rogue.playbackOmniscience)) {
1218: needDistinctness = true;
1219: if (player.status[STATUS_HALLUCINATING] > 0 && !(monst->info.flags & (MONST_INANIMATE | MONST_INVULNERABLE)) && !rogue.playbackOmniscience) {
1220: cellChar = monsterCatalog[randomAnimateMonster()].displayChar;
1221: cellForeColor = *(monsterCatalog[randomAnimateMonster()].foreColor);
1222: } else {
1223: cellChar = monst->info.displayChar;
1224: cellForeColor = *(monst->info.foreColor);
1225: if (monst->status[STATUS_INVISIBLE] || (monst->bookkeepingFlags & MB_SUBMERGED)) {
1226: // Invisible allies show up on the screen with a transparency effect.
1227: //cellForeColor = cellBackColor;
1228: applyColorAverage(&cellForeColor, &cellBackColor, 75);
1229: } else {
1230: if (monst->creatureState == MONSTER_ALLY && !(monst->info.flags & MONST_INANIMATE)) {
1231: if (rogue.trueColorMode) {
1232: cellForeColor = white;
1233: } else {
1234: applyColorAverage(&cellForeColor, &pink, 50);
1235: }
1236: }
1237: }
1238: //DEBUG if (monst->bookkeepingFlags & MB_LEADER) applyColorAverage(&cellBackColor, &purple, 50);
1239: }
1240: } else if (monst
1241: && monsterRevealed(monst)
1242: && !canSeeMonster(monst)) {
1243: if (player.status[STATUS_HALLUCINATING] && !rogue.playbackOmniscience) {
1244: cellChar = (rand_range(0, 1) ? 'X' : 'x');
1245: } else {
1246: cellChar = (monst->info.isLarge ? 'X' : 'x');
1247: }
1248: cellForeColor = white;
1249: lightMultiplierColor = white;
1250: if (!(pmap[x][y].flags & DISCOVERED)) {
1251: cellBackColor = black;
1252: gasAugmentColor = black;
1253: }
1254: } else if ((pmap[x][y].flags & HAS_ITEM) && !cellHasTerrainFlag(x, y, T_OBSTRUCTS_ITEMS)
1255: && (playerCanSeeOrSense(x, y) || ((pmap[x][y].flags & DISCOVERED) && !cellHasTerrainFlag(x, y, T_MOVES_ITEMS)))) {
1256: needDistinctness = true;
1257: if (player.status[STATUS_HALLUCINATING] && !rogue.playbackOmniscience) {
1258: cellChar = itemChars[rand_range(0, 9)];
1259: cellForeColor = itemColor;
1260: } else {
1261: theItem = itemAtLoc(x, y);
1262: cellChar = theItem->displayChar;
1263: cellForeColor = *(theItem->foreColor);
1264: // Remember the item was here
1265: pmap[x][y].rememberedItemCategory = theItem->category;
1266: pmap[x][y].rememberedItemKind = theItem->kind;
1267: pmap[x][y].rememberedItemQuantity = theItem->quantity;
1268: pmap[x][y].rememberedItemOriginDepth = theItem->originDepth;
1269: }
1270: } else if (playerCanSeeOrSense(x, y) || (pmap[x][y].flags & (DISCOVERED | MAGIC_MAPPED))) {
1271: // just don't want these to be plotted as black
1272: // Also, ensure we remember there are no items here
1273: pmap[x][y].rememberedItemCategory = 0;
1274: pmap[x][y].rememberedItemKind = 0;
1275: pmap[x][y].rememberedItemQuantity = 0;
1276: pmap[x][y].rememberedItemOriginDepth = 0;
1277: } else {
1278: *returnChar = ' ';
1279: *returnForeColor = black;
1280: *returnBackColor = undiscoveredColor;
1281:
1282: if (D_DISABLE_BACKGROUND_COLORS) *returnBackColor = black;
1283:
1284: restoreRNG;
1285: return;
1286: }
1287:
1288: if (gasAugmentWeight && ((pmap[x][y].flags & DISCOVERED) || rogue.playbackOmniscience)) {
1289: if (!rogue.trueColorMode || !needDistinctness) {
1290: applyColorAverage(&cellForeColor, &gasAugmentColor, gasAugmentWeight);
1291: }
1292: // phantoms create sillhouettes in gas clouds
1293: if ((pmap[x][y].flags & HAS_MONSTER)
1294: && monst->status[STATUS_INVISIBLE]
1295: && playerCanSeeOrSense(x, y)
1296: && !monsterRevealed(monst)
1297: && !monsterHiddenBySubmersion(monst, &player)) {
1298:
1299: if (player.status[STATUS_HALLUCINATING] && !rogue.playbackOmniscience) {
1300: cellChar = monsterCatalog[randomAnimateMonster()].displayChar;
1301: } else {
1302: cellChar = monst->info.displayChar;
1303: }
1304: cellForeColor = cellBackColor;
1305: }
1306: applyColorAverage(&cellBackColor, &gasAugmentColor, gasAugmentWeight);
1307: }
1308:
1309: if (!(pmap[x][y].flags & (ANY_KIND_OF_VISIBLE | ITEM_DETECTED | HAS_PLAYER))
1310: && !playerCanSeeOrSense(x, y)
1311: && (!monst || !monsterRevealed(monst)) && !monsterWithDetectedItem) {
1312:
1313: pmap[x][y].flags |= STABLE_MEMORY;
1314: pmap[x][y].rememberedAppearance.character = cellChar;
1315:
1316: if (rogue.trueColorMode) {
1317: bakeTerrainColors(&cellForeColor, &cellBackColor, x, y);
1318: }
1319:
1320: // store memory
1321: storeColorComponents(pmap[x][y].rememberedAppearance.foreColorComponents, &cellForeColor);
1322: storeColorComponents(pmap[x][y].rememberedAppearance.backColorComponents, &cellBackColor);
1323:
1324: applyColorAugment(&lightMultiplierColor, &basicLightColor, 100);
1325: if (!rogue.trueColorMode || !needDistinctness) {
1326: applyColorMultiplier(&cellForeColor, &lightMultiplierColor);
1327: }
1328: applyColorMultiplier(&cellBackColor, &lightMultiplierColor);
1329: bakeTerrainColors(&cellForeColor, &cellBackColor, x, y);
1330:
1331: // Then restore, so that it looks the same on this pass as it will when later refreshed.
1332: cellForeColor = colorFromComponents(pmap[x][y].rememberedAppearance.foreColorComponents);
1333: cellBackColor = colorFromComponents(pmap[x][y].rememberedAppearance.backColorComponents);
1334: }
1335: }
1336:
1337: // Smooth out walls: if there's a "wall-ish" tile drawn below us, just draw the wall top
1338: if ((cellChar == G_WALL || cellChar == G_GRANITE) && coordinatesAreInMap(x, y+1)
1339: && glyphIsWallish(displayBuffer[mapToWindowX(x)][mapToWindowY(y+1)].character)) {
1340: cellChar = G_WALL_TOP;
1341: }
1342:
1343: if (((pmap[x][y].flags & ITEM_DETECTED) || monsterWithDetectedItem
1344: || (monst && monsterRevealed(monst)))
1345: && !playerCanSeeOrSense(x, y)) {
1346: // do nothing
1347: } else if (!(pmap[x][y].flags & VISIBLE) && (pmap[x][y].flags & CLAIRVOYANT_VISIBLE)) {
1348: // can clairvoyantly see it
1349: if (rogue.trueColorMode) {
1350: lightMultiplierColor = basicLightColor;
1351: } else {
1352: applyColorAugment(&lightMultiplierColor, &basicLightColor, 100);
1353: }
1354: if (!rogue.trueColorMode || !needDistinctness) {
1355: applyColorMultiplier(&cellForeColor, &lightMultiplierColor);
1356: applyColorMultiplier(&cellForeColor, &clairvoyanceColor);
1357: }
1358: applyColorMultiplier(&cellBackColor, &lightMultiplierColor);
1359: applyColorMultiplier(&cellBackColor, &clairvoyanceColor);
1360: } else if (!(pmap[x][y].flags & VISIBLE) && (pmap[x][y].flags & TELEPATHIC_VISIBLE)) {
1361: // Can telepathically see it through another creature's eyes.
1362:
1363: applyColorAugment(&lightMultiplierColor, &basicLightColor, 100);
1364:
1365: if (!rogue.trueColorMode || !needDistinctness) {
1366: applyColorMultiplier(&cellForeColor, &lightMultiplierColor);
1367: applyColorMultiplier(&cellForeColor, &telepathyMultiplier);
1368: }
1369: applyColorMultiplier(&cellBackColor, &lightMultiplierColor);
1370: applyColorMultiplier(&cellBackColor, &telepathyMultiplier);
1371: } else if (!(pmap[x][y].flags & DISCOVERED) && (pmap[x][y].flags & MAGIC_MAPPED)) {
1372: // magic mapped only
1373: if (!rogue.playbackOmniscience) {
1374: needDistinctness = false;
1375: if (!rogue.trueColorMode || !needDistinctness) {
1376: applyColorMultiplier(&cellForeColor, &magicMapColor);
1377: }
1378: applyColorMultiplier(&cellBackColor, &magicMapColor);
1379: }
1380: } else if (!(pmap[x][y].flags & VISIBLE) && !rogue.playbackOmniscience) {
1381: // if it's not visible
1382:
1383: needDistinctness = false;
1384: if (rogue.inWater) {
1385: applyColorAverage(&cellForeColor, &black, 80);
1386: applyColorAverage(&cellBackColor, &black, 80);
1387: } else {
1388: if (!cellHasTMFlag(x, y, TM_BRIGHT_MEMORY)
1389: && (!rogue.trueColorMode || !needDistinctness)) {
1390:
1391: applyColorMultiplier(&cellForeColor, &memoryColor);
1392: applyColorAverage(&cellForeColor, &memoryOverlay, 25);
1393: }
1394: applyColorMultiplier(&cellBackColor, &memoryColor);
1395: applyColorAverage(&cellBackColor, &memoryOverlay, 25);
1396: }
1397: } else if (playerCanSeeOrSense(x, y) && rogue.playbackOmniscience && !(pmap[x][y].flags & ANY_KIND_OF_VISIBLE)) {
1398: // omniscience
1399: applyColorAugment(&lightMultiplierColor, &basicLightColor, 100);
1400: if (!rogue.trueColorMode || !needDistinctness) {
1401: applyColorMultiplier(&cellForeColor, &lightMultiplierColor);
1402: applyColorMultiplier(&cellForeColor, &omniscienceColor);
1403: }
1404: applyColorMultiplier(&cellBackColor, &lightMultiplierColor);
1405: applyColorMultiplier(&cellBackColor, &omniscienceColor);
1406: } else {
1407: if (!rogue.trueColorMode || !needDistinctness) {
1408: applyColorMultiplier(&cellForeColor, &lightMultiplierColor);
1409: }
1410: applyColorMultiplier(&cellBackColor, &lightMultiplierColor);
1411:
1412: if (player.status[STATUS_HALLUCINATING] && !rogue.trueColorMode) {
1413: randomizeColor(&cellForeColor, 40 * player.status[STATUS_HALLUCINATING] / 300 + 20);
1414: randomizeColor(&cellBackColor, 40 * player.status[STATUS_HALLUCINATING] / 300 + 20);
1415: }
1416: if (rogue.inWater) {
1417: applyColorMultiplier(&cellForeColor, &deepWaterLightColor);
1418: applyColorMultiplier(&cellBackColor, &deepWaterLightColor);
1419: }
1420: }
1421: // DEBUG cellBackColor.red = max(0,((scentMap[x][y] - rogue.scentTurnNumber) * 2) + 100);
1422: // DEBUG if (pmap[x][y].flags & KNOWN_TO_BE_TRAP_FREE) cellBackColor.red += 20;
1423: // DEBUG if (cellHasTerrainFlag(x, y, T_IS_FLAMMABLE)) cellBackColor.red += 50;
1424:
1425: if (pmap[x][y].flags & IS_IN_PATH) {
1426: if (cellHasTMFlag(x, y, TM_INVERT_WHEN_HIGHLIGHTED)) {
1427: swapColors(&cellForeColor, &cellBackColor);
1428: } else {
1429: if (!rogue.trueColorMode || !needDistinctness) {
1430: applyColorAverage(&cellForeColor, &yellow, rogue.cursorPathIntensity);
1431: }
1432: applyColorAverage(&cellBackColor, &yellow, rogue.cursorPathIntensity);
1433: }
1434: needDistinctness = true;
1435: }
1436:
1437: bakeTerrainColors(&cellForeColor, &cellBackColor, x, y);
1438:
1439: if (rogue.displayAggroRangeMode && (pmap[x][y].flags & IN_FIELD_OF_VIEW)) {
1440: distance = min(rogue.scentTurnNumber - scentMap[x][y], scentDistance(x, y, player.xLoc, player.yLoc));
1441: if (distance > rogue.aggroRange * 2) {
1442: applyColorAverage(&cellForeColor, &orange, 12);
1443: applyColorAverage(&cellBackColor, &orange, 12);
1444: applyColorAugment(&cellForeColor, &orange, 12);
1445: applyColorAugment(&cellBackColor, &orange, 12);
1446: }
1447: }
1448:
1449: if (rogue.trueColorMode
1450: && playerCanSeeOrSense(x, y)) {
1451:
1452: if (displayDetail[x][y] == DV_DARK) {
1453: applyColorMultiplier(&cellForeColor, &inDarknessMultiplierColor);
1454: applyColorMultiplier(&cellBackColor, &inDarknessMultiplierColor);
1455:
1456: applyColorAugment(&cellForeColor, &purple, 10);
1457: applyColorAugment(&cellBackColor, &white, -10);
1458: applyColorAverage(&cellBackColor, &purple, 20);
1459: } else if (displayDetail[x][y] == DV_LIT) {
1460:
1461: colorMultiplierFromDungeonLight(x, y, &lightMultiplierColor);
1462: normColor(&lightMultiplierColor, 175, 50);
1463: //applyColorMultiplier(&cellForeColor, &lightMultiplierColor);
1464: //applyColorMultiplier(&cellBackColor, &lightMultiplierColor);
1465: applyColorAugment(&cellForeColor, &lightMultiplierColor, 5);
1466: applyColorAugment(&cellBackColor, &lightMultiplierColor, 5);
1467: }
1468: }
1469:
1470: if (needDistinctness) {
1471: separateColors(&cellForeColor, &cellBackColor);
1472: }
1473:
1474: if (D_SCENT_VISION) {
1475: if (rogue.scentTurnNumber > (unsigned short) scentMap[x][y]) {
1476: cellBackColor.red = rogue.scentTurnNumber - (unsigned short) scentMap[x][y];
1477: cellBackColor.red = clamp(cellBackColor.red, 0, 100);
1478: } else {
1479: cellBackColor.green = abs(rogue.scentTurnNumber - (unsigned short) scentMap[x][y]);
1480: cellBackColor.green = clamp(cellBackColor.green, 0, 100);
1481: }
1482: }
1483:
1484: *returnChar = cellChar;
1485: *returnForeColor = cellForeColor;
1486: *returnBackColor = cellBackColor;
1487:
1488: if (D_DISABLE_BACKGROUND_COLORS) *returnBackColor = black;
1489: restoreRNG;
1490: }
1491:
1492: void refreshDungeonCell(short x, short y) {
1493: enum displayGlyph cellChar;
1494: color foreColor, backColor;
1495: brogueAssert(coordinatesAreInMap(x, y));
1496:
1497: getCellAppearance(x, y, &cellChar, &foreColor, &backColor);
1498: plotCharWithColor(cellChar, mapToWindowX(x), mapToWindowY(y), &foreColor, &backColor);
1499: }
1500:
1501: void applyColorMultiplier(color *baseColor, const color *multiplierColor) {
1502: baseColor->red = baseColor->red * multiplierColor->red / 100;
1503: baseColor->redRand = baseColor->redRand * multiplierColor->redRand / 100;
1504: baseColor->green = baseColor->green * multiplierColor->green / 100;
1505: baseColor->greenRand = baseColor->greenRand * multiplierColor->greenRand / 100;
1506: baseColor->blue = baseColor->blue * multiplierColor->blue / 100;
1507: baseColor->blueRand = baseColor->blueRand * multiplierColor->blueRand / 100;
1508: baseColor->rand = baseColor->rand * multiplierColor->rand / 100;
1509: //baseColor->colorDances *= multiplierColor->colorDances;
1510: return;
1511: }
1512:
1513: void applyColorAverage(color *baseColor, const color *newColor, short averageWeight) {
1514: short weightComplement = 100 - averageWeight;
1515: baseColor->red = (baseColor->red * weightComplement + newColor->red * averageWeight) / 100;
1516: baseColor->redRand = (baseColor->redRand * weightComplement + newColor->redRand * averageWeight) / 100;
1517: baseColor->green = (baseColor->green * weightComplement + newColor->green * averageWeight) / 100;
1518: baseColor->greenRand = (baseColor->greenRand * weightComplement + newColor->greenRand * averageWeight) / 100;
1519: baseColor->blue = (baseColor->blue * weightComplement + newColor->blue * averageWeight) / 100;
1520: baseColor->blueRand = (baseColor->blueRand * weightComplement + newColor->blueRand * averageWeight) / 100;
1521: baseColor->rand = (baseColor->rand * weightComplement + newColor->rand * averageWeight) / 100;
1522: baseColor->colorDances = (baseColor->colorDances || newColor->colorDances);
1523: return;
1524: }
1525:
1526: void applyColorAugment(color *baseColor, const color *augmentingColor, short augmentWeight) {
1527: baseColor->red += (augmentingColor->red * augmentWeight) / 100;
1528: baseColor->redRand += (augmentingColor->redRand * augmentWeight) / 100;
1529: baseColor->green += (augmentingColor->green * augmentWeight) / 100;
1530: baseColor->greenRand += (augmentingColor->greenRand * augmentWeight) / 100;
1531: baseColor->blue += (augmentingColor->blue * augmentWeight) / 100;
1532: baseColor->blueRand += (augmentingColor->blueRand * augmentWeight) / 100;
1533: baseColor->rand += (augmentingColor->rand * augmentWeight) / 100;
1534: return;
1535: }
1536:
1537: void applyColorScalar(color *baseColor, short scalar) {
1538: baseColor->red = baseColor->red * scalar / 100;
1539: baseColor->redRand = baseColor->redRand * scalar / 100;
1540: baseColor->green = baseColor->green * scalar / 100;
1541: baseColor->greenRand = baseColor->greenRand * scalar / 100;
1542: baseColor->blue = baseColor->blue * scalar / 100;
1543: baseColor->blueRand = baseColor->blueRand * scalar / 100;
1544: baseColor->rand = baseColor->rand * scalar / 100;
1545: }
1546:
1547: void applyColorBounds(color *baseColor, short lowerBound, short upperBound) {
1548: baseColor->red = clamp(baseColor->red, lowerBound, upperBound);
1549: baseColor->redRand = clamp(baseColor->redRand, lowerBound, upperBound);
1550: baseColor->green = clamp(baseColor->green, lowerBound, upperBound);
1551: baseColor->greenRand = clamp(baseColor->greenRand, lowerBound, upperBound);
1552: baseColor->blue = clamp(baseColor->blue, lowerBound, upperBound);
1553: baseColor->blueRand = clamp(baseColor->blueRand, lowerBound, upperBound);
1554: baseColor->rand = clamp(baseColor->rand, lowerBound, upperBound);
1555: }
1556:
1557: void desaturate(color *baseColor, short weight) {
1558: short avg;
1559: avg = (baseColor->red + baseColor->green + baseColor->blue) / 3 + 1;
1560: baseColor->red = baseColor->red * (100 - weight) / 100 + (avg * weight / 100);
1561: baseColor->green = baseColor->green * (100 - weight) / 100 + (avg * weight / 100);
1562: baseColor->blue = baseColor->blue * (100 - weight) / 100 + (avg * weight / 100);
1563:
1564: avg = (baseColor->redRand + baseColor->greenRand + baseColor->blueRand);
1565: baseColor->redRand = baseColor->redRand * (100 - weight) / 100;
1566: baseColor->greenRand = baseColor->greenRand * (100 - weight) / 100;
1567: baseColor->blueRand = baseColor->blueRand * (100 - weight) / 100;
1568:
1569: baseColor->rand += avg * weight / 3 / 100;
1570: }
1571:
1572: short randomizeByPercent(short input, short percent) {
1573: return (rand_range(input * (100 - percent) / 100, input * (100 + percent) / 100));
1574: }
1575:
1576: void randomizeColor(color *baseColor, short randomizePercent) {
1577: baseColor->red = randomizeByPercent(baseColor->red, randomizePercent);
1578: baseColor->green = randomizeByPercent(baseColor->green, randomizePercent);
1579: baseColor->blue = randomizeByPercent(baseColor->blue, randomizePercent);
1580: }
1581:
1582: void swapColors(color *color1, color *color2) {
1583: color tempColor = *color1;
1584: *color1 = *color2;
1585: *color2 = tempColor;
1586: }
1587:
1588: // Assumes colors are pre-baked.
1589: void blendAppearances(const color *fromForeColor, const color *fromBackColor, const enum displayGlyph fromChar,
1590: const color *toForeColor, const color *toBackColor, const enum displayGlyph toChar,
1591: color *retForeColor, color *retBackColor, enum displayGlyph *retChar,
1592: const short percent) {
1593: // Straight average of the back color:
1594: *retBackColor = *fromBackColor;
1595: applyColorAverage(retBackColor, toBackColor, percent);
1596:
1597: // Pick the character:
1598: if (percent >= 50) {
1599: *retChar = toChar;
1600: } else {
1601: *retChar = fromChar;
1602: }
1603:
1604: // Pick the method for blending the fore color.
1605: if (fromChar == toChar) {
1606: // If the character isn't changing, do a straight average.
1607: *retForeColor = *fromForeColor;
1608: applyColorAverage(retForeColor, toForeColor, percent);
1609: } else {
1610: // If it is changing, the first half blends to the current back color, and the second half blends to the final back color.
1611: if (percent >= 50) {
1612: *retForeColor = *retBackColor;
1613: applyColorAverage(retForeColor, toForeColor, (percent - 50) * 2);
1614: } else {
1615: *retForeColor = *fromForeColor;
1616: applyColorAverage(retForeColor, retBackColor, percent * 2);
1617: }
1618: }
1619: }
1620:
1621: void irisFadeBetweenBuffers(cellDisplayBuffer fromBuf[COLS][ROWS],
1622: cellDisplayBuffer toBuf[COLS][ROWS],
1623: short x, short y,
1624: short frameCount,
1625: boolean outsideIn) {
1626: short i, j, frame, percentBasis, thisCellPercent;
1627: boolean fastForward;
1628: color fromBackColor, toBackColor, fromForeColor, toForeColor, currentForeColor, currentBackColor;
1629: enum displayGlyph fromChar, toChar, currentChar;
1630: short completionMap[COLS][ROWS], maxDistance;
1631:
1632: fastForward = false;
1633: frame = 1;
1634:
1635: // Calculate the square of the maximum distance from (x, y) that the iris will have to spread.
1636: if (x < COLS / 2) {
1637: i = COLS - x;
1638: } else {
1639: i = x;
1640: }
1641: if (y < ROWS / 2) {
1642: j = ROWS - y;
1643: } else {
1644: j = y;
1645: }
1646: maxDistance = i*i + j*j;
1647:
1648: // Generate the initial completion map as a percent of maximum distance.
1649: for (i=0; i<COLS; i++) {
1650: for (j=0; j<ROWS; j++) {
1651: completionMap[i][j] = (i - x)*(i - x) + (j - y)*(j - y); // square of distance
1652: completionMap[i][j] = 100 * completionMap[i][j] / maxDistance; // percent of max distance
1653: if (outsideIn) {
1654: completionMap[i][j] -= 100; // translate to [-100, 0], with the origin at -100 and the farthest point at 0.
1655: } else {
1656: completionMap[i][j] *= -1; // translate to [-100, 0], with the origin at 0 and the farthest point at -100.
1657: }
1658: }
1659: }
1660:
1661: do {
1662: percentBasis = 10000 * frame / frameCount;
1663:
1664: for (i=0; i<COLS; i++) {
1665: for (j=0; j<ROWS; j++) {
1666: thisCellPercent = percentBasis * 3 / 100 + completionMap[i][j];
1667:
1668: fromBackColor = colorFromComponents(fromBuf[i][j].backColorComponents);
1669: fromForeColor = colorFromComponents(fromBuf[i][j].foreColorComponents);
1670: fromChar = fromBuf[i][j].character;
1671:
1672: toBackColor = colorFromComponents(toBuf[i][j].backColorComponents);
1673: toForeColor = colorFromComponents(toBuf[i][j].foreColorComponents);
1674: toChar = toBuf[i][j].character;
1675:
1676: blendAppearances(&fromForeColor, &fromBackColor, fromChar, &toForeColor, &toBackColor, toChar, ¤tForeColor, ¤tBackColor, ¤tChar, clamp(thisCellPercent, 0, 100));
1677: plotCharWithColor(currentChar, i, j, ¤tForeColor, ¤tBackColor);
1678: }
1679: }
1680:
1681: fastForward = pauseBrogue(16);
1682: frame++;
1683: } while (frame <= frameCount && !fastForward);
1684: overlayDisplayBuffer(toBuf, NULL);
1685: }
1686:
1687: // takes dungeon coordinates
1688: void colorBlendCell(short x, short y, color *hiliteColor, short hiliteStrength) {
1689: enum displayGlyph displayChar;
1690: color foreColor, backColor;
1691:
1692: getCellAppearance(x, y, &displayChar, &foreColor, &backColor);
1693: applyColorAverage(&foreColor, hiliteColor, hiliteStrength);
1694: applyColorAverage(&backColor, hiliteColor, hiliteStrength);
1695: plotCharWithColor(displayChar, mapToWindowX(x), mapToWindowY(y), &foreColor, &backColor);
1696: }
1697:
1698: // takes dungeon coordinates
1699: void hiliteCell(short x, short y, const color *hiliteColor, short hiliteStrength, boolean distinctColors) {
1700: enum displayGlyph displayChar;
1701: color foreColor, backColor;
1702:
1703: assureCosmeticRNG;
1704:
1705: getCellAppearance(x, y, &displayChar, &foreColor, &backColor);
1706: applyColorAugment(&foreColor, hiliteColor, hiliteStrength);
1707: applyColorAugment(&backColor, hiliteColor, hiliteStrength);
1708: if (distinctColors) {
1709: separateColors(&foreColor, &backColor);
1710: }
1711: plotCharWithColor(displayChar, mapToWindowX(x), mapToWindowY(y), &foreColor, &backColor);
1712:
1713: restoreRNG;
1714: }
1715:
1716: short adjustedLightValue(short x) {
1717: if (x <= LIGHT_SMOOTHING_THRESHOLD) {
1718: return x;
1719: } else {
1720: return fp_sqrt(x * FP_FACTOR / LIGHT_SMOOTHING_THRESHOLD) * LIGHT_SMOOTHING_THRESHOLD / FP_FACTOR;
1721: }
1722: }
1723:
1724: void colorMultiplierFromDungeonLight(short x, short y, color *editColor) {
1725:
1726: editColor->red = editColor->redRand = adjustedLightValue(max(0, tmap[x][y].light[0]));
1727: editColor->green = editColor->greenRand = adjustedLightValue(max(0, tmap[x][y].light[1]));
1728: editColor->blue = editColor->blueRand = adjustedLightValue(max(0, tmap[x][y].light[2]));
1729:
1730: editColor->rand = adjustedLightValue(max(0, tmap[x][y].light[0] + tmap[x][y].light[1] + tmap[x][y].light[2]) / 3);
1731: editColor->colorDances = false;
1732: }
1733:
1734: void plotCharWithColor(enum displayGlyph inputChar, short xLoc, short yLoc, const color *cellForeColor, const color *cellBackColor) {
1735: short oldRNG;
1736:
1737: short foreRed = cellForeColor->red,
1738: foreGreen = cellForeColor->green,
1739: foreBlue = cellForeColor->blue,
1740:
1741: backRed = cellBackColor->red,
1742: backGreen = cellBackColor->green,
1743: backBlue = cellBackColor->blue,
1744:
1745: foreRand, backRand;
1746:
1747: brogueAssert(coordinatesAreInWindow(xLoc, yLoc));
1748:
1749: if (rogue.gameHasEnded || rogue.playbackFastForward) {
1750: return;
1751: }
1752:
1753: //assureCosmeticRNG;
1754: oldRNG = rogue.RNG;
1755: rogue.RNG = RNG_COSMETIC;
1756:
1757: foreRand = rand_range(0, cellForeColor->rand);
1758: backRand = rand_range(0, cellBackColor->rand);
1759: foreRed += rand_range(0, cellForeColor->redRand) + foreRand;
1760: foreGreen += rand_range(0, cellForeColor->greenRand) + foreRand;
1761: foreBlue += rand_range(0, cellForeColor->blueRand) + foreRand;
1762: backRed += rand_range(0, cellBackColor->redRand) + backRand;
1763: backGreen += rand_range(0, cellBackColor->greenRand) + backRand;
1764: backBlue += rand_range(0, cellBackColor->blueRand) + backRand;
1765:
1766: foreRed = min(100, max(0, foreRed));
1767: foreGreen = min(100, max(0, foreGreen));
1768: foreBlue = min(100, max(0, foreBlue));
1769: backRed = min(100, max(0, backRed));
1770: backGreen = min(100, max(0, backGreen));
1771: backBlue = min(100, max(0, backBlue));
1772:
1773: if (inputChar != ' '
1774: && foreRed == backRed
1775: && foreGreen == backGreen
1776: && foreBlue == backBlue) {
1777:
1778: inputChar = ' ';
1779: }
1780:
1781: if (inputChar != displayBuffer[xLoc][yLoc].character
1782: || foreRed != displayBuffer[xLoc][yLoc].foreColorComponents[0]
1783: || foreGreen != displayBuffer[xLoc][yLoc].foreColorComponents[1]
1784: || foreBlue != displayBuffer[xLoc][yLoc].foreColorComponents[2]
1785: || backRed != displayBuffer[xLoc][yLoc].backColorComponents[0]
1786: || backGreen != displayBuffer[xLoc][yLoc].backColorComponents[1]
1787: || backBlue != displayBuffer[xLoc][yLoc].backColorComponents[2]) {
1788:
1789: displayBuffer[xLoc][yLoc].needsUpdate = true;
1790:
1791: displayBuffer[xLoc][yLoc].character = inputChar;
1792: displayBuffer[xLoc][yLoc].foreColorComponents[0] = foreRed;
1793: displayBuffer[xLoc][yLoc].foreColorComponents[1] = foreGreen;
1794: displayBuffer[xLoc][yLoc].foreColorComponents[2] = foreBlue;
1795: displayBuffer[xLoc][yLoc].backColorComponents[0] = backRed;
1796: displayBuffer[xLoc][yLoc].backColorComponents[1] = backGreen;
1797: displayBuffer[xLoc][yLoc].backColorComponents[2] = backBlue;
1798: }
1799:
1800: restoreRNG;
1801: }
1802:
1803: void plotCharToBuffer(enum displayGlyph inputChar, short x, short y, color *foreColor, color *backColor, cellDisplayBuffer dbuf[COLS][ROWS]) {
1804: short oldRNG;
1805:
1806: if (!dbuf) {
1807: plotCharWithColor(inputChar, x, y, foreColor, backColor);
1808: return;
1809: }
1810:
1811: brogueAssert(coordinatesAreInWindow(x, y));
1812:
1813: oldRNG = rogue.RNG;
1814: rogue.RNG = RNG_COSMETIC;
1815: //assureCosmeticRNG;
1816: dbuf[x][y].foreColorComponents[0] = foreColor->red + rand_range(0, foreColor->redRand) + rand_range(0, foreColor->rand);
1817: dbuf[x][y].foreColorComponents[1] = foreColor->green + rand_range(0, foreColor->greenRand) + rand_range(0, foreColor->rand);
1818: dbuf[x][y].foreColorComponents[2] = foreColor->blue + rand_range(0, foreColor->blueRand) + rand_range(0, foreColor->rand);
1819: dbuf[x][y].backColorComponents[0] = backColor->red + rand_range(0, backColor->redRand) + rand_range(0, backColor->rand);
1820: dbuf[x][y].backColorComponents[1] = backColor->green + rand_range(0, backColor->greenRand) + rand_range(0, backColor->rand);
1821: dbuf[x][y].backColorComponents[2] = backColor->blue + rand_range(0, backColor->blueRand) + rand_range(0, backColor->rand);
1822: dbuf[x][y].character = inputChar;
1823: dbuf[x][y].opacity = 100;
1824: restoreRNG;
1825: }
1826:
1827: void plotForegroundChar(enum displayGlyph inputChar, short x, short y, color *foreColor, boolean affectedByLighting) {
1828: color multColor, myColor, backColor, ignoredColor;
1829: enum displayGlyph ignoredChar;
1830:
1831: myColor = *foreColor;
1832: getCellAppearance(x, y, &ignoredChar, &ignoredColor, &backColor);
1833: if (affectedByLighting) {
1834: colorMultiplierFromDungeonLight(x, y, &multColor);
1835: applyColorMultiplier(&myColor, &multColor);
1836: }
1837: plotCharWithColor(inputChar, mapToWindowX(x), mapToWindowY(y), &myColor, &backColor);
1838: }
1839:
1840: // Set to false and draws don't take effect, they simply queue up. Set to true and all of the
1841: // queued up draws take effect.
1842: void commitDraws() {
1843: short i, j;
1844:
1845: for (j=0; j<ROWS; j++) {
1846: for (i=0; i<COLS; i++) {
1847: if (displayBuffer[i][j].needsUpdate) {
1848: plotChar(displayBuffer[i][j].character, i, j,
1849: displayBuffer[i][j].foreColorComponents[0],
1850: displayBuffer[i][j].foreColorComponents[1],
1851: displayBuffer[i][j].foreColorComponents[2],
1852: displayBuffer[i][j].backColorComponents[0],
1853: displayBuffer[i][j].backColorComponents[1],
1854: displayBuffer[i][j].backColorComponents[2]);
1855: displayBuffer[i][j].needsUpdate = false;
1856: }
1857: }
1858: }
1859: }
1860:
1861: // Debug feature: display the level to the screen without regard to lighting, field of view, etc.
1862: void dumpLevelToScreen() {
1863: short i, j;
1864: pcell backup;
1865:
1866: assureCosmeticRNG;
1867: for (i=0; i<DCOLS; i++) {
1868: for (j=0; j<DROWS; j++) {
1869: if (pmap[i][j].layers[DUNGEON] != GRANITE
1870: || (pmap[i][j].flags & DISCOVERED)) {
1871:
1872: backup = pmap[i][j];
1873: pmap[i][j].flags |= (VISIBLE | DISCOVERED);
1874: tmap[i][j].light[0] = 100;
1875: tmap[i][j].light[1] = 100;
1876: tmap[i][j].light[2] = 100;
1877: refreshDungeonCell(i, j);
1878: pmap[i][j] = backup;
1879: } else {
1880: plotCharWithColor(' ', mapToWindowX(i), mapToWindowY(j), &white, &black);
1881: }
1882:
1883: }
1884: }
1885: restoreRNG;
1886: }
1887:
1888: // To be used immediately after dumpLevelToScreen() above.
1889: // Highlight the portion indicated by hiliteCharGrid with the hiliteColor at the hiliteStrength -- both latter arguments are optional.
1890: void hiliteCharGrid(char hiliteCharGrid[DCOLS][DROWS], color *hiliteColor, short hiliteStrength) {
1891: short i, j, x, y;
1892: color hCol;
1893:
1894: assureCosmeticRNG;
1895:
1896: if (hiliteColor) {
1897: hCol = *hiliteColor;
1898: } else {
1899: hCol = yellow;
1900: }
1901:
1902: bakeColor(&hCol);
1903:
1904: if (!hiliteStrength) {
1905: hiliteStrength = 75;
1906: }
1907:
1908: for (i=0; i<DCOLS; i++) {
1909: for (j=0; j<DROWS; j++) {
1910: if (hiliteCharGrid[i][j]) {
1911: x = mapToWindowX(i);
1912: y = mapToWindowY(j);
1913:
1914: displayBuffer[x][y].needsUpdate = true;
1915: displayBuffer[x][y].backColorComponents[0] = clamp(displayBuffer[x][y].backColorComponents[0] + hCol.red * hiliteStrength / 100, 0, 100);
1916: displayBuffer[x][y].backColorComponents[1] = clamp(displayBuffer[x][y].backColorComponents[1] + hCol.green * hiliteStrength / 100, 0, 100);
1917: displayBuffer[x][y].backColorComponents[2] = clamp(displayBuffer[x][y].backColorComponents[2] + hCol.blue * hiliteStrength / 100, 0, 100);
1918: displayBuffer[x][y].foreColorComponents[0] = clamp(displayBuffer[x][y].foreColorComponents[0] + hCol.red * hiliteStrength / 100, 0, 100);
1919: displayBuffer[x][y].foreColorComponents[1] = clamp(displayBuffer[x][y].foreColorComponents[1] + hCol.green * hiliteStrength / 100, 0, 100);
1920: displayBuffer[x][y].foreColorComponents[2] = clamp(displayBuffer[x][y].foreColorComponents[2] + hCol.blue * hiliteStrength / 100, 0, 100);
1921: }
1922: }
1923: }
1924: restoreRNG;
1925: }
1926:
1927: void blackOutScreen() {
1928: short i, j;
1929:
1930: for (i=0; i<COLS; i++) {
1931: for (j=0; j<ROWS; j++) {
1932: plotCharWithColor(' ', i, j, &black, &black);
1933: }
1934: }
1935: }
1936:
1937: void colorOverDungeon(const color *color) {
1938: short i, j;
1939:
1940: for (i=0; i<DCOLS; i++) {
1941: for (j=0; j<DROWS; j++) {
1942: plotCharWithColor(' ', mapToWindowX(i), mapToWindowY(j), color, color);
1943: }
1944: }
1945: }
1946:
1947: void copyDisplayBuffer(cellDisplayBuffer toBuf[COLS][ROWS], cellDisplayBuffer fromBuf[COLS][ROWS]) {
1948: short i, j;
1949:
1950: for (i=0; i<COLS; i++) {
1951: for (j=0; j<ROWS; j++) {
1952: toBuf[i][j] = fromBuf[i][j];
1953: }
1954: }
1955: }
1956:
1957: void clearDisplayBuffer(cellDisplayBuffer dbuf[COLS][ROWS]) {
1958: short i, j, k;
1959:
1960: for (i=0; i<COLS; i++) {
1961: for (j=0; j<ROWS; j++) {
1962: dbuf[i][j].character = ' ';
1963: for (k=0; k<3; k++) {
1964: dbuf[i][j].foreColorComponents[k] = 0;
1965: dbuf[i][j].backColorComponents[k] = 0;
1966: }
1967: dbuf[i][j].opacity = 0;
1968: }
1969: }
1970: }
1971:
1972: color colorFromComponents(char rgb[3]) {
1973: color theColor = black;
1974: theColor.red = rgb[0];
1975: theColor.green = rgb[1];
1976: theColor.blue = rgb[2];
1977: return theColor;
1978: }
1979:
1980: // draws overBuf over the current display with per-cell pseudotransparency as specified in overBuf.
1981: // If previousBuf is not null, it gets filled with the preexisting display for reversion purposes.
1982: void overlayDisplayBuffer(cellDisplayBuffer overBuf[COLS][ROWS], cellDisplayBuffer previousBuf[COLS][ROWS]) {
1983: short i, j;
1984: color foreColor, backColor, tempColor;
1985: enum displayGlyph character;
1986:
1987: if (previousBuf) {
1988: copyDisplayBuffer(previousBuf, displayBuffer);
1989: }
1990:
1991: for (i=0; i<COLS; i++) {
1992: for (j=0; j<ROWS; j++) {
1993:
1994: if (overBuf[i][j].opacity != 0) {
1995: backColor = colorFromComponents(overBuf[i][j].backColorComponents);
1996:
1997: // character and fore color:
1998: if (overBuf[i][j].character == ' ') { // Blank cells in the overbuf take the character from the screen.
1999: character = displayBuffer[i][j].character;
2000: foreColor = colorFromComponents(displayBuffer[i][j].foreColorComponents);
2001: applyColorAverage(&foreColor, &backColor, overBuf[i][j].opacity);
2002: } else {
2003: character = overBuf[i][j].character;
2004: foreColor = colorFromComponents(overBuf[i][j].foreColorComponents);
2005: }
2006:
2007: // back color:
2008: tempColor = colorFromComponents(displayBuffer[i][j].backColorComponents);
2009: applyColorAverage(&backColor, &tempColor, 100 - overBuf[i][j].opacity);
2010:
2011: plotCharWithColor(character, i, j, &foreColor, &backColor);
2012: }
2013: }
2014: }
2015: }
2016:
2017: // Takes a list of locations, a color and a list of strengths and flashes the foregrounds of those locations.
2018: // Strengths are percentages measuring how hard the color flashes at its peak.
2019: void flashForeground(short *x, short *y, color **flashColor, short *flashStrength, short count, short frames) {
2020: short i, j, percent;
2021: enum displayGlyph *displayChar;
2022: color *bColor, *fColor, newColor;
2023: short oldRNG;
2024:
2025: if (count <= 0) {
2026: return;
2027: }
2028:
2029: oldRNG = rogue.RNG;
2030: rogue.RNG = RNG_COSMETIC;
2031: //assureCosmeticRNG;
2032:
2033: displayChar = (enum displayGlyph *) malloc(count * sizeof(enum displayGlyph));
2034: fColor = (color *) malloc(count * sizeof(color));
2035: bColor = (color *) malloc(count * sizeof(color));
2036:
2037: for (i=0; i<count; i++) {
2038: getCellAppearance(x[i], y[i], &displayChar[i], &fColor[i], &bColor[i]);
2039: bakeColor(&fColor[i]);
2040: bakeColor(&bColor[i]);
2041: }
2042:
2043: for (j=frames; j>= 0; j--) {
2044: for (i=0; i<count; i++) {
2045: percent = flashStrength[i] * j / frames;
2046: newColor = fColor[i];
2047: applyColorAverage(&newColor, flashColor[i], percent);
2048: plotCharWithColor(displayChar[i], mapToWindowX(x[i]), mapToWindowY(y[i]), &newColor, &(bColor[i]));
2049: }
2050: if (j) {
2051: if (pauseBrogue(16)) {
2052: j = 1;
2053: }
2054: }
2055: }
2056:
2057: free(displayChar);
2058: free(fColor);
2059: free(bColor);
2060:
2061: restoreRNG;
2062: }
2063:
2064: void flashCell(color *theColor, short frames, short x, short y) {
2065: short i;
2066: boolean interrupted = false;
2067:
2068: for (i=0; i<frames && !interrupted; i++) {
2069: colorBlendCell(x, y, theColor, 100 - 100 * i / frames);
2070: interrupted = pauseBrogue(50);
2071: }
2072:
2073: refreshDungeonCell(x, y);
2074: }
2075:
2076: // special effect expanding flash of light at dungeon coordinates (x, y) restricted to tiles with matching flags
2077: void colorFlash(const color *theColor, unsigned long reqTerrainFlags,
2078: unsigned long reqTileFlags, short frames, short maxRadius, short x, short y) {
2079: short i, j, k, intensity, currentRadius, fadeOut;
2080: short localRadius[DCOLS][DROWS];
2081: boolean tileQualifies[DCOLS][DROWS], aTileQualified, fastForward;
2082:
2083: aTileQualified = false;
2084: fastForward = false;
2085:
2086: for (i = max(x - maxRadius, 0); i <= min(x + maxRadius, DCOLS - 1); i++) {
2087: for (j = max(y - maxRadius, 0); j <= min(y + maxRadius, DROWS - 1); j++) {
2088: if ((!reqTerrainFlags || cellHasTerrainFlag(reqTerrainFlags, i, j))
2089: && (!reqTileFlags || (pmap[i][j].flags & reqTileFlags))
2090: && (i-x) * (i-x) + (j-y) * (j-y) <= maxRadius * maxRadius) {
2091:
2092: tileQualifies[i][j] = true;
2093: localRadius[i][j] = fp_sqrt(((i-x) * (i-x) + (j-y) * (j-y)) * FP_FACTOR) / FP_FACTOR;
2094: aTileQualified = true;
2095: } else {
2096: tileQualifies[i][j] = false;
2097: }
2098: }
2099: }
2100:
2101: if (!aTileQualified) {
2102: return;
2103: }
2104:
2105: for (k = 1; k <= frames; k++) {
2106: currentRadius = max(1, maxRadius * k / frames);
2107: fadeOut = min(100, (frames - k) * 100 * 5 / frames);
2108: for (i = max(x - maxRadius, 0); i <= min(x + maxRadius, DCOLS - 1); i++) {
2109: for (j = max(y - maxRadius, 0); j <= min(y + maxRadius, DROWS - 1); j++) {
2110: if (tileQualifies[i][j] && (localRadius[i][j] <= currentRadius)) {
2111:
2112: intensity = 100 - 100 * (currentRadius - localRadius[i][j] - 2) / currentRadius;
2113: intensity = fadeOut * intensity / 100;
2114:
2115: hiliteCell(i, j, theColor, intensity, false);
2116: }
2117: }
2118: }
2119: if (!fastForward && (rogue.playbackFastForward || pauseBrogue(50))) {
2120: k = frames - 1;
2121: fastForward = true;
2122: }
2123: }
2124: }
2125:
2126: #define bCurve(x) (((x) * (x) + 11) / (10 * ((x) * (x) + 1)) - 0.1)
2127:
2128: // x and y are global coordinates, not within the playing square
2129: void funkyFade(cellDisplayBuffer displayBuf[COLS][ROWS], const color *colorStart,
2130: const color *colorEnd, short stepCount, short x, short y, boolean invert) {
2131: short i, j, n, weight;
2132: double x2, y2, weightGrid[COLS][ROWS][3], percentComplete;
2133: color tempColor, colorMid, foreColor, backColor;
2134: enum displayGlyph tempChar;
2135: short **distanceMap;
2136: boolean fastForward;
2137:
2138: assureCosmeticRNG;
2139:
2140: fastForward = false;
2141: distanceMap = allocGrid();
2142: fillGrid(distanceMap, 0);
2143: calculateDistances(distanceMap, player.xLoc, player.yLoc, T_OBSTRUCTS_PASSABILITY, 0, true, true);
2144:
2145: for (i=0; i<COLS; i++) {
2146: x2 = (double) ((i - x) * 5.0 / COLS);
2147: for (j=0; j<ROWS; j++) {
2148: y2 = (double) ((j - y) * 2.5 / ROWS);
2149:
2150: weightGrid[i][j][0] = bCurve(x2*x2+y2*y2) * (.7 + .3 * cos(5*x2*x2) * cos(5*y2*y2));
2151: weightGrid[i][j][1] = bCurve(x2*x2+y2*y2) * (.7 + .3 * sin(5*x2*x2) * cos(5*y2*y2));
2152: weightGrid[i][j][2] = bCurve(x2*x2+y2*y2);
2153: }
2154: }
2155:
2156: for (n=(invert ? stepCount - 1 : 0); (invert ? n >= 0 : n <= stepCount); n += (invert ? -1 : 1)) {
2157: for (i=0; i<COLS; i++) {
2158: for (j=0; j<ROWS; j++) {
2159:
2160: percentComplete = (double) (n) * 100 / stepCount;
2161:
2162: colorMid = *colorStart;
2163: if (colorEnd) {
2164: applyColorAverage(&colorMid, colorEnd, n * 100 / stepCount);
2165: }
2166:
2167: // the fade color floods the reachable dungeon tiles faster
2168: if (!invert && coordinatesAreInMap(windowToMapX(i), windowToMapY(j))
2169: && distanceMap[windowToMapX(i)][windowToMapY(j)] >= 0 && distanceMap[windowToMapX(i)][windowToMapY(j)] < 30000) {
2170: percentComplete *= 1.0 + (100.0 - min(100, distanceMap[windowToMapX(i)][windowToMapY(j)])) / 100.;
2171: }
2172:
2173: weight = (short)(percentComplete + weightGrid[i][j][2] * percentComplete * 10);
2174: weight = min(100, weight);
2175: tempColor = black;
2176:
2177: tempColor.red = (short)(percentComplete + weightGrid[i][j][0] * percentComplete * 10) * colorMid.red / 100;
2178: tempColor.red = min(colorMid.red, tempColor.red);
2179:
2180: tempColor.green = (short)(percentComplete + weightGrid[i][j][1] * percentComplete * 10) * colorMid.green / 100;
2181: tempColor.green = min(colorMid.green, tempColor.green);
2182:
2183: tempColor.blue = (short)(percentComplete + weightGrid[i][j][2] * percentComplete * 10) * colorMid.blue / 100;
2184: tempColor.blue = min(colorMid.blue, tempColor.blue);
2185:
2186: backColor = black;
2187:
2188: backColor.red = displayBuf[i][j].backColorComponents[0];
2189: backColor.green = displayBuf[i][j].backColorComponents[1];
2190: backColor.blue = displayBuf[i][j].backColorComponents[2];
2191:
2192: foreColor = (invert ? white : black);
2193:
2194: if (j < MESSAGE_LINES
2195: && i >= mapToWindowX(0)
2196: && i < mapToWindowX(strLenWithoutEscapes(displayedMessage[MESSAGE_LINES - j - 1]))) {
2197: tempChar = displayedMessage[MESSAGE_LINES - j - 1][windowToMapX(i)];
2198: } else {
2199: tempChar = displayBuf[i][j].character;
2200:
2201: foreColor.red = displayBuf[i][j].foreColorComponents[0];
2202: foreColor.green = displayBuf[i][j].foreColorComponents[1];
2203: foreColor.blue = displayBuf[i][j].foreColorComponents[2];
2204:
2205: applyColorAverage(&foreColor, &tempColor, weight);
2206: }
2207: applyColorAverage(&backColor, &tempColor, weight);
2208: plotCharWithColor(tempChar, i, j, &foreColor, &backColor);
2209: }
2210: }
2211: if (!fastForward && pauseBrogue(16)) {
2212: // drop the event - skipping the transition should only skip the transition
2213: rogueEvent event;
2214: nextKeyOrMouseEvent(&event, false, false);
2215: fastForward = true;
2216: n = (invert ? 1 : stepCount - 2);
2217: }
2218: }
2219:
2220: freeGrid(distanceMap);
2221:
2222: restoreRNG;
2223: }
2224:
2225: void displayWaypoints() {
2226: short i, j, w, lowestDistance;
2227:
2228: for (i=0; i<DCOLS; i++) {
2229: for (j=0; j<DROWS; j++) {
2230: lowestDistance = 30000;
2231: for (w=0; w<rogue.wpCount; w++) {
2232: if (rogue.wpDistance[w][i][j] < lowestDistance) {
2233: lowestDistance = rogue.wpDistance[w][i][j];
2234: }
2235: }
2236: if (lowestDistance < 10) {
2237: hiliteCell(i, j, &white, clamp(100 - lowestDistance*15, 0, 100), true);
2238: }
2239: }
2240: }
2241: temporaryMessage("Waypoints:", true);
2242: }
2243:
2244: void displayMachines() {
2245: short i, j;
2246: color foreColor, backColor, machineColors[50];
2247: enum displayGlyph dchar;
2248:
2249: assureCosmeticRNG;
2250:
2251: for (i=0; i<50; i++) {
2252: machineColors[i] = black;
2253: machineColors[i].red = rand_range(0, 100);
2254: machineColors[i].green = rand_range(0, 100);
2255: machineColors[i].blue = rand_range(0, 100);
2256: }
2257:
2258: for (i=0; i<DCOLS; i++) {
2259: for (j=0; j<DROWS; j++) {
2260: if (pmap[i][j].machineNumber) {
2261: getCellAppearance(i, j, &dchar, &foreColor, &backColor);
2262: applyColorAugment(&backColor, &(machineColors[pmap[i][j].machineNumber]), 50);
2263: //plotCharWithColor(dchar, mapToWindowX(i), mapToWindowY(j), &foreColor, &backColor);
2264: if (pmap[i][j].machineNumber < 10) {
2265: dchar ='0' + pmap[i][j].machineNumber;
2266: } else if (pmap[i][j].machineNumber < 10 + 26) {
2267: dchar = 'a' + pmap[i][j].machineNumber - 10;
2268: } else {
2269: dchar = 'A' + pmap[i][j].machineNumber - 10 - 26;
2270: }
2271: plotCharWithColor(dchar, mapToWindowX(i), mapToWindowY(j), &foreColor, &backColor);
2272: }
2273: }
2274: }
2275: displayMoreSign();
2276: displayLevel();
2277:
2278: restoreRNG;
2279: }
2280:
2281: #define CHOKEMAP_DISPLAY_CUTOFF 160
2282: void displayChokeMap() {
2283: short i, j;
2284: color foreColor, backColor;
2285: enum displayGlyph dchar;
2286:
2287: for (i=0; i<DCOLS; i++) {
2288: for (j=0; j<DROWS; j++) {
2289: if (chokeMap[i][j] < CHOKEMAP_DISPLAY_CUTOFF) {
2290: if (pmap[i][j].flags & IS_GATE_SITE) {
2291: getCellAppearance(i, j, &dchar, &foreColor, &backColor);
2292: applyColorAugment(&backColor, &teal, 50);
2293: plotCharWithColor(dchar, mapToWindowX(i), mapToWindowY(j), &foreColor, &backColor);
2294: } else
2295: if (chokeMap[i][j] < CHOKEMAP_DISPLAY_CUTOFF) {
2296: getCellAppearance(i, j, &dchar, &foreColor, &backColor);
2297: applyColorAugment(&backColor, &red, 100 - chokeMap[i][j] * 100 / CHOKEMAP_DISPLAY_CUTOFF);
2298: plotCharWithColor(dchar, mapToWindowX(i), mapToWindowY(j), &foreColor, &backColor);
2299: }
2300: }
2301: }
2302: }
2303: displayMoreSign();
2304: displayLevel();
2305: }
2306:
2307: void displayLoops() {
2308: short i, j;
2309: color foreColor, backColor;
2310: enum displayGlyph dchar;
2311:
2312: for (i=0; i<DCOLS; i++) {
2313: for (j=0; j<DROWS; j++) {
2314: if (pmap[i][j].flags & IN_LOOP) {
2315: getCellAppearance(i, j, &dchar, &foreColor, &backColor);
2316: applyColorAugment(&backColor, &yellow, 50);
2317: plotCharWithColor(dchar, mapToWindowX(i), mapToWindowY(j), &foreColor, &backColor);
2318: //colorBlendCell(i, j, &tempColor, 100);//hiliteCell(i, j, &tempColor, 100, true);
2319: }
2320: if (pmap[i][j].flags & IS_CHOKEPOINT) {
2321: getCellAppearance(i, j, &dchar, &foreColor, &backColor);
2322: applyColorAugment(&backColor, &teal, 50);
2323: plotCharWithColor(dchar, mapToWindowX(i), mapToWindowY(j), &foreColor, &backColor);
2324: }
2325: }
2326: }
2327: waitForAcknowledgment();
2328: }
2329:
2330: void exploreKey(const boolean controlKey) {
2331: short x, y, finalX = 0, finalY = 0;
2332: short **exploreMap;
2333: enum directions dir;
2334: boolean tooDark = false;
2335:
2336: // fight any adjacent enemies first
2337: dir = adjacentFightingDir();
2338: if (dir == NO_DIRECTION) {
2339: for (dir = 0; dir < DIRECTION_COUNT; dir++) {
2340: x = player.xLoc + nbDirs[dir][0];
2341: y = player.yLoc + nbDirs[dir][1];
2342: if (coordinatesAreInMap(x, y)
2343: && !(pmap[x][y].flags & DISCOVERED)) {
2344:
2345: tooDark = true;
2346: break;
2347: }
2348: }
2349: if (!tooDark) {
2350: x = finalX = player.xLoc;
2351: y = finalY = player.yLoc;
2352:
2353: exploreMap = allocGrid();
2354: getExploreMap(exploreMap, false);
2355: do {
2356: dir = nextStep(exploreMap, x, y, NULL, false);
2357: if (dir != NO_DIRECTION) {
2358: x += nbDirs[dir][0];
2359: y += nbDirs[dir][1];
2360: if (pmap[x][y].flags & (DISCOVERED | MAGIC_MAPPED)) {
2361: finalX = x;
2362: finalY = y;
2363: }
2364: }
2365: } while (dir != NO_DIRECTION);
2366: freeGrid(exploreMap);
2367: }
2368: } else {
2369: x = finalX = player.xLoc + nbDirs[dir][0];
2370: y = finalY = player.yLoc + nbDirs[dir][1];
2371: }
2372:
2373: if (tooDark) {
2374: message("It's too dark to explore!", false);
2375: } else if (x == player.xLoc && y == player.yLoc) {
2376: message("I see no path for further exploration.", false);
2377: } else if (proposeOrConfirmLocation(finalX, finalY, "I see no path for further exploration.")) {
2378: explore(controlKey ? 1 : 20); // Do the exploring until interrupted.
2379: hideCursor();
2380: exploreKey(controlKey);
2381: }
2382: }
2383:
2384: boolean pauseBrogue(short milliseconds) {
2385: boolean interrupted;
2386:
2387: commitDraws();
2388: if (rogue.playbackMode && rogue.playbackFastForward) {
2389: interrupted = true;
2390: } else {
2391: interrupted = pauseForMilliseconds(milliseconds);
2392: }
2393: return interrupted;
2394: }
2395:
2396: void nextBrogueEvent(rogueEvent *returnEvent, boolean textInput, boolean colorsDance, boolean realInputEvenInPlayback) {
2397: rogueEvent recordingInput;
2398: boolean repeatAgain, interaction;
2399: short pauseDuration;
2400:
2401: returnEvent->eventType = EVENT_ERROR;
2402:
2403: if (rogue.playbackMode && !realInputEvenInPlayback) {
2404: do {
2405: repeatAgain = false;
2406: if ((!rogue.playbackFastForward && rogue.playbackBetweenTurns)
2407: || rogue.playbackOOS) {
2408:
2409: pauseDuration = (rogue.playbackPaused ? DEFAULT_PLAYBACK_DELAY : rogue.playbackDelayThisTurn);
2410: if (pauseDuration && pauseBrogue(pauseDuration)) {
2411: // if the player did something during playback
2412: nextBrogueEvent(&recordingInput, false, false, true);
2413: interaction = executePlaybackInput(&recordingInput);
2414: repeatAgain = !rogue.playbackPaused && interaction;
2415: }
2416: }
2417: } while ((repeatAgain || rogue.playbackOOS) && !rogue.gameHasEnded);
2418: rogue.playbackDelayThisTurn = rogue.playbackDelayPerTurn;
2419: recallEvent(returnEvent);
2420: } else {
2421: commitDraws();
2422: if (rogue.creaturesWillFlashThisTurn) {
2423: displayMonsterFlashes(true);
2424: }
2425: do {
2426: nextKeyOrMouseEvent(returnEvent, textInput, colorsDance); // No mouse clicks outside of the window will register.
2427: } while (returnEvent->eventType == MOUSE_UP && !coordinatesAreInWindow(returnEvent->param1, returnEvent->param2));
2428: // recording done elsewhere
2429: }
2430:
2431: if (returnEvent->eventType == EVENT_ERROR) {
2432: rogue.playbackPaused = rogue.playbackMode; // pause if replaying
2433: message("Event error!", true);
2434: }
2435: }
2436:
2437: void executeMouseClick(rogueEvent *theEvent) {
2438: short x, y;
2439: boolean autoConfirm;
2440: x = theEvent->param1;
2441: y = theEvent->param2;
2442: autoConfirm = theEvent->controlKey;
2443:
2444: if (theEvent->eventType == RIGHT_MOUSE_UP) {
2445: displayInventory(ALL_ITEMS, 0, 0, true, true);
2446: } else if (coordinatesAreInMap(windowToMapX(x), windowToMapY(y))) {
2447: if (autoConfirm) {
2448: travel(windowToMapX(x), windowToMapY(y), autoConfirm);
2449: } else {
2450: rogue.cursorLoc[0] = windowToMapX(x);
2451: rogue.cursorLoc[1] = windowToMapY(y);
2452: mainInputLoop();
2453: }
2454:
2455: } else if (windowToMapX(x) >= 0 && windowToMapX(x) < DCOLS && y >= 0 && y < MESSAGE_LINES) {
2456: // If the click location is in the message block, display the message archive.
2457: displayMessageArchive();
2458: }
2459: }
2460:
2461: void executeKeystroke(signed long keystroke, boolean controlKey, boolean shiftKey) {
2462: char path[BROGUE_FILENAME_MAX];
2463: short direction = -1;
2464:
2465: confirmMessages();
2466: stripShiftFromMovementKeystroke(&keystroke);
2467:
2468: switch (keystroke) {
2469: case UP_KEY:
2470: case UP_ARROW:
2471: case NUMPAD_8:
2472: direction = UP;
2473: break;
2474: case DOWN_KEY:
2475: case DOWN_ARROW:
2476: case NUMPAD_2:
2477: direction = DOWN;
2478: break;
2479: case LEFT_KEY:
2480: case LEFT_ARROW:
2481: case NUMPAD_4:
2482: direction = LEFT;
2483: break;
2484: case RIGHT_KEY:
2485: case RIGHT_ARROW:
2486: case NUMPAD_6:
2487: direction = RIGHT;
2488: break;
2489: case NUMPAD_7:
2490: case UPLEFT_KEY:
2491: direction = UPLEFT;
2492: break;
2493: case UPRIGHT_KEY:
2494: case NUMPAD_9:
2495: direction = UPRIGHT;
2496: break;
2497: case DOWNLEFT_KEY:
2498: case NUMPAD_1:
2499: direction = DOWNLEFT;
2500: break;
2501: case DOWNRIGHT_KEY:
2502: case NUMPAD_3:
2503: direction = DOWNRIGHT;
2504: break;
2505: case DESCEND_KEY:
2506: considerCautiousMode();
2507: if (D_WORMHOLING) {
2508: recordKeystroke(DESCEND_KEY, false, false);
2509: useStairs(1);
2510: } else if (proposeOrConfirmLocation(rogue.downLoc[0], rogue.downLoc[1], "I see no way down.")) {
2511: travel(rogue.downLoc[0], rogue.downLoc[1], true);
2512: }
2513: break;
2514: case ASCEND_KEY:
2515: considerCautiousMode();
2516: if (D_WORMHOLING) {
2517: recordKeystroke(ASCEND_KEY, false, false);
2518: useStairs(-1);
2519: } else if (proposeOrConfirmLocation(rogue.upLoc[0], rogue.upLoc[1], "I see no way up.")) {
2520: travel(rogue.upLoc[0], rogue.upLoc[1], true);
2521: }
2522: break;
2523: case RETURN_KEY:
2524: showCursor();
2525: break;
2526: case REST_KEY:
2527: case PERIOD_KEY:
2528: case NUMPAD_5:
2529: considerCautiousMode();
2530: rogue.justRested = true;
2531: recordKeystroke(REST_KEY, false, false);
2532: playerTurnEnded();
2533: break;
2534: case AUTO_REST_KEY:
2535: rogue.justRested = true;
2536: autoRest();
2537: break;
2538: case SEARCH_KEY:
2539: if (controlKey) {
2540: rogue.disturbed = false;
2541: rogue.automationActive = true;
2542: do {
2543: manualSearch();
2544: if (pauseBrogue(80)) {
2545: rogue.disturbed = true;
2546: }
2547: } while (player.status[STATUS_SEARCHING] < 5 && !rogue.disturbed);
2548: rogue.automationActive = false;
2549: } else {
2550: manualSearch();
2551: }
2552: break;
2553: case INVENTORY_KEY:
2554: displayInventory(ALL_ITEMS, 0, 0, true, true);
2555: break;
2556: case EQUIP_KEY:
2557: equip(NULL);
2558: break;
2559: case UNEQUIP_KEY:
2560: unequip(NULL);
2561: break;
2562: case DROP_KEY:
2563: drop(NULL);
2564: break;
2565: case APPLY_KEY:
2566: apply(NULL, true);
2567: break;
2568: case THROW_KEY:
2569: throwCommand(NULL, false);
2570: break;
2571: case RETHROW_KEY:
2572: if (rogue.lastItemThrown != NULL && itemIsCarried(rogue.lastItemThrown)) {
2573: throwCommand(rogue.lastItemThrown, true);
2574: }
2575: break;
2576: case RELABEL_KEY:
2577: relabel(NULL);
2578: break;
2579: case TRUE_COLORS_KEY:
2580: rogue.trueColorMode = !rogue.trueColorMode;
2581: displayLevel();
2582: refreshSideBar(-1, -1, false);
2583: if (rogue.trueColorMode) {
2584: messageWithColor(KEYBOARD_LABELS ? "Color effects disabled. Press '\\' again to enable." : "Color effects disabled.",
2585: &teal, false);
2586: } else {
2587: messageWithColor(KEYBOARD_LABELS ? "Color effects enabled. Press '\\' again to disable." : "Color effects enabled.",
2588: &teal, false);
2589: }
2590: break;
2591: case AGGRO_DISPLAY_KEY:
2592: rogue.displayAggroRangeMode = !rogue.displayAggroRangeMode;
2593: displayLevel();
2594: refreshSideBar(-1, -1, false);
2595: if (rogue.displayAggroRangeMode) {
2596: messageWithColor(KEYBOARD_LABELS ? "Stealth range displayed. Press ']' again to hide." : "Stealth range displayed.",
2597: &teal, false);
2598: } else {
2599: messageWithColor(KEYBOARD_LABELS ? "Stealth range hidden. Press ']' again to display." : "Stealth range hidden.",
2600: &teal, false);
2601: }
2602: break;
2603: case CALL_KEY:
2604: call(NULL);
2605: break;
2606: case EXPLORE_KEY:
2607: considerCautiousMode();
2608: exploreKey(controlKey);
2609: break;
2610: case AUTOPLAY_KEY:
2611: if (confirm("Turn on autopilot?", false)) {
2612: autoPlayLevel(controlKey);
2613: }
2614: break;
2615: case MESSAGE_ARCHIVE_KEY:
2616: displayMessageArchive();
2617: break;
2618: case BROGUE_HELP_KEY:
2619: printHelpScreen();
2620: break;
2621: case DISCOVERIES_KEY:
2622: printDiscoveriesScreen();
2623: break;
2624: case VIEW_RECORDING_KEY:
2625: if (rogue.playbackMode || serverMode) {
2626: return;
2627: }
2628: confirmMessages();
2629: if ((rogue.playerTurnNumber < 50 || confirm("End this game and view a recording?", false))
2630: && dialogChooseFile(path, RECORDING_SUFFIX, "View recording: ")) {
2631: if (fileExists(path)) {
2632: strcpy(rogue.nextGamePath, path);
2633: rogue.nextGame = NG_VIEW_RECORDING;
2634: rogue.gameHasEnded = true;
2635: } else {
2636: message("File not found.", false);
2637: }
2638: }
2639: break;
2640: case LOAD_SAVED_GAME_KEY:
2641: if (rogue.playbackMode || serverMode) {
2642: return;
2643: }
2644: confirmMessages();
2645: if ((rogue.playerTurnNumber < 50 || confirm("End this game and load a saved game?", false))
2646: && dialogChooseFile(path, GAME_SUFFIX, "Open saved game: ")) {
2647: if (fileExists(path)) {
2648: strcpy(rogue.nextGamePath, path);
2649: rogue.nextGame = NG_OPEN_GAME;
2650: rogue.gameHasEnded = true;
2651: } else {
2652: message("File not found.", false);
2653: }
2654: }
2655: break;
2656: case SAVE_GAME_KEY:
2657: if (rogue.playbackMode || serverMode) {
2658: return;
2659: }
2660: if (confirm("Suspend this game? (This feature is still in beta.)", false)) {
2661: saveGame();
2662: }
2663: break;
2664: case NEW_GAME_KEY:
2665: if (rogue.playerTurnNumber < 50 || confirm("End this game and begin a new game?", false)) {
2666: rogue.nextGame = NG_NEW_GAME;
2667: rogue.gameHasEnded = true;
2668: }
2669: break;
2670: case QUIT_KEY:
2671: if (confirm("Quit this game without saving?", false)) {
2672: recordKeystroke(QUIT_KEY, false, false);
2673: rogue.quit = true;
2674: gameOver("Quit", true);
2675: }
2676: break;
2677: case GRAPHICS_KEY:
2678: if (hasGraphics) {
2679: graphicsEnabled = setGraphicsEnabled(!graphicsEnabled);
2680: if (graphicsEnabled) {
2681: messageWithColor(KEYBOARD_LABELS ? "Enabled graphical tiles. Press 'G' again to disable." : "Enable graphical tiles.",
2682: &teal, false);
2683: } else {
2684: messageWithColor(KEYBOARD_LABELS ? "Disabled graphical tiles. Press 'G' again to enable." : "Disabled graphical tiles.",
2685: &teal, false);
2686: }
2687: }
2688: break;
2689: case SEED_KEY:
2690: /*DEBUG {
2691: cellDisplayBuffer dbuf[COLS][ROWS];
2692: copyDisplayBuffer(dbuf, displayBuffer);
2693: funkyFade(dbuf, &white, 0, 100, mapToWindowX(player.xLoc), mapToWindowY(player.yLoc), false);
2694: }*/
2695: // DEBUG displayLoops();
2696: // DEBUG displayChokeMap();
2697: DEBUG displayMachines();
2698: //DEBUG displayWaypoints();
2699: // DEBUG {displayGrid(safetyMap); displayMoreSign(); displayLevel();}
2700: // parseFile();
2701: // DEBUG spawnDungeonFeature(player.xLoc, player.yLoc, &dungeonFeatureCatalog[DF_METHANE_GAS_ARMAGEDDON], true, false);
2702: printSeed();
2703: break;
2704: case EASY_MODE_KEY:
2705: //if (shiftKey) {
2706: enableEasyMode();
2707: //}
2708: break;
2709: case PRINTSCREEN_KEY:
2710: if (takeScreenshot()) {
2711: flashTemporaryAlert(" Screenshot saved in save directory ", 2000);
2712: }
2713: break;
2714: default:
2715: break;
2716: }
2717: if (direction >= 0) { // if it was a movement command
2718: hideCursor();
2719: considerCautiousMode();
2720: if (controlKey || shiftKey) {
2721: playerRuns(direction);
2722: } else {
2723: playerMoves(direction);
2724: }
2725: refreshSideBar(-1, -1, false);
2726: }
2727:
2728: if (D_SAFETY_VISION) {
2729: displayGrid(safetyMap);
2730: }
2731: if (rogue.trueColorMode || D_SCENT_VISION) {
2732: displayLevel();
2733: }
2734:
2735: rogue.cautiousMode = false;
2736: }
2737:
2738: boolean getInputTextString(char *inputText,
2739: const char *prompt,
2740: short maxLength,
2741: const char *defaultEntry,
2742: const char *promptSuffix,
2743: short textEntryType,
2744: boolean useDialogBox) {
2745: short charNum, i, x, y;
2746: char keystroke, suffix[100];
2747: const short textEntryBounds[TEXT_INPUT_TYPES][2] = {{' ', '~'}, {' ', '~'}, {'0', '9'}};
2748: cellDisplayBuffer dbuf[COLS][ROWS], rbuf[COLS][ROWS];
2749:
2750: // x and y mark the origin for text entry.
2751: if (useDialogBox) {
2752: x = (COLS - max(maxLength, strLenWithoutEscapes(prompt))) / 2;
2753: y = ROWS / 2 - 1;
2754: clearDisplayBuffer(dbuf);
2755: rectangularShading(x - 1, y - 2, max(maxLength, strLenWithoutEscapes(prompt)) + 2,
2756: 4, &interfaceBoxColor, INTERFACE_OPACITY, dbuf);
2757: overlayDisplayBuffer(dbuf, rbuf);
2758: printString(prompt, x, y - 1, &white, &interfaceBoxColor, NULL);
2759: for (i=0; i<maxLength; i++) {
2760: plotCharWithColor(' ', x + i, y, &black, &black);
2761: }
2762: printString(defaultEntry, x, y, &white, &black, 0);
2763: } else {
2764: confirmMessages();
2765: x = mapToWindowX(strLenWithoutEscapes(prompt));
2766: y = MESSAGE_LINES - 1;
2767: message(prompt, false);
2768: printString(defaultEntry, x, y, &white, &black, 0);
2769: }
2770:
2771: maxLength = min(maxLength, COLS - x);
2772:
2773:
2774: strcpy(inputText, defaultEntry);
2775: charNum = strLenWithoutEscapes(inputText);
2776: for (i = charNum; i < maxLength; i++) {
2777: inputText[i] = ' ';
2778: }
2779:
2780: if (promptSuffix[0] == '\0') { // empty suffix
2781: strcpy(suffix, " "); // so that deleting doesn't leave a white trail
2782: } else {
2783: strcpy(suffix, promptSuffix);
2784: }
2785:
2786: do {
2787: printString(suffix, charNum + x, y, &gray, &black, 0);
2788: plotCharWithColor((suffix[0] ? suffix[0] : ' '), x + charNum, y, &black, &white);
2789: keystroke = nextKeyPress(true);
2790: if (keystroke == DELETE_KEY && charNum > 0) {
2791: printString(suffix, charNum + x - 1, y, &gray, &black, 0);
2792: plotCharWithColor(' ', x + charNum + strlen(suffix) - 1, y, &black, &black);
2793: charNum--;
2794: inputText[charNum] = ' ';
2795: } else if (keystroke >= textEntryBounds[textEntryType][0]
2796: && keystroke <= textEntryBounds[textEntryType][1]) { // allow only permitted input
2797:
2798: if (textEntryType == TEXT_INPUT_FILENAME
2799: && characterForbiddenInFilename(keystroke)) {
2800:
2801: keystroke = '-';
2802: }
2803:
2804: inputText[charNum] = keystroke;
2805: plotCharWithColor(keystroke, x + charNum, y, &white, &black);
2806: printString(suffix, charNum + x + 1, y, &gray, &black, 0);
2807: if (charNum < maxLength) {
2808: charNum++;
2809: }
2810: }
2811: #ifdef USE_CLIPBOARD
2812: else if (keystroke == TAB_KEY) {
2813: char* clipboard = getClipboard();
2814: for (int i=0; i<(int) min(strlen(clipboard), (unsigned long) (maxLength - charNum)); ++i) {
2815:
2816: char character = clipboard[i];
2817:
2818: if (character >= textEntryBounds[textEntryType][0]
2819: && character <= textEntryBounds[textEntryType][1]) { // allow only permitted input
2820: if (textEntryType == TEXT_INPUT_FILENAME
2821: && characterForbiddenInFilename(character)) {
2822: character = '-';
2823: }
2824: plotCharWithColor(character, x + charNum, y, &white, &black);
2825: if (charNum < maxLength) {
2826: charNum++;
2827: }
2828: }
2829: }
2830: }
2831: #endif
2832: } while (keystroke != RETURN_KEY && keystroke != ESCAPE_KEY);
2833:
2834: if (useDialogBox) {
2835: overlayDisplayBuffer(rbuf, NULL);
2836: }
2837:
2838: inputText[charNum] = '\0';
2839:
2840: if (keystroke == ESCAPE_KEY) {
2841: return false;
2842: }
2843: strcat(displayedMessage[0], inputText);
2844: strcat(displayedMessage[0], suffix);
2845: return true;
2846: }
2847:
2848: void displayCenteredAlert(char *message) {
2849: printString(message, (COLS - strLenWithoutEscapes(message)) / 2, ROWS / 2, &teal, &black, 0);
2850: }
2851:
2852: // Flashes a message on the screen starting at (x, y) lasting for the given time (in ms) and with the given colors.
2853: void flashMessage(char *message, short x, short y, int time, color *fColor, color *bColor) {
2854: boolean fastForward;
2855: int i, j, messageLength, percentComplete, previousPercentComplete;
2856: color backColors[COLS], backColor, foreColor;
2857: cellDisplayBuffer dbufs[COLS];
2858: enum displayGlyph dchar;
2859: short oldRNG;
2860: const int stepInMs = 16;
2861:
2862: if (rogue.playbackFastForward) {
2863: return;
2864: }
2865:
2866: oldRNG = rogue.RNG;
2867: rogue.RNG = RNG_COSMETIC;
2868: //assureCosmeticRNG;
2869:
2870: messageLength = strLenWithoutEscapes(message);
2871: fastForward = false;
2872:
2873: for (j=0; j<messageLength; j++) {
2874: backColors[j] = colorFromComponents(displayBuffer[j + x][y].backColorComponents);
2875: dbufs[j] = displayBuffer[j + x][y];
2876: }
2877:
2878: previousPercentComplete = -1;
2879: for (i=0; i < time && fastForward == false; i += stepInMs) {
2880: percentComplete = 100 * i / time;
2881: percentComplete = percentComplete * percentComplete / 100; // transition is front-loaded
2882: if (previousPercentComplete != percentComplete) {
2883: for (j=0; j<messageLength; j++) {
2884: if (i==0) {
2885: backColors[j] = colorFromComponents(displayBuffer[j + x][y].backColorComponents);
2886: dbufs[j] = displayBuffer[j + x][y];
2887: }
2888: backColor = backColors[j];
2889: applyColorAverage(&backColor, bColor, 100 - percentComplete);
2890: if (percentComplete < 50) {
2891: dchar = message[j];
2892: foreColor = *fColor;
2893: applyColorAverage(&foreColor, &backColor, percentComplete * 2);
2894: } else {
2895: dchar = dbufs[j].character;
2896: foreColor = colorFromComponents(dbufs[j].foreColorComponents);
2897: applyColorAverage(&foreColor, &backColor, (100 - percentComplete) * 2);
2898: }
2899: plotCharWithColor(dchar, j+x, y, &foreColor, &backColor);
2900: }
2901: }
2902: previousPercentComplete = percentComplete;
2903: fastForward = pauseBrogue(stepInMs);
2904: }
2905: for (j=0; j<messageLength; j++) {
2906: foreColor = colorFromComponents(dbufs[j].foreColorComponents);
2907: plotCharWithColor(dbufs[j].character, j+x, y, &foreColor, &(backColors[j]));
2908: }
2909:
2910: restoreRNG;
2911: }
2912:
2913: void flashTemporaryAlert(char *message, int time) {
2914: flashMessage(message, (COLS - strLenWithoutEscapes(message)) / 2, ROWS / 2, time, &teal, &black);
2915: }
2916:
2917: void waitForAcknowledgment() {
2918: rogueEvent theEvent;
2919:
2920: if (rogue.autoPlayingLevel || (rogue.playbackMode && !rogue.playbackOOS)) {
2921: return;
2922: }
2923:
2924: do {
2925: nextBrogueEvent(&theEvent, false, false, false);
2926: if (theEvent.eventType == KEYSTROKE && theEvent.param1 != ACKNOWLEDGE_KEY && theEvent.param1 != ESCAPE_KEY) {
2927: flashTemporaryAlert(" -- Press space or click to continue -- ", 500);
2928: }
2929: } while (!(theEvent.eventType == KEYSTROKE && (theEvent.param1 == ACKNOWLEDGE_KEY || theEvent.param1 == ESCAPE_KEY)
2930: || theEvent.eventType == MOUSE_UP));
2931: }
2932:
2933: void waitForKeystrokeOrMouseClick() {
2934: rogueEvent theEvent;
2935: do {
2936: nextBrogueEvent(&theEvent, false, false, false);
2937: } while (theEvent.eventType != KEYSTROKE && theEvent.eventType != MOUSE_UP);
2938: }
2939:
2940: boolean confirm(char *prompt, boolean alsoDuringPlayback) {
2941: short retVal;
2942: brogueButton buttons[2] = {{{0}}};
2943: cellDisplayBuffer rbuf[COLS][ROWS];
2944: char whiteColorEscape[20] = "";
2945: char yellowColorEscape[20] = "";
2946:
2947: if (rogue.autoPlayingLevel || (!alsoDuringPlayback && rogue.playbackMode)) {
2948: return true; // oh yes he did
2949: }
2950:
2951: encodeMessageColor(whiteColorEscape, 0, &white);
2952: encodeMessageColor(yellowColorEscape, 0, KEYBOARD_LABELS ? &yellow : &white);
2953:
2954: initializeButton(&(buttons[0]));
2955: sprintf(buttons[0].text, " %sY%ses ", yellowColorEscape, whiteColorEscape);
2956: buttons[0].hotkey[0] = 'y';
2957: buttons[0].hotkey[1] = 'Y';
2958: buttons[0].hotkey[2] = RETURN_KEY;
2959: buttons[0].flags |= (B_WIDE_CLICK_AREA | B_KEYPRESS_HIGHLIGHT);
2960:
2961: initializeButton(&(buttons[1]));
2962: sprintf(buttons[1].text, " %sN%so ", yellowColorEscape, whiteColorEscape);
2963: buttons[1].hotkey[0] = 'n';
2964: buttons[1].hotkey[1] = 'N';
2965: buttons[1].hotkey[2] = ACKNOWLEDGE_KEY;
2966: buttons[1].hotkey[3] = ESCAPE_KEY;
2967: buttons[1].flags |= (B_WIDE_CLICK_AREA | B_KEYPRESS_HIGHLIGHT);
2968:
2969: retVal = printTextBox(prompt, COLS/3, ROWS/3, COLS/3, &white, &interfaceBoxColor, rbuf, buttons, 2);
2970: overlayDisplayBuffer(rbuf, NULL);
2971:
2972: if (retVal == -1 || retVal == 1) { // If they canceled or pressed no.
2973: return false;
2974: } else {
2975: return true;
2976: }
2977:
2978: confirmMessages();
2979: return retVal;
2980: }
2981:
2982: void clearMonsterFlashes() {
2983:
2984: }
2985:
2986: void displayMonsterFlashes(boolean flashingEnabled) {
2987: creature *monst;
2988: short x[100], y[100], strength[100], count = 0;
2989: color *flashColor[100];
2990: short oldRNG;
2991:
2992: rogue.creaturesWillFlashThisTurn = false;
2993:
2994: if (rogue.autoPlayingLevel || rogue.blockCombatText) {
2995: return;
2996: }
2997:
2998: oldRNG = rogue.RNG;
2999: rogue.RNG = RNG_COSMETIC;
3000: //assureCosmeticRNG;
3001:
3002: CYCLE_MONSTERS_AND_PLAYERS(monst) {
3003: if (monst->bookkeepingFlags & MB_WILL_FLASH) {
3004: monst->bookkeepingFlags &= ~MB_WILL_FLASH;
3005: if (flashingEnabled && canSeeMonster(monst) && count < 100) {
3006: x[count] = monst->xLoc;
3007: y[count] = monst->yLoc;
3008: strength[count] = monst->flashStrength;
3009: flashColor[count] = &(monst->flashColor);
3010: count++;
3011: }
3012: }
3013: }
3014: flashForeground(x, y, flashColor, strength, count, 20);
3015: restoreRNG;
3016: }
3017:
3018: void dequeueEvent() {
3019: rogueEvent returnEvent;
3020: nextBrogueEvent(&returnEvent, false, false, true);
3021: }
3022:
3023: void displayMessageArchive() {
3024: short i, j, k, reverse, fadePercent, totalMessageCount, currentMessageCount;
3025: boolean fastForward;
3026: cellDisplayBuffer dbuf[COLS][ROWS], rbuf[COLS][ROWS];
3027:
3028: // Count the number of lines in the archive.
3029: for (totalMessageCount=0;
3030: totalMessageCount < MESSAGE_ARCHIVE_LINES && messageArchive[totalMessageCount][0];
3031: totalMessageCount++);
3032:
3033: if (totalMessageCount > MESSAGE_LINES) {
3034:
3035: copyDisplayBuffer(rbuf, displayBuffer);
3036:
3037: // Pull-down/pull-up animation:
3038: for (reverse = 0; reverse <= 1; reverse++) {
3039: fastForward = false;
3040: for (currentMessageCount = (reverse ? totalMessageCount : MESSAGE_LINES);
3041: (reverse ? currentMessageCount >= MESSAGE_LINES : currentMessageCount <= totalMessageCount);
3042: currentMessageCount += (reverse ? -1 : 1)) {
3043:
3044: clearDisplayBuffer(dbuf);
3045:
3046: // Print the message archive text to the dbuf.
3047: for (j=0; j < currentMessageCount && j < ROWS; j++) {
3048: printString(messageArchive[(messageArchivePosition - currentMessageCount + MESSAGE_ARCHIVE_LINES + j) % MESSAGE_ARCHIVE_LINES],
3049: mapToWindowX(0), j, &white, &black, dbuf);
3050: }
3051:
3052: // Set the dbuf opacity, and do a fade from bottom to top to make it clear that the bottom messages are the most recent.
3053: for (j=0; j < currentMessageCount && j<ROWS; j++) {
3054: fadePercent = 50 * (j + totalMessageCount - currentMessageCount) / totalMessageCount + 50;
3055: for (i=0; i<DCOLS; i++) {
3056: dbuf[mapToWindowX(i)][j].opacity = INTERFACE_OPACITY;
3057: if (dbuf[mapToWindowX(i)][j].character != ' ') {
3058: for (k=0; k<3; k++) {
3059: dbuf[mapToWindowX(i)][j].foreColorComponents[k] = dbuf[mapToWindowX(i)][j].foreColorComponents[k] * fadePercent / 100;
3060: }
3061: }
3062: }
3063: }
3064:
3065: // Display.
3066: overlayDisplayBuffer(rbuf, 0);
3067: overlayDisplayBuffer(dbuf, 0);
3068:
3069: if (!fastForward && pauseBrogue(reverse ? 1 : 2)) {
3070: fastForward = true;
3071: dequeueEvent();
3072: currentMessageCount = (reverse ? MESSAGE_LINES + 1 : totalMessageCount - 1); // skip to the end
3073: }
3074: }
3075:
3076: if (!reverse) {
3077: displayMoreSign();
3078: }
3079: }
3080: overlayDisplayBuffer(rbuf, 0);
3081: updateFlavorText();
3082: confirmMessages();
3083: updateMessageDisplay();
3084: }
3085: }
3086:
3087: // Clears the message area and prints the given message in the area.
3088: // It will disappear when messages are refreshed and will not be archived.
3089: // This is primarily used to display prompts.
3090: void temporaryMessage(char *msg, boolean requireAcknowledgment) {
3091: char message[COLS];
3092: short i, j;
3093:
3094: assureCosmeticRNG;
3095: strcpy(message, msg);
3096:
3097: for (i=0; message[i] == COLOR_ESCAPE; i += 4) {
3098: upperCase(&(message[i]));
3099: }
3100:
3101: refreshSideBar(-1, -1, false);
3102:
3103: for (i=0; i<MESSAGE_LINES; i++) {
3104: for (j=0; j<DCOLS; j++) {
3105: plotCharWithColor(' ', mapToWindowX(j), i, &black, &black);
3106: }
3107: }
3108: printString(message, mapToWindowX(0), mapToWindowY(-1), &white, &black, 0);
3109: if (requireAcknowledgment) {
3110: waitForAcknowledgment();
3111: updateMessageDisplay();
3112: }
3113: restoreRNG;
3114: }
3115:
3116: void messageWithColor(char *msg, color *theColor, boolean requireAcknowledgment) {
3117: char buf[COLS*2] = "";
3118: short i;
3119:
3120: i=0;
3121: i = encodeMessageColor(buf, i, theColor);
3122: strcpy(&(buf[i]), msg);
3123: message(buf, requireAcknowledgment);
3124: }
3125:
3126: void flavorMessage(char *msg) {
3127: short i;
3128: char text[COLS*20];
3129:
3130: for (i=0; i < COLS*2 && msg[i] != '\0'; i++) {
3131: text[i] = msg[i];
3132: }
3133: text[i] = '\0';
3134:
3135: for(i=0; text[i] == COLOR_ESCAPE; i+=4);
3136: upperCase(&(text[i]));
3137:
3138: printString(text, mapToWindowX(0), ROWS - 2, &flavorTextColor, &black, 0);
3139: for (i = strLenWithoutEscapes(text); i < DCOLS; i++) {
3140: plotCharWithColor(' ', mapToWindowX(i), ROWS - 2, &black, &black);
3141: }
3142: }
3143:
3144: void messageWithoutCaps(char *msg, boolean requireAcknowledgment) {
3145: short i;
3146: if (!msg[0]) {
3147: return;
3148: }
3149:
3150: // need to confirm the oldest message? (Disabled!)
3151: /*if (!messageConfirmed[MESSAGE_LINES - 1]) {
3152: //refreshSideBar(-1, -1, false);
3153: displayMoreSign();
3154: for (i=0; i<MESSAGE_LINES; i++) {
3155: messageConfirmed[i] = true;
3156: }
3157: }*/
3158:
3159: for (i = MESSAGE_LINES - 1; i >= 1; i--) {
3160: messageConfirmed[i] = messageConfirmed[i-1];
3161: strcpy(displayedMessage[i], displayedMessage[i-1]);
3162: }
3163: messageConfirmed[0] = false;
3164: strcpy(displayedMessage[0], msg);
3165:
3166: // Add the message to the archive.
3167: strcpy(messageArchive[messageArchivePosition], msg);
3168: messageArchivePosition = (messageArchivePosition + 1) % MESSAGE_ARCHIVE_LINES;
3169:
3170: // display the message:
3171: updateMessageDisplay();
3172:
3173: if (requireAcknowledgment || rogue.cautiousMode) {
3174: displayMoreSign();
3175: confirmMessages();
3176: rogue.cautiousMode = false;
3177: }
3178:
3179: if (rogue.playbackMode) {
3180: rogue.playbackDelayThisTurn += rogue.playbackDelayPerTurn * 5;
3181: }
3182: }
3183:
3184:
3185: void message(const char *msg, boolean requireAcknowledgment) {
3186: char text[COLS*20], *msgPtr;
3187: short i, lines;
3188:
3189: assureCosmeticRNG;
3190:
3191: rogue.disturbed = true;
3192: if (requireAcknowledgment) {
3193: refreshSideBar(-1, -1, false);
3194: }
3195: displayCombatText();
3196:
3197: lines = wrapText(text, msg, DCOLS);
3198: msgPtr = &(text[0]);
3199:
3200: // Implement the American quotation mark/period/comma ordering rule.
3201: for (i=0; text[i] != '\0' && text[i+1] != '\0'; i++) {
3202: if (text[i] == COLOR_ESCAPE) {
3203: i += 4;
3204: } else if (text[i] == '"'
3205: && (text[i+1] == '.' || text[i+1] == ',')) {
3206:
3207: text[i] = text[i+1];
3208: text[i+1] = '"';
3209: }
3210: }
3211:
3212: for(i=0; text[i] == COLOR_ESCAPE; i+=4);
3213: upperCase(&(text[i]));
3214:
3215: if (lines > 1) {
3216: for (i=0; text[i] != '\0'; i++) {
3217: if (text[i] == '\n') {
3218: text[i] = '\0';
3219:
3220: messageWithoutCaps(msgPtr, false);
3221: msgPtr = &(text[i+1]);
3222: }
3223: }
3224: }
3225:
3226: messageWithoutCaps(msgPtr, requireAcknowledgment);
3227: restoreRNG;
3228: }
3229:
3230: // Only used for the "you die..." message, to enable posthumous inventory viewing.
3231: void displayMoreSignWithoutWaitingForAcknowledgment() {
3232: if (strLenWithoutEscapes(displayedMessage[0]) < DCOLS - 8 || messageConfirmed[0]) {
3233: printString("--MORE--", COLS - 8, MESSAGE_LINES-1, &black, &white, 0);
3234: } else {
3235: printString("--MORE--", COLS - 8, MESSAGE_LINES, &black, &white, 0);
3236: }
3237: }
3238:
3239: void displayMoreSign() {
3240: short i;
3241:
3242: if (rogue.autoPlayingLevel) {
3243: return;
3244: }
3245:
3246: if (strLenWithoutEscapes(displayedMessage[0]) < DCOLS - 8 || messageConfirmed[0]) {
3247: printString("--MORE--", COLS - 8, MESSAGE_LINES-1, &black, &white, 0);
3248: waitForAcknowledgment();
3249: printString(" ", COLS - 8, MESSAGE_LINES-1, &black, &black, 0);
3250: } else {
3251: printString("--MORE--", COLS - 8, MESSAGE_LINES, &black, &white, 0);
3252: waitForAcknowledgment();
3253: for (i=1; i<=8; i++) {
3254: refreshDungeonCell(DCOLS - i, 0);
3255: }
3256: }
3257: }
3258:
3259: // Inserts a four-character color escape sequence into a string at the insertion point.
3260: // Does NOT check string lengths, so it could theoretically write over the null terminator.
3261: // Returns the new insertion point.
3262: short encodeMessageColor(char *msg, short i, const color *theColor) {
3263: boolean needTerminator = false;
3264: color col = *theColor;
3265:
3266: assureCosmeticRNG;
3267:
3268: bakeColor(&col);
3269:
3270: col.red = clamp(col.red, 0, 100);
3271: col.green = clamp(col.green, 0, 100);
3272: col.blue = clamp(col.blue, 0, 100);
3273:
3274: needTerminator = !msg[i] || !msg[i + 1] || !msg[i + 2] || !msg[i + 3];
3275:
3276: msg[i++] = COLOR_ESCAPE;
3277: msg[i++] = (char) (COLOR_VALUE_INTERCEPT + col.red);
3278: msg[i++] = (char) (COLOR_VALUE_INTERCEPT + col.green);
3279: msg[i++] = (char) (COLOR_VALUE_INTERCEPT + col.blue);
3280:
3281: if (needTerminator) {
3282: msg[i] = '\0';
3283: }
3284:
3285: restoreRNG;
3286:
3287: return i;
3288: }
3289:
3290: // Call this when the i'th character of msg is COLOR_ESCAPE.
3291: // It will return the encoded color, and will advance i past the color escape sequence.
3292: short decodeMessageColor(const char *msg, short i, color *returnColor) {
3293:
3294: if (msg[i] != COLOR_ESCAPE) {
3295: printf("\nAsked to decode a color escape that didn't exist!");
3296: *returnColor = white;
3297: } else {
3298: i++;
3299: *returnColor = black;
3300: returnColor->red = (short) (msg[i++] - COLOR_VALUE_INTERCEPT);
3301: returnColor->green = (short) (msg[i++] - COLOR_VALUE_INTERCEPT);
3302: returnColor->blue = (short) (msg[i++] - COLOR_VALUE_INTERCEPT);
3303:
3304: returnColor->red = clamp(returnColor->red, 0, 100);
3305: returnColor->green = clamp(returnColor->green, 0, 100);
3306: returnColor->blue = clamp(returnColor->blue, 0, 100);
3307: }
3308: return i;
3309: }
3310:
3311: // Returns a color for combat text based on the identity of the victim.
3312: color *messageColorFromVictim(creature *monst) {
3313: if (monst == &player) {
3314: return &badMessageColor;
3315: } else if (player.status[STATUS_HALLUCINATING] && !rogue.playbackOmniscience) {
3316: return &white;
3317: } else if (monst->creatureState == MONSTER_ALLY) {
3318: return &badMessageColor;
3319: } else if (monstersAreEnemies(&player, monst)) {
3320: return &goodMessageColor;
3321: } else {
3322: return &white;
3323: }
3324: }
3325:
3326: void updateMessageDisplay() {
3327: short i, j, m;
3328: color messageColor;
3329:
3330: for (i=0; i<MESSAGE_LINES; i++) {
3331: messageColor = white;
3332:
3333: if (messageConfirmed[i]) {
3334: applyColorAverage(&messageColor, &black, 50);
3335: applyColorAverage(&messageColor, &black, 75 * i / MESSAGE_LINES);
3336: }
3337:
3338: for (j = m = 0; displayedMessage[i][m] && j < DCOLS; j++, m++) {
3339:
3340: while (displayedMessage[i][m] == COLOR_ESCAPE) {
3341: m = decodeMessageColor(displayedMessage[i], m, &messageColor); // pulls the message color out and advances m
3342: if (messageConfirmed[i]) {
3343: applyColorAverage(&messageColor, &black, 50);
3344: applyColorAverage(&messageColor, &black, 75 * i / MESSAGE_LINES);
3345: }
3346: }
3347:
3348: plotCharWithColor(displayedMessage[i][m], mapToWindowX(j), MESSAGE_LINES - i - 1,
3349: &messageColor,
3350: &black);
3351: }
3352: for (; j < DCOLS; j++) {
3353: plotCharWithColor(' ', mapToWindowX(j), MESSAGE_LINES - i - 1, &black, &black);
3354: }
3355: }
3356: }
3357:
3358: // Does NOT clear the message archive.
3359: void deleteMessages() {
3360: short i;
3361: for (i=0; i<MESSAGE_LINES; i++) {
3362: displayedMessage[i][0] = '\0';
3363: }
3364: confirmMessages();
3365: }
3366:
3367: void confirmMessages() {
3368: short i;
3369: for (i=0; i<MESSAGE_LINES; i++) {
3370: messageConfirmed[i] = true;
3371: }
3372: updateMessageDisplay();
3373: }
3374:
3375: void stripShiftFromMovementKeystroke(signed long *keystroke) {
3376: const unsigned short newKey = *keystroke - ('A' - 'a');
3377: if (newKey == LEFT_KEY
3378: || newKey == RIGHT_KEY
3379: || newKey == DOWN_KEY
3380: || newKey == UP_KEY
3381: || newKey == UPLEFT_KEY
3382: || newKey == UPRIGHT_KEY
3383: || newKey == DOWNLEFT_KEY
3384: || newKey == DOWNRIGHT_KEY) {
3385: *keystroke -= 'A' - 'a';
3386: }
3387: }
3388:
3389: void upperCase(char *theChar) {
3390: if (*theChar >= 'a' && *theChar <= 'z') {
3391: (*theChar) += ('A' - 'a');
3392: }
3393: }
3394:
3395: enum entityDisplayTypes {
3396: EDT_NOTHING = 0,
3397: EDT_CREATURE,
3398: EDT_ITEM,
3399: EDT_TERRAIN,
3400: };
3401:
3402: // Refreshes the sidebar.
3403: // Progresses from the closest visible monster to the farthest.
3404: // If a monster, item or terrain is focused, then display the sidebar with that monster/item highlighted,
3405: // in the order it would normally appear. If it would normally not fit on the sidebar at all,
3406: // then list it first.
3407: // Also update rogue.sidebarLocationList[ROWS][2] list of locations so that each row of
3408: // the screen is mapped to the corresponding entity, if any.
3409: // FocusedEntityMustGoFirst should usually be false when called externally. This is because
3410: // we won't know if it will fit on the screen in normal order until we try.
3411: // So if we try and fail, this function will call itself again, but with this set to true.
3412: void refreshSideBar(short focusX, short focusY, boolean focusedEntityMustGoFirst) {
3413: short printY, oldPrintY, shortestDistance, i, j, k, px, py, x = 0, y = 0, displayEntityCount, indirectVision;
3414: creature *monst = NULL, *closestMonst = NULL;
3415: item *theItem, *closestItem = NULL;
3416: char buf[COLS];
3417: void *entityList[ROWS] = {0}, *focusEntity = NULL;
3418: enum entityDisplayTypes entityType[ROWS] = {0}, focusEntityType = EDT_NOTHING;
3419: short terrainLocationMap[ROWS][2];
3420: boolean gotFocusedEntityOnScreen = (focusX >= 0 ? false : true);
3421: char addedEntity[DCOLS][DROWS];
3422: short oldRNG;
3423:
3424: if (rogue.gameHasEnded || rogue.playbackFastForward) {
3425: return;
3426: }
3427:
3428: oldRNG = rogue.RNG;
3429: rogue.RNG = RNG_COSMETIC;
3430: //assureCosmeticRNG;
3431:
3432: if (focusX < 0) {
3433: focusedEntityMustGoFirst = false; // just in case!
3434: } else {
3435: if (pmap[focusX][focusY].flags & (HAS_MONSTER | HAS_PLAYER)) {
3436: monst = monsterAtLoc(focusX, focusY);
3437: if (canSeeMonster(monst) || rogue.playbackOmniscience) {
3438: focusEntity = monst;
3439: focusEntityType = EDT_CREATURE;
3440: }
3441: }
3442: if (!focusEntity && (pmap[focusX][focusY].flags & HAS_ITEM)) {
3443: theItem = itemAtLoc(focusX, focusY);
3444: if (playerCanSeeOrSense(focusX, focusY)) {
3445: focusEntity = theItem;
3446: focusEntityType = EDT_ITEM;
3447: }
3448: }
3449: if (!focusEntity
3450: && cellHasTMFlag(focusX, focusY, TM_LIST_IN_SIDEBAR)
3451: && playerCanSeeOrSense(focusX, focusY)) {
3452:
3453: focusEntity = tileCatalog[pmap[focusX][focusY].layers[layerWithTMFlag(focusX, focusY, TM_LIST_IN_SIDEBAR)]].description;
3454: focusEntityType = EDT_TERRAIN;
3455: }
3456: }
3457:
3458: printY = 0;
3459:
3460: px = player.xLoc;
3461: py = player.yLoc;
3462:
3463: zeroOutGrid(addedEntity);
3464:
3465: // Header information for playback mode.
3466: if (rogue.playbackMode) {
3467: printString(" -- PLAYBACK -- ", 0, printY++, &white, &black, 0);
3468: if (rogue.howManyTurns > 0) {
3469: sprintf(buf, "Turn %li/%li", rogue.playerTurnNumber, rogue.howManyTurns);
3470: printProgressBar(0, printY++, buf, rogue.playerTurnNumber, rogue.howManyTurns, &darkPurple, false);
3471: }
3472: if (rogue.playbackOOS) {
3473: printString(" [OUT OF SYNC] ", 0, printY++, &badMessageColor, &black, 0);
3474: } else if (rogue.playbackPaused) {
3475: printString(" [PAUSED] ", 0, printY++, &gray, &black, 0);
3476: }
3477: printString(" ", 0, printY++, &white, &black, 0);
3478: }
3479:
3480: // Now list the monsters that we'll be displaying in the order of their proximity to player (listing the focused first if required).
3481:
3482: // Initialization.
3483: displayEntityCount = 0;
3484: for (i=0; i<ROWS*2; i++) {
3485: rogue.sidebarLocationList[i][0] = -1;
3486: rogue.sidebarLocationList[i][1] = -1;
3487: }
3488:
3489: // Player always goes first.
3490: entityList[displayEntityCount] = &player;
3491: entityType[displayEntityCount] = EDT_CREATURE;
3492: displayEntityCount++;
3493: addedEntity[player.xLoc][player.yLoc] = true;
3494:
3495: // Focused entity, if it must go first.
3496: if (focusedEntityMustGoFirst && !addedEntity[focusX][focusY]) {
3497: addedEntity[focusX][focusY] = true;
3498: entityList[displayEntityCount] = focusEntity;
3499: entityType[displayEntityCount] = focusEntityType;
3500: terrainLocationMap[displayEntityCount][0] = focusX;
3501: terrainLocationMap[displayEntityCount][1] = focusY;
3502: displayEntityCount++;
3503: }
3504:
3505: for (indirectVision = 0; indirectVision < 2; indirectVision++) {
3506: // Non-focused monsters.
3507: do {
3508: shortestDistance = 10000;
3509: for (monst = monsters->nextCreature; monst != NULL; monst = monst->nextCreature) {
3510: if ((canDirectlySeeMonster(monst) || (indirectVision && (canSeeMonster(monst) || rogue.playbackOmniscience)))
3511: && !addedEntity[monst->xLoc][monst->yLoc]
3512: && !(monst->info.flags & MONST_NOT_LISTED_IN_SIDEBAR)
3513: && (px - monst->xLoc) * (px - monst->xLoc) + (py - monst->yLoc) * (py - monst->yLoc) < shortestDistance) {
3514:
3515: shortestDistance = (px - monst->xLoc) * (px - monst->xLoc) + (py - monst->yLoc) * (py - monst->yLoc);
3516: closestMonst = monst;
3517: }
3518: }
3519: if (shortestDistance < 10000) {
3520: addedEntity[closestMonst->xLoc][closestMonst->yLoc] = true;
3521: entityList[displayEntityCount] = closestMonst;
3522: entityType[displayEntityCount] = EDT_CREATURE;
3523: displayEntityCount++;
3524: }
3525: } while (shortestDistance < 10000 && displayEntityCount * 2 < ROWS); // Because each entity takes at least 2 rows in the sidebar.
3526:
3527: // Non-focused items.
3528: do {
3529: shortestDistance = 10000;
3530: for (theItem = floorItems->nextItem; theItem != NULL; theItem = theItem->nextItem) {
3531: if ((playerCanDirectlySee(theItem->xLoc, theItem->yLoc) || (indirectVision && (playerCanSeeOrSense(theItem->xLoc, theItem->yLoc) || rogue.playbackOmniscience)))
3532: && !addedEntity[theItem->xLoc][theItem->yLoc]
3533: && (px - theItem->xLoc) * (px - theItem->xLoc) + (py - theItem->yLoc) * (py - theItem->yLoc) < shortestDistance) {
3534:
3535: shortestDistance = (px - theItem->xLoc) * (px - theItem->xLoc) + (py - theItem->yLoc) * (py - theItem->yLoc);
3536: closestItem = theItem;
3537: }
3538: }
3539: if (shortestDistance < 10000) {
3540: addedEntity[closestItem->xLoc][closestItem->yLoc] = true;
3541: entityList[displayEntityCount] = closestItem;
3542: entityType[displayEntityCount] = EDT_ITEM;
3543: displayEntityCount++;
3544: }
3545: } while (shortestDistance < 10000 && displayEntityCount * 2 < ROWS); // Because each entity takes at least 2 rows in the sidebar.
3546:
3547: // Non-focused terrain.
3548:
3549: // count up the number of candidate locations
3550: for (k=0; k<max(DROWS, DCOLS); k++) {
3551: for (i = px-k; i <= px+k; i++) {
3552: // we are scanning concentric squares. The first and last columns
3553: // need to be stepped through, but others can be jumped over.
3554: short step = (i == px-k || i == px+k) ? 1 : 2*k;
3555: for (j = py-k; j <= py+k; j += step) {
3556: if (displayEntityCount >= ROWS - 1) goto no_space_for_more_entities;
3557: if (coordinatesAreInMap(i, j)
3558: && !addedEntity[i][j]
3559: && cellHasTMFlag(i, j, TM_LIST_IN_SIDEBAR)
3560: && (playerCanDirectlySee(i, j) || (indirectVision && (playerCanSeeOrSense(i, j) || rogue.playbackOmniscience)))) {
3561:
3562: addedEntity[i][j] = true;
3563: entityList[displayEntityCount] = tileCatalog[pmap[i][j].layers[layerWithTMFlag(i, j, TM_LIST_IN_SIDEBAR)]].description;
3564: entityType[displayEntityCount] = EDT_TERRAIN;
3565: terrainLocationMap[displayEntityCount][0] = i;
3566: terrainLocationMap[displayEntityCount][1] = j;
3567: displayEntityCount++;
3568: }
3569: }
3570: }
3571: }
3572: no_space_for_more_entities:;
3573: }
3574:
3575: // Entities are now listed. Start printing.
3576:
3577: for (i=0; i<displayEntityCount && printY < ROWS - 1; i++) { // Bottom line is reserved for the depth.
3578: oldPrintY = printY;
3579: if (entityType[i] == EDT_CREATURE) {
3580: x = ((creature *) entityList[i])->xLoc;
3581: y = ((creature *) entityList[i])->yLoc;
3582: printY = printMonsterInfo((creature *) entityList[i],
3583: printY,
3584: (focusEntity && (x != focusX || y != focusY)),
3585: (x == focusX && y == focusY));
3586:
3587: } else if (entityType[i] == EDT_ITEM) {
3588: x = ((item *) entityList[i])->xLoc;
3589: y = ((item *) entityList[i])->yLoc;
3590: printY = printItemInfo((item *) entityList[i],
3591: printY,
3592: (focusEntity && (x != focusX || y != focusY)),
3593: (x == focusX && y == focusY));
3594: } else if (entityType[i] == EDT_TERRAIN) {
3595: x = terrainLocationMap[i][0];
3596: y = terrainLocationMap[i][1];
3597: printY = printTerrainInfo(x, y,
3598: printY,
3599: ((const char *) entityList[i]),
3600: (focusEntity && (x != focusX || y != focusY)),
3601: (x == focusX && y == focusY));
3602: }
3603: if (focusEntity && (x == focusX && y == focusY) && printY < ROWS) {
3604: gotFocusedEntityOnScreen = true;
3605: }
3606: for (j=oldPrintY; j<printY; j++) {
3607: rogue.sidebarLocationList[j][0] = x;
3608: rogue.sidebarLocationList[j][1] = y;
3609: }
3610: }
3611:
3612: if (gotFocusedEntityOnScreen) {
3613: // Wrap things up.
3614: for (i=printY; i< ROWS - 1; i++) {
3615: printString(" ", 0, i, &white, &black, 0);
3616: }
3617: sprintf(buf, " -- Depth: %i --%s ", rogue.depthLevel, (rogue.depthLevel < 10 ? " " : ""));
3618: printString(buf, 0, ROWS - 1, &white, &black, 0);
3619: } else if (!focusedEntityMustGoFirst) {
3620: // Failed to get the focusMonst printed on the screen. Try again, this time with the focus first.
3621: refreshSideBar(focusX, focusY, true);
3622: }
3623:
3624: restoreRNG;
3625: }
3626:
3627: void printString(const char *theString, short x, short y, color *foreColor, color *backColor, cellDisplayBuffer dbuf[COLS][ROWS]) {
3628: color fColor;
3629: short i;
3630:
3631: fColor = *foreColor;
3632:
3633: for (i=0; theString[i] != '\0' && x < COLS; i++, x++) {
3634: while (theString[i] == COLOR_ESCAPE) {
3635: i = decodeMessageColor(theString, i, &fColor);
3636: if (!theString[i]) {
3637: return;
3638: }
3639: }
3640:
3641: if (dbuf) {
3642: plotCharToBuffer(theString[i], x, y, &fColor, backColor, dbuf);
3643: } else {
3644: plotCharWithColor(theString[i], x, y, &fColor, backColor);
3645: }
3646: }
3647: }
3648:
3649: // Inserts line breaks into really long words. Optionally adds a hyphen, but doesn't do anything
3650: // clever regarding hyphen placement. Plays nicely with color escapes.
3651: void breakUpLongWordsIn(char *sourceText, short width, boolean useHyphens) {
3652: char buf[COLS * ROWS * 2] = "";
3653: short i, m, nextChar, wordWidth;
3654: //const short maxLength = useHyphens ? width - 1 : width;
3655:
3656: // i iterates over characters in sourceText; m keeps track of the length of buf.
3657: wordWidth = 0;
3658: for (i=0, m=0; sourceText[i] != 0;) {
3659: if (sourceText[i] == COLOR_ESCAPE) {
3660: strncpy(&(buf[m]), &(sourceText[i]), 4);
3661: i += 4;
3662: m += 4;
3663: } else if (sourceText[i] == ' ' || sourceText[i] == '\n') {
3664: wordWidth = 0;
3665: buf[m++] = sourceText[i++];
3666: } else {
3667: if (!useHyphens && wordWidth >= width) {
3668: buf[m++] = '\n';
3669: wordWidth = 0;
3670: } else if (useHyphens && wordWidth >= width - 1) {
3671: nextChar = i+1;
3672: while (sourceText[nextChar] == COLOR_ESCAPE) {
3673: nextChar += 4;
3674: }
3675: if (sourceText[nextChar] && sourceText[nextChar] != ' ' && sourceText[nextChar] != '\n') {
3676: buf[m++] = '-';
3677: buf[m++] = '\n';
3678: wordWidth = 0;
3679: }
3680: }
3681: buf[m++] = sourceText[i++];
3682: wordWidth++;
3683: }
3684: }
3685: buf[m] = '\0';
3686: strcpy(sourceText, buf);
3687: }
3688:
3689: // Returns the number of lines, including the newlines already in the text.
3690: // Puts the output in "to" only if we receive a "to" -- can make it null and just get a line count.
3691: short wrapText(char *to, const char *sourceText, short width) {
3692: short i, w, textLength, lineCount;
3693: char printString[COLS * ROWS * 2];
3694: short spaceLeftOnLine, wordWidth;
3695:
3696: strcpy(printString, sourceText); // a copy we can write on
3697: breakUpLongWordsIn(printString, width, true); // break up any words that are wider than the width.
3698:
3699: textLength = strlen(printString); // do NOT discount escape sequences
3700: lineCount = 1;
3701:
3702: // Now go through and replace spaces with newlines as needed.
3703:
3704: // Fast foward until i points to the first character that is not a color escape.
3705: for (i=0; printString[i] == COLOR_ESCAPE; i+= 4);
3706: spaceLeftOnLine = width;
3707:
3708: while (i < textLength) {
3709: // wordWidth counts the word width of the next word without color escapes.
3710: // w indicates the position of the space or newline or null terminator that terminates the word.
3711: wordWidth = 0;
3712: for (w = i + 1; w < textLength && printString[w] != ' ' && printString[w] != '\n';) {
3713: if (printString[w] == COLOR_ESCAPE) {
3714: w += 4;
3715: } else {
3716: w++;
3717: wordWidth++;
3718: }
3719: }
3720:
3721: if (1 + wordWidth > spaceLeftOnLine || printString[i] == '\n') {
3722: printString[i] = '\n';
3723: lineCount++;
3724: spaceLeftOnLine = width - wordWidth; // line width minus the width of the word we just wrapped
3725: //printf("\n\n%s", printString);
3726: } else {
3727: spaceLeftOnLine -= 1 + wordWidth;
3728: }
3729: i = w; // Advance to the terminator that follows the word.
3730: }
3731: if (to) {
3732: strcpy(to, printString);
3733: }
3734: return lineCount;
3735: }
3736:
3737: // returns the y-coordinate of the last line
3738: short printStringWithWrapping(char *theString, short x, short y, short width, color *foreColor,
3739: color*backColor, cellDisplayBuffer dbuf[COLS][ROWS]) {
3740: color fColor;
3741: char printString[COLS * ROWS * 2];
3742: short i, px, py;
3743:
3744: wrapText(printString, theString, width); // inserts newlines as necessary
3745:
3746: // display the string
3747: px = x; //px and py are the print insertion coordinates; x and y remain the top-left of the text box
3748: py = y;
3749: fColor = *foreColor;
3750:
3751: for (i=0; printString[i] != '\0'; i++) {
3752: if (printString[i] == '\n') {
3753: px = x; // back to the leftmost column
3754: if (py < ROWS - 1) { // don't advance below the bottom of the screen
3755: py++; // next line
3756: } else {
3757: break; // If we've run out of room, stop.
3758: }
3759: continue;
3760: } else if (printString[i] == COLOR_ESCAPE) {
3761: i = decodeMessageColor(printString, i, &fColor) - 1;
3762: continue;
3763: }
3764:
3765: if (dbuf) {
3766: if (coordinatesAreInWindow(px, py)) {
3767: plotCharToBuffer(printString[i], px, py, &fColor, backColor, dbuf);
3768: }
3769: } else {
3770: if (coordinatesAreInWindow(px, py)) {
3771: plotCharWithColor(printString[i], px, py, &fColor, backColor);
3772: }
3773: }
3774:
3775: px++;
3776: }
3777: return py;
3778: }
3779:
3780: char nextKeyPress(boolean textInput) {
3781: rogueEvent theEvent;
3782: do {
3783: nextBrogueEvent(&theEvent, textInput, false, false);
3784: } while (theEvent.eventType != KEYSTROKE);
3785: return theEvent.param1;
3786: }
3787:
3788: #define BROGUE_HELP_LINE_COUNT 33
3789:
3790: void printHelpScreen() {
3791: short i, j;
3792: cellDisplayBuffer dbuf[COLS][ROWS], rbuf[COLS][ROWS];
3793: char helpText[BROGUE_HELP_LINE_COUNT][DCOLS*3] = {
3794: "",
3795: "",
3796: " -- Commands --",
3797: "",
3798: " mouse ****move cursor (including to examine monsters and terrain)",
3799: " click ****travel",
3800: " control-click ****advance one space",
3801: " <return> ****enable keyboard cursor control",
3802: " <space/esc> ****disable keyboard cursor control",
3803: "hjklyubn, arrow keys, or numpad ****move or attack (control or shift to run)",
3804: "",
3805: " a/e/r/t/d/c/R ****apply/equip/remove/throw/drop/call/relabel an item",
3806: " T ****re-throw last item at last monster",
3807: "i, right-click ****view inventory",
3808: " D ****list discovered items",
3809: "",
3810: " z ****rest once",
3811: " Z ****rest for 100 turns or until something happens",
3812: " s ****search for secrets (control-s: long search)",
3813: " <, > ****travel to stairs",
3814: " x ****auto-explore (control-x: fast forward)",
3815: " A ****autopilot (control-A: fast forward)",
3816: " M ****display old messages",
3817: " G ****toggle graphical tiles (when available)",
3818: "",
3819: " S ****suspend game and quit",
3820: " Q ****quit to title screen",
3821: "",
3822: " \\ ****disable/enable color effects",
3823: " ] ****display/hide stealth range",
3824: " <space/esc> ****clear message or cancel command",
3825: "",
3826: " -- press space or click to continue --"
3827: };
3828:
3829: // Replace the "****"s with color escapes.
3830: for (i=0; i<BROGUE_HELP_LINE_COUNT; i++) {
3831: for (j=0; helpText[i][j]; j++) {
3832: if (helpText[i][j] == '*') {
3833: j = encodeMessageColor(helpText[i], j, &white);
3834: }
3835: }
3836: }
3837:
3838: clearDisplayBuffer(dbuf);
3839:
3840: // Print the text to the dbuf.
3841: for (i=0; i<BROGUE_HELP_LINE_COUNT && i < ROWS; i++) {
3842: printString(helpText[i], mapToWindowX(1), i, &itemMessageColor, &black, dbuf);
3843: }
3844:
3845: // Set the dbuf opacity.
3846: for (i=0; i<DCOLS; i++) {
3847: for (j=0; j<ROWS; j++) {
3848: //plotCharWithColor(' ', mapToWindowX(i), j, &black, &black);
3849: dbuf[mapToWindowX(i)][j].opacity = INTERFACE_OPACITY;
3850: }
3851: }
3852:
3853: // Display.
3854: overlayDisplayBuffer(dbuf, rbuf);
3855: waitForAcknowledgment();
3856: overlayDisplayBuffer(rbuf, 0);
3857: updateFlavorText();
3858: updateMessageDisplay();
3859: }
3860:
3861: void printDiscoveries(short category, short count, unsigned short itemCharacter, short x, short y, cellDisplayBuffer dbuf[COLS][ROWS]) {
3862: color *theColor, goodColor, badColor;
3863: char buf[COLS], buf2[COLS];
3864: short i, magic, totalFrequency;
3865: itemTable *theTable = tableForItemCategory(category, NULL);
3866:
3867: goodColor = goodMessageColor;
3868: applyColorAverage(&goodColor, &black, 50);
3869: badColor = badMessageColor;
3870: applyColorAverage(&badColor, &black, 50);
3871:
3872: totalFrequency = 0;
3873: for (i = 0; i < count; i++) {
3874: if (!theTable[i].identified) {
3875: totalFrequency += theTable[i].frequency;
3876: }
3877: }
3878:
3879: for (i = 0; i < count; i++) {
3880: if (theTable[i].identified) {
3881: theColor = &white;
3882: plotCharToBuffer(itemCharacter, x, y + i, &itemColor, &black, dbuf);
3883: } else {
3884: theColor = &darkGray;
3885: magic = magicCharDiscoverySuffix(category, i);
3886: if (magic == 1) {
3887: plotCharToBuffer(G_GOOD_MAGIC, x, y + i, &goodColor, &black, dbuf);
3888: } else if (magic == -1) {
3889: plotCharToBuffer(G_BAD_MAGIC, x, y + i, &badColor, &black, dbuf);
3890: }
3891: }
3892: strcpy(buf, theTable[i].name);
3893:
3894: if (!theTable[i].identified
3895: && theTable[i].frequency > 0
3896: && totalFrequency > 0) {
3897:
3898: sprintf(buf2, " (%i%%)", theTable[i].frequency * 100 / totalFrequency);
3899: strcat(buf, buf2);
3900: }
3901:
3902: upperCase(buf);
3903: strcat(buf, " ");
3904: printString(buf, x + 2, y + i, theColor, &black, dbuf);
3905: }
3906: }
3907:
3908: void printDiscoveriesScreen() {
3909: short i, j, y;
3910: cellDisplayBuffer dbuf[COLS][ROWS], rbuf[COLS][ROWS];
3911:
3912: clearDisplayBuffer(dbuf);
3913:
3914: printString("-- SCROLLS --", mapToWindowX(2), y = mapToWindowY(1), &flavorTextColor, &black, dbuf);
3915: printDiscoveries(SCROLL, NUMBER_SCROLL_KINDS, G_SCROLL, mapToWindowX(3), ++y, dbuf);
3916:
3917: printString("-- RINGS --", mapToWindowX(2), y += NUMBER_SCROLL_KINDS + 1, &flavorTextColor, &black, dbuf);
3918: printDiscoveries(RING, NUMBER_RING_KINDS, G_RING, mapToWindowX(3), ++y, dbuf);
3919:
3920: printString("-- POTIONS --", mapToWindowX(29), y = mapToWindowY(1), &flavorTextColor, &black, dbuf);
3921: printDiscoveries(POTION, NUMBER_POTION_KINDS, G_POTION, mapToWindowX(30), ++y, dbuf);
3922:
3923: printString("-- STAFFS --", mapToWindowX(53), y = mapToWindowY(1), &flavorTextColor, &black, dbuf);
3924: printDiscoveries(STAFF, NUMBER_STAFF_KINDS, G_STAFF, mapToWindowX(54), ++y, dbuf);
3925:
3926: printString("-- WANDS --", mapToWindowX(53), y += NUMBER_STAFF_KINDS + 1, &flavorTextColor, &black, dbuf);
3927: printDiscoveries(WAND, NUMBER_WAND_KINDS, G_WAND, mapToWindowX(54), ++y, dbuf);
3928:
3929: printString(KEYBOARD_LABELS ? "-- press any key to continue --" : "-- touch anywhere to continue --",
3930: mapToWindowX(20), mapToWindowY(DROWS-2), &itemMessageColor, &black, dbuf);
3931:
3932: for (i=0; i<COLS; i++) {
3933: for (j=0; j<ROWS; j++) {
3934: dbuf[i][j].opacity = (i < STAT_BAR_WIDTH ? 0 : INTERFACE_OPACITY);
3935: }
3936: }
3937: overlayDisplayBuffer(dbuf, rbuf);
3938:
3939: waitForKeystrokeOrMouseClick();
3940:
3941: overlayDisplayBuffer(rbuf, NULL);
3942: }
3943:
3944: // Creates buttons for the discoveries screen in the buttons pointer; returns the number of buttons created.
3945: //short createDiscoveriesButtons(short category, short count, unsigned short itemCharacter, short x, short y, brogueButton *buttons) {
3946: // color goodColor, badColor;
3947: // char whiteColorEscape[20] = "", darkGrayColorEscape[20] = "", yellowColorEscape[20] = "", goodColorEscape[20] = "", badColorEscape[20] = "";
3948: // short i, magic, symbolCount;
3949: // itemTable *theTable = tableForItemCategory(category, NULL);
3950: // char buf[COLS] = "";
3951: //
3952: // goodColor = goodMessageColor;
3953: // applyColorAverage(&goodColor, &black, 50);
3954: // encodeMessageColor(goodColorEscape, 0, &goodColor);
3955: // badColor = badMessageColor;
3956: // applyColorAverage(&badColor, &black, 50);
3957: // encodeMessageColor(badColorEscape, 0, &badColor);
3958: // encodeMessageColor(whiteColorEscape, 0, &white);
3959: // encodeMessageColor(darkGrayColorEscape, 0, &darkGray);
3960: // encodeMessageColor(yellowColorEscape, 0, &itemColor);
3961: //
3962: // for (i = 0; i < count; i++) {
3963: // initializeButton(&(buttons[i]));
3964: // buttons[i].flags = (B_DRAW | B_HOVER_ENABLED | B_ENABLED); // Clear other flags.
3965: // buttons[i].buttonColor = black;
3966: // buttons[i].opacity = 100;
3967: // buttons[i].x = x;
3968: // buttons[i].y = y + i;
3969: // symbolCount = 0;
3970: // if (theTable[i].identified) {
3971: // strcat(buttons[i].text, yellowColorEscape);
3972: // buttons[i].symbol[symbolCount++] = itemCharacter;
3973: // strcat(buttons[i].text, "*");
3974: // strcat(buttons[i].text, whiteColorEscape);
3975: // strcat(buttons[i].text, " ");
3976: // } else {
3977: // strcat(buttons[i].text, " ");
3978: // strcat(buttons[i].text, darkGrayColorEscape);
3979: // }
3980: // strcpy(buf, theTable[i].name);
3981: // upperCase(buf);
3982: // strcat(buttons[i].text, buf);
3983: // strcat(buttons[i].text, " ");
3984: // strcat(buttons[i].text, darkGrayColorEscape);
3985: // magic = magicCharDiscoverySuffix(category, i);
3986: // strcat(buttons[i].text, "(");
3987: // if (magic != -1) {
3988: // strcat(buttons[i].text, goodColorEscape);
3989: // strcat(buttons[i].text, "*");
3990: // buttons[i].symbol[symbolCount++] = G_GOOD_MAGIC;
3991: // }
3992: // if (magic != 1) {
3993: // strcat(buttons[i].text, badColorEscape);
3994: // strcat(buttons[i].text, "*");
3995: // buttons[i].symbol[symbolCount++] = BAD_MAGIC_CHAR;
3996: // }
3997: // strcat(buttons[i].text, darkGrayColorEscape);
3998: // strcat(buttons[i].text, ")");
3999: // }
4000: // return i;
4001: //}
4002: //
4003: //void printDiscoveriesScreen() {
4004: // short i, j, y, buttonCount;
4005: // cellDisplayBuffer dbuf[COLS][ROWS], rbuf[COLS][ROWS];
4006: // brogueButton buttons[NUMBER_SCROLL_KINDS + NUMBER_WAND_KINDS + NUMBER_POTION_KINDS + NUMBER_STAFF_KINDS + NUMBER_RING_KINDS] = {{{0}}};
4007: // rogueEvent theEvent;
4008: //
4009: // clearDisplayBuffer(dbuf);
4010: // buttonCount = 0;
4011: //
4012: // printString("-- SCROLLS --", mapToWindowX(3), y = mapToWindowY(1), &flavorTextColor, &black, dbuf);
4013: // buttonCount += createDiscoveriesButtons(SCROLL, NUMBER_SCROLL_KINDS, SCROLL_CHAR, mapToWindowX(3), ++y, &(buttons[buttonCount]));
4014: //
4015: // printString("-- WANDS --", mapToWindowX(3), y += NUMBER_SCROLL_KINDS + 1, &flavorTextColor, &black, dbuf);
4016: // buttonCount += createDiscoveriesButtons(WAND, NUMBER_WAND_KINDS, WAND_CHAR, mapToWindowX(3), ++y, &(buttons[buttonCount]));
4017: //
4018: // printString("-- POTIONS --", mapToWindowX(29), y = mapToWindowY(1), &flavorTextColor, &black, dbuf);
4019: // buttonCount += createDiscoveriesButtons(POTION, NUMBER_POTION_KINDS, POTION_CHAR, mapToWindowX(29), ++y, &(buttons[buttonCount]));
4020: //
4021: // printString("-- STAFFS --", mapToWindowX(54), y = mapToWindowY(1), &flavorTextColor, &black, dbuf);
4022: // buttonCount += createDiscoveriesButtons(STAFF, NUMBER_STAFF_KINDS, STAFF_CHAR, mapToWindowX(54), ++y, &(buttons[buttonCount]));
4023: //
4024: // printString("-- RINGS --", mapToWindowX(54), y += NUMBER_STAFF_KINDS + 1, &flavorTextColor, &black, dbuf);
4025: // buttonCount += createDiscoveriesButtons(RING, NUMBER_RING_KINDS, RING_CHAR, mapToWindowX(54), ++y, &(buttons[buttonCount]));
4026: //
4027: // for (i=0; i<COLS; i++) {
4028: // for (j=0; j<ROWS; j++) {
4029: // dbuf[i][j].opacity = (i < STAT_BAR_WIDTH ? 0 : INTERFACE_OPACITY);
4030: // }
4031: // }
4032: // overlayDisplayBuffer(dbuf, rbuf);
4033: // y = buttonInputLoop(buttons,
4034: // buttonCount,
4035: // mapToWindowX(3),
4036: // mapToWindowY(1),
4037: // DCOLS - 6,
4038: // DROWS - 2,
4039: // &theEvent);
4040: // overlayDisplayBuffer(rbuf, NULL);
4041: //}
4042:
4043: void printHighScores(boolean hiliteMostRecent) {
4044: short i, hiliteLineNum, maxLength = 0, leftOffset;
4045: rogueHighScoresEntry list[HIGH_SCORES_COUNT] = {{0}};
4046: char buf[DCOLS*3];
4047: color scoreColor;
4048:
4049: hiliteLineNum = getHighScoresList(list);
4050:
4051: if (!hiliteMostRecent) {
4052: hiliteLineNum = -1;
4053: }
4054:
4055: blackOutScreen();
4056:
4057: for (i = 0; i < HIGH_SCORES_COUNT && list[i].score > 0; i++) {
4058: if (strLenWithoutEscapes(list[i].description) > maxLength) {
4059: maxLength = strLenWithoutEscapes(list[i].description);
4060: }
4061: }
4062:
4063: leftOffset = min(COLS - maxLength - 23 - 1, COLS/5);
4064:
4065: scoreColor = black;
4066: applyColorAverage(&scoreColor, &itemMessageColor, 100);
4067: printString("-- HIGH SCORES --", (COLS - 17 + 1) / 2, 0, &scoreColor, &black, 0);
4068:
4069: for (i = 0; i < HIGH_SCORES_COUNT && list[i].score > 0; i++) {
4070: scoreColor = black;
4071: if (i == hiliteLineNum) {
4072: applyColorAverage(&scoreColor, &itemMessageColor, 100);
4073: } else {
4074: applyColorAverage(&scoreColor, &white, 100);
4075: applyColorAverage(&scoreColor, &black, (i * 50 / 24));
4076: }
4077:
4078: // rank
4079: sprintf(buf, "%s%i)", (i + 1 < 10 ? " " : ""), i + 1);
4080: printString(buf, leftOffset, i + 2, &scoreColor, &black, 0);
4081:
4082: // score
4083: sprintf(buf, "%li", list[i].score);
4084: printString(buf, leftOffset + 5, i + 2, &scoreColor, &black, 0);
4085:
4086: // date
4087: printString(list[i].date, leftOffset + 12, i + 2, &scoreColor, &black, 0);
4088:
4089: // description
4090: printString(list[i].description, leftOffset + 23, i + 2, &scoreColor, &black, 0);
4091: }
4092:
4093: scoreColor = black;
4094: applyColorAverage(&scoreColor, &goodMessageColor, 100);
4095:
4096: printString(KEYBOARD_LABELS ? "Press space to continue." : "Touch anywhere to continue.",
4097: (COLS - strLenWithoutEscapes(KEYBOARD_LABELS ? "Press space to continue." : "Touch anywhere to continue.")) / 2,
4098: ROWS - 1, &scoreColor, &black, 0);
4099:
4100: commitDraws();
4101: waitForAcknowledgment();
4102: }
4103:
4104: void displayGrid(short **map) {
4105: short i, j, score, topRange, bottomRange;
4106: color tempColor, foreColor, backColor;
4107: enum displayGlyph dchar;
4108:
4109: topRange = -30000;
4110: bottomRange = 30000;
4111: tempColor = black;
4112:
4113: if (map == safetyMap && !rogue.updatedSafetyMapThisTurn) {
4114: updateSafetyMap();
4115: }
4116:
4117: for (i=0; i<DCOLS; i++) {
4118: for (j=0; j<DROWS; j++) {
4119: if (cellHasTerrainFlag(i, j, T_WAYPOINT_BLOCKER) || (map[i][j] == map[0][0]) || (i == player.xLoc && j == player.yLoc)) {
4120: continue;
4121: }
4122: if (map[i][j] > topRange) {
4123: topRange = map[i][j];
4124: //if (topRange == 0) {
4125: //printf("\ntop is zero at %i,%i", i, j);
4126: //}
4127: }
4128: if (map[i][j] < bottomRange) {
4129: bottomRange = map[i][j];
4130: }
4131: }
4132: }
4133:
4134: for (i=0; i<DCOLS; i++) {
4135: for (j=0; j<DROWS; j++) {
4136: if (cellHasTerrainFlag(i, j, T_OBSTRUCTS_PASSABILITY | T_LAVA_INSTA_DEATH)
4137: || (map[i][j] == map[0][0])
4138: || (i == player.xLoc && j == player.yLoc)) {
4139: continue;
4140: }
4141: score = 300 - (map[i][j] - bottomRange) * 300 / max(1, (topRange - bottomRange));
4142: tempColor.blue = max(min(score, 100), 0);
4143: score -= 100;
4144: tempColor.red = max(min(score, 100), 0);
4145: score -= 100;
4146: tempColor.green = max(min(score, 100), 0);
4147: getCellAppearance(i, j, &dchar, &foreColor, &backColor);
4148: plotCharWithColor(dchar, mapToWindowX(i), mapToWindowY(j), &foreColor, &tempColor);
4149: //colorBlendCell(i, j, &tempColor, 100);//hiliteCell(i, j, &tempColor, 100, false);
4150: }
4151: }
4152: //printf("\ntop: %i; bottom: %i", topRange, bottomRange);
4153: }
4154:
4155: void printSeed() {
4156: char buf[COLS];
4157: sprintf(buf, "Dungeon seed #%lu; turn #%lu; version %s", rogue.seed, rogue.playerTurnNumber, BROGUE_VERSION_STRING);
4158: message(buf, false);
4159: }
4160:
4161: void printProgressBar(short x, short y, const char barLabel[COLS], long amtFilled, long amtMax, color *fillColor, boolean dim) {
4162: char barText[] = " "; // string length is 20
4163: short i, labelOffset;
4164: color currentFillColor, textColor, progressBarColor, darkenedBarColor;
4165:
4166: if (y >= ROWS - 1) { // don't write over the depth number
4167: return;
4168: }
4169:
4170: if (amtFilled > amtMax) {
4171: amtFilled = amtMax;
4172: }
4173:
4174: if (amtMax <= 0) {
4175: amtMax = 1;
4176: }
4177:
4178: progressBarColor = *fillColor;
4179: if (!(y % 2)) {
4180: applyColorAverage(&progressBarColor, &black, 25);
4181: }
4182:
4183: if (dim) {
4184: applyColorAverage(&progressBarColor, &black, 50);
4185: }
4186: darkenedBarColor = progressBarColor;
4187: applyColorAverage(&darkenedBarColor, &black, 75);
4188:
4189: labelOffset = (20 - strlen(barLabel)) / 2;
4190: for (i = 0; i < (short) strlen(barLabel); i++) {
4191: barText[i + labelOffset] = barLabel[i];
4192: }
4193:
4194: amtFilled = clamp(amtFilled, 0, amtMax);
4195:
4196: if (amtMax < 10000000) {
4197: amtFilled *= 100;
4198: amtMax *= 100;
4199: }
4200:
4201: for (i=0; i<20; i++) {
4202: currentFillColor = (i <= (20 * amtFilled / amtMax) ? progressBarColor : darkenedBarColor);
4203: if (i == 20 * amtFilled / amtMax) {
4204: applyColorAverage(¤tFillColor, &black, 75 - 75 * (amtFilled % (amtMax / 20)) / (amtMax / 20));
4205: }
4206: textColor = (dim ? gray : white);
4207: applyColorAverage(&textColor, ¤tFillColor, (dim ? 50 : 33));
4208: plotCharWithColor(barText[i], x + i, y, &textColor, ¤tFillColor);
4209: }
4210: }
4211:
4212: // Very low-level. Changes displayBuffer directly.
4213: void highlightScreenCell(short x, short y, color *highlightColor, short strength) {
4214: color tempColor;
4215:
4216: tempColor = colorFromComponents(displayBuffer[x][y].foreColorComponents);
4217: applyColorAugment(&tempColor, highlightColor, strength);
4218: storeColorComponents(displayBuffer[x][y].foreColorComponents, &tempColor);
4219:
4220: tempColor = colorFromComponents(displayBuffer[x][y].backColorComponents);
4221: applyColorAugment(&tempColor, highlightColor, strength);
4222: storeColorComponents(displayBuffer[x][y].backColorComponents, &tempColor);
4223:
4224: displayBuffer[x][y].needsUpdate = true;
4225: }
4226:
4227: short estimatedArmorValue() {
4228: short retVal;
4229:
4230: retVal = ((armorTable[rogue.armor->kind].range.upperBound + armorTable[rogue.armor->kind].range.lowerBound) / 2) / 10;
4231: retVal += strengthModifier(rogue.armor) / FP_FACTOR;
4232: retVal -= player.status[STATUS_DONNING];
4233:
4234: return max(0, retVal);
4235: }
4236:
4237: short creatureHealthChangePercent(creature *monst) {
4238: if (monst->previousHealthPoints <= 0) {
4239: return 0;
4240: }
4241: // ignore overhealing from tranference
4242: return 100 * (monst->currentHP - min(monst->previousHealthPoints, monst->info.maxHP)) / monst->info.maxHP;
4243: }
4244:
4245: // returns the y-coordinate after the last line printed
4246: short printMonsterInfo(creature *monst, short y, boolean dim, boolean highlight) {
4247: char buf[COLS * 2], buf2[COLS * 2], monstName[COLS], tempColorEscape[5], grayColorEscape[5];
4248: enum displayGlyph monstChar;
4249: color monstForeColor, monstBackColor, healthBarColor, tempColor;
4250: short initialY, i, j, highlightStrength, displayedArmor, percent;
4251: boolean inPath;
4252: short oldRNG;
4253:
4254: const char hallucinationStrings[16][COLS] = {
4255: " (Dancing) ",
4256: " (Singing) ",
4257: " (Pontificating) ",
4258: " (Skipping) ",
4259: " (Spinning) ",
4260: " (Crying) ",
4261: " (Laughing) ",
4262: " (Humming) ",
4263: " (Whistling) ",
4264: " (Quivering) ",
4265: " (Muttering) ",
4266: " (Gibbering) ",
4267: " (Giggling) ",
4268: " (Moaning) ",
4269: " (Shrieking) ",
4270: " (Caterwauling) ",
4271: };
4272: const char statusStrings[NUMBER_OF_STATUS_EFFECTS][COLS] = {
4273: "Searching",
4274: "Donning Armor",
4275: "Weakened: -",
4276: "Telepathic",
4277: "Hallucinating",
4278: "Levitating",
4279: "Slowed",
4280: "Hasted",
4281: "Confused",
4282: "Burning",
4283: "Paralyzed",
4284: "Poisoned",
4285: "Stuck",
4286: "Nauseous",
4287: "Discordant",
4288: "Immune to Fire",
4289: "", // STATUS_EXPLOSION_IMMUNITY,
4290: "", // STATUS_NUTRITION,
4291: "", // STATUS_ENTERS_LEVEL_IN,
4292: "Frightened",
4293: "Entranced",
4294: "Darkened",
4295: "Lifespan",
4296: "Shielded",
4297: "Invisible",
4298: };
4299:
4300: if (y >= ROWS - 1) {
4301: return ROWS - 1;
4302: }
4303:
4304: initialY = y;
4305:
4306: oldRNG = rogue.RNG;
4307: rogue.RNG = RNG_COSMETIC;
4308: //assureCosmeticRNG;
4309:
4310: if (y < ROWS - 1) {
4311: printString(" ", 0, y, &white, &black, 0); // Start with a blank line
4312:
4313: // Unhighlight if it's highlighted as part of the path.
4314: inPath = (pmap[monst->xLoc][monst->yLoc].flags & IS_IN_PATH) ? true : false;
4315: pmap[monst->xLoc][monst->yLoc].flags &= ~IS_IN_PATH;
4316: getCellAppearance(monst->xLoc, monst->yLoc, &monstChar, &monstForeColor, &monstBackColor);
4317: applyColorBounds(&monstForeColor, 0, 100);
4318: applyColorBounds(&monstBackColor, 0, 100);
4319: if (inPath) {
4320: pmap[monst->xLoc][monst->yLoc].flags |= IS_IN_PATH;
4321: }
4322:
4323: if (dim) {
4324: applyColorAverage(&monstForeColor, &black, 50);
4325: applyColorAverage(&monstBackColor, &black, 50);
4326: } else if (highlight) {
4327: applyColorAugment(&monstForeColor, &black, 100);
4328: applyColorAugment(&monstBackColor, &black, 100);
4329: }
4330: plotCharWithColor(monstChar, 0, y, &monstForeColor, &monstBackColor);
4331: if(monst->carriedItem) {
4332: plotCharWithColor(monst->carriedItem->displayChar, 1, y, &itemColor, &black);
4333: }
4334: monsterName(monstName, monst, false);
4335: upperCase(monstName);
4336:
4337: if (monst == &player) {
4338: if (player.status[STATUS_INVISIBLE]) {
4339: strcat(monstName, " xxxx");
4340: encodeMessageColor(monstName, strlen(monstName) - 4, &monstForeColor);
4341: strcat(monstName, "(invisible)");
4342: } else if (playerInDarkness()) {
4343: strcat(monstName, " xxxx");
4344: //encodeMessageColor(monstName, strlen(monstName) - 4, &playerInDarknessColor);
4345: encodeMessageColor(monstName, strlen(monstName) - 4, &monstForeColor);
4346: strcat(monstName, "(dark)");
4347: } else if (!(pmap[player.xLoc][player.yLoc].flags & IS_IN_SHADOW)) {
4348: strcat(monstName, " xxxx");
4349: //encodeMessageColor(monstName, strlen(monstName) - 4, &playerInLightColor);
4350: encodeMessageColor(monstName, strlen(monstName) - 4, &monstForeColor);
4351: strcat(monstName, "(lit)");
4352: }
4353: }
4354:
4355: sprintf(buf, ": %s", monstName);
4356: printString(buf, monst->carriedItem?2:1, y++, (dim ? &gray : &white), &black, 0);
4357: }
4358:
4359: // mutation, if any
4360: if (y < ROWS - 1
4361: && monst->mutationIndex >= 0
4362: && (!player.status[STATUS_HALLUCINATING] || rogue.playbackOmniscience)) {
4363:
4364: strcpy(buf, " ");
4365: sprintf(buf2, "xxxx(%s)", mutationCatalog[monst->mutationIndex].title);
4366: tempColor = *mutationCatalog[monst->mutationIndex].textColor;
4367: if (dim) {
4368: applyColorAverage(&tempColor, &black, 50);
4369: }
4370: encodeMessageColor(buf2, 0, &tempColor);
4371: strcpy(buf + ((strLenWithoutEscapes(buf) - strLenWithoutEscapes(buf2)) / 2), buf2);
4372: for (i = strlen(buf); i < 20 + 4; i++) {
4373: buf[i] = ' ';
4374: }
4375: buf[24] = '\0';
4376: printString(buf, 0, y++, (dim ? &gray : &white), &black, 0);
4377: }
4378:
4379: // hit points
4380: if (monst->info.maxHP > 1
4381: && !(monst->info.flags & MONST_INVULNERABLE)) {
4382:
4383: if (monst == &player) {
4384: healthBarColor = redBar;
4385: applyColorAverage(&healthBarColor, &blueBar, min(100, 100 * player.currentHP / player.info.maxHP));
4386: } else {
4387: healthBarColor = blueBar;
4388: }
4389: percent = creatureHealthChangePercent(monst);
4390: if (monst->currentHP <= 0) {
4391: strcpy(buf, "Dead");
4392: } else if (percent != 0) {
4393: strcpy(buf, " Health ");
4394: sprintf(buf2, "(%s%i%%)", percent > 0 ? "+" : "", percent);
4395: strcpy(&(buf[20 - strlen(buf2)]), buf2);
4396: } else {
4397: strcpy(buf, "Health");
4398: }
4399: printProgressBar(0, y++, buf, monst->currentHP, monst->info.maxHP, &healthBarColor, dim);
4400: }
4401:
4402: if (monst == &player) {
4403: // nutrition
4404: if (player.status[STATUS_NUTRITION] > HUNGER_THRESHOLD) {
4405: printProgressBar(0, y++, "Nutrition", player.status[STATUS_NUTRITION], STOMACH_SIZE, &blueBar, dim);
4406: } else if (player.status[STATUS_NUTRITION] > WEAK_THRESHOLD) {
4407: printProgressBar(0, y++, "Nutrition (Hungry)", player.status[STATUS_NUTRITION], STOMACH_SIZE, &blueBar, dim);
4408: } else if (player.status[STATUS_NUTRITION] > FAINT_THRESHOLD) {
4409: printProgressBar(0, y++, "Nutrition (Weak)", player.status[STATUS_NUTRITION], STOMACH_SIZE, &blueBar, dim);
4410: } else if (player.status[STATUS_NUTRITION] > 0) {
4411: printProgressBar(0, y++, "Nutrition (Faint)", player.status[STATUS_NUTRITION], STOMACH_SIZE, &blueBar, dim);
4412: } else if (y < ROWS - 1) {
4413: printString(" STARVING ", 0, y++, &badMessageColor, &black, NULL);
4414: }
4415: }
4416:
4417: if (!player.status[STATUS_HALLUCINATING] || rogue.playbackOmniscience || monst == &player) {
4418:
4419: for (i=0; i<NUMBER_OF_STATUS_EFFECTS; i++) {
4420: if (i == STATUS_WEAKENED && monst->status[i] > 0) {
4421: sprintf(buf, "%s%i", statusStrings[STATUS_WEAKENED], monst->weaknessAmount);
4422: printProgressBar(0, y++, buf, monst->status[i], monst->maxStatus[i], &redBar, dim);
4423: } else if (i == STATUS_LEVITATING && monst->status[i] > 0) {
4424: printProgressBar(0, y++, (monst == &player ? "Levitating" : "Flying"), monst->status[i], monst->maxStatus[i], &redBar, dim);
4425: } else if (i == STATUS_POISONED
4426: && monst->status[i] > 0) {
4427:
4428:
4429: if (monst->status[i] * monst->poisonAmount >= monst->currentHP) {
4430: strcpy(buf, "Fatal Poison");
4431: } else {
4432: strcpy(buf, "Poisoned");
4433: }
4434: if (monst->poisonAmount == 1) {
4435: printProgressBar(0, y++, buf, monst->status[i], monst->maxStatus[i], &redBar, dim);
4436: } else {
4437: sprintf(buf2, "%s (x%i)",
4438: buf,
4439: monst->poisonAmount);
4440: printProgressBar(0, y++, buf2, monst->status[i], monst->maxStatus[i], &redBar, dim);
4441: }
4442: } else if (statusStrings[i][0] && monst->status[i] > 0) {
4443: printProgressBar(0, y++, statusStrings[i], monst->status[i], monst->maxStatus[i], &redBar, dim);
4444: }
4445: }
4446: if (monst->targetCorpseLoc[0] == monst->xLoc && monst->targetCorpseLoc[1] == monst->yLoc) {
4447: printProgressBar(0, y++, monsterText[monst->info.monsterID].absorbStatus, monst->corpseAbsorptionCounter, 20, &redBar, dim);
4448: }
4449: }
4450:
4451: if (monst != &player
4452: && (!(monst->info.flags & MONST_INANIMATE)
4453: || monst->creatureState == MONSTER_ALLY)) {
4454:
4455: if (y < ROWS - 1) {
4456: if (player.status[STATUS_HALLUCINATING] && !rogue.playbackOmniscience && y < ROWS - 1) {
4457: printString(hallucinationStrings[rand_range(0, 9)], 0, y++, (dim ? &darkGray : &gray), &black, 0);
4458: } else if (monst->bookkeepingFlags & MB_CAPTIVE && y < ROWS - 1) {
4459: printString(" (Captive) ", 0, y++, (dim ? &darkGray : &gray), &black, 0);
4460: } else if ((monst->info.flags & MONST_RESTRICTED_TO_LIQUID)
4461: && !cellHasTMFlag(monst->xLoc, monst->yLoc, TM_ALLOWS_SUBMERGING)) {
4462: printString(" (Helpless) ", 0, y++, (dim ? &darkGray : &gray), &black, 0);
4463: } else if (monst->creatureState == MONSTER_SLEEPING && y < ROWS - 1) {
4464: printString(" (Sleeping) ", 0, y++, (dim ? &darkGray : &gray), &black, 0);
4465: } else if ((monst->creatureState == MONSTER_ALLY) && y < ROWS - 1) {
4466: printString(" (Ally) ", 0, y++, (dim ? &darkGray : &gray), &black, 0);
4467: } else if (monst->creatureState == MONSTER_FLEEING && y < ROWS - 1) {
4468: printString(" (Fleeing) ", 0, y++, (dim ? &darkGray : &gray), &black, 0);
4469: } else if ((monst->creatureState == MONSTER_WANDERING) && y < ROWS - 1) {
4470: if ((monst->bookkeepingFlags & MB_FOLLOWER) && monst->leader && (monst->leader->info.flags & MONST_IMMOBILE)) {
4471: // follower of an immobile leader -- i.e. a totem
4472: printString(" (Worshiping) ", 0, y++, (dim ? &darkGray : &gray), &black, 0);
4473: } else if ((monst->bookkeepingFlags & MB_FOLLOWER) && monst->leader && (monst->leader->bookkeepingFlags & MB_CAPTIVE)) {
4474: // actually a captor/torturer
4475: printString(" (Guarding) ", 0, y++, (dim ? &darkGray : &gray), &black, 0);
4476: } else {
4477: printString(" (Wandering) ", 0, y++, (dim ? &darkGray : &gray), &black, 0);
4478: }
4479: } else if (monst->ticksUntilTurn > max(0, player.ticksUntilTurn) + player.movementSpeed) {
4480: printString(" (Off balance) ", 0, y++, (dim ? &darkGray : &gray), &black, 0);
4481: } else if ((monst->creatureState == MONSTER_TRACKING_SCENT) && y < ROWS - 1) {
4482: printString(" (Hunting) ", 0, y++, (dim ? &darkGray : &gray), &black, 0);
4483: }
4484: }
4485: } else if (monst == &player) {
4486: if (y < ROWS - 1) {
4487: tempColorEscape[0] = '\0';
4488: grayColorEscape[0] = '\0';
4489: if (player.status[STATUS_WEAKENED]) {
4490: tempColor = red;
4491: if (dim) {
4492: applyColorAverage(&tempColor, &black, 50);
4493: }
4494: encodeMessageColor(tempColorEscape, 0, &tempColor);
4495: encodeMessageColor(grayColorEscape, 0, (dim ? &darkGray : &gray));
4496: }
4497:
4498: displayedArmor = displayedArmorValue();
4499:
4500: if (!rogue.armor || rogue.armor->flags & ITEM_IDENTIFIED || rogue.playbackOmniscience) {
4501:
4502: sprintf(buf, "Str: %s%i%s Armor: %i",
4503: tempColorEscape,
4504: rogue.strength - player.weaknessAmount,
4505: grayColorEscape,
4506: displayedArmor);
4507: } else {
4508: sprintf(buf, "Str: %s%i%s Armor: %i?",
4509: tempColorEscape,
4510: rogue.strength - player.weaknessAmount,
4511: grayColorEscape,
4512: estimatedArmorValue());
4513: }
4514: //buf[20] = '\0';
4515: printString(" ", 0, y, &white, &black, 0);
4516: printString(buf, (20 - strLenWithoutEscapes(buf)) / 2, y++, (dim ? &darkGray : &gray), &black, 0);
4517: }
4518: if (y < ROWS - 1 && rogue.gold) {
4519: sprintf(buf, "Gold: %li", rogue.gold);
4520: buf[20] = '\0';
4521: printString(" ", 0, y, &white, &black, 0);
4522: printString(buf, (20 - strLenWithoutEscapes(buf)) / 2, y++, (dim ? &darkGray : &gray), &black, 0);
4523: }
4524: if (y < ROWS - 1) {
4525: tempColorEscape[0] = '\0';
4526: grayColorEscape[0] = '\0';
4527: tempColor = playerInShadowColor;
4528: percent = (rogue.aggroRange - 2) * 100 / 28;
4529: applyColorAverage(&tempColor, &black, percent);
4530: applyColorAugment(&tempColor, &playerInLightColor, percent);
4531: if (dim) {
4532: applyColorAverage(&tempColor, &black, 50);
4533: }
4534: encodeMessageColor(tempColorEscape, 0, &tempColor);
4535: encodeMessageColor(grayColorEscape, 0, (dim ? &darkGray : &gray));
4536: sprintf(buf, "%sStealth range: %i%s",
4537: tempColorEscape,
4538: rogue.aggroRange,
4539: grayColorEscape);
4540: printString(" ", 0, y, &white, &black, 0);
4541: printString(buf, 1, y++, (dim ? &darkGray : &gray), &black, 0);
4542: }
4543: }
4544:
4545: if (y < ROWS - 1) {
4546: printString(" ", 0, y++, (dim ? &darkGray : &gray), &black, 0);
4547: }
4548:
4549: if (highlight) {
4550: for (i=0; i<20; i++) {
4551: highlightStrength = smoothHiliteGradient(i, 20-1) / 10;
4552: for (j=initialY; j < (y == ROWS - 1 ? y : min(y - 1, ROWS - 1)); j++) {
4553: highlightScreenCell(i, j, &white, highlightStrength);
4554: }
4555: }
4556: }
4557:
4558: restoreRNG;
4559: return y;
4560: }
4561:
4562: void describeHallucinatedItem(char *buf) {
4563: const unsigned short itemCats[10] = {FOOD, WEAPON, ARMOR, POTION, SCROLL, STAFF, WAND, RING, CHARM, GOLD};
4564: short cat, kind, maxKinds;
4565: assureCosmeticRNG;
4566: cat = itemCats[rand_range(0, 9)];
4567: tableForItemCategory(cat, &maxKinds);
4568: kind = rand_range(0, maxKinds - 1);
4569: describedItemBasedOnParameters(cat, kind, 1, 1, buf);
4570: restoreRNG;
4571: }
4572:
4573: // Returns the y-coordinate after the last line printed.
4574: short printItemInfo(item *theItem, short y, boolean dim, boolean highlight) {
4575: char name[COLS * 3];
4576: enum displayGlyph itemChar;
4577: color itemForeColor, itemBackColor;
4578: short initialY, i, j, highlightStrength, lineCount;
4579: boolean inPath;
4580: short oldRNG;
4581:
4582: if (y >= ROWS - 1) {
4583: return ROWS - 1;
4584: }
4585:
4586: initialY = y;
4587:
4588: oldRNG = rogue.RNG;
4589: rogue.RNG = RNG_COSMETIC;
4590: //assureCosmeticRNG;
4591:
4592: if (y < ROWS - 1) {
4593: // Unhighlight if it's highlighted as part of the path.
4594: inPath = (pmap[theItem->xLoc][theItem->yLoc].flags & IS_IN_PATH) ? true : false;
4595: pmap[theItem->xLoc][theItem->yLoc].flags &= ~IS_IN_PATH;
4596: getCellAppearance(theItem->xLoc, theItem->yLoc, &itemChar, &itemForeColor, &itemBackColor);
4597: applyColorBounds(&itemForeColor, 0, 100);
4598: applyColorBounds(&itemBackColor, 0, 100);
4599: if (inPath) {
4600: pmap[theItem->xLoc][theItem->yLoc].flags |= IS_IN_PATH;
4601: }
4602: if (dim) {
4603: applyColorAverage(&itemForeColor, &black, 50);
4604: applyColorAverage(&itemBackColor, &black, 50);
4605: }
4606: plotCharWithColor(itemChar, 0, y, &itemForeColor, &itemBackColor);
4607: printString(": ", 1, y, (dim ? &gray : &white), &black, 0);
4608: if (rogue.playbackOmniscience || !player.status[STATUS_HALLUCINATING]) {
4609: itemName(theItem, name, true, true, (dim ? &gray : &white));
4610: } else {
4611: describeHallucinatedItem(name);
4612: }
4613: upperCase(name);
4614: lineCount = wrapText(NULL, name, 20-3);
4615: for (i=initialY + 1; i <= initialY + lineCount + 1 && i < ROWS - 1; i++) {
4616: printString(" ", 0, i, (dim ? &darkGray : &gray), &black, 0);
4617: }
4618: y = printStringWithWrapping(name, 3, y, 20-3, (dim ? &gray : &white), &black, NULL); // Advances y.
4619: }
4620:
4621: if (highlight) {
4622: for (i=0; i<20; i++) {
4623: highlightStrength = smoothHiliteGradient(i, 20-1) / 10;
4624: for (j=initialY; j <= y && j < ROWS - 1; j++) {
4625: highlightScreenCell(i, j, &white, highlightStrength);
4626: }
4627: }
4628: }
4629: y += 2;
4630:
4631: restoreRNG;
4632: return y;
4633: }
4634:
4635: // Returns the y-coordinate after the last line printed.
4636: short printTerrainInfo(short x, short y, short py, const char *description, boolean dim, boolean highlight) {
4637: enum displayGlyph displayChar;
4638: color foreColor, backColor;
4639: short initialY, i, j, highlightStrength, lineCount;
4640: boolean inPath;
4641: char name[DCOLS*2];
4642: color textColor;
4643: short oldRNG;
4644:
4645: if (py >= ROWS - 1) {
4646: return ROWS - 1;
4647: }
4648:
4649: initialY = py;
4650:
4651: oldRNG = rogue.RNG;
4652: rogue.RNG = RNG_COSMETIC;
4653: //assureCosmeticRNG;
4654:
4655: if (py < ROWS - 1) {
4656: // Unhighlight if it's highlighted as part of the path.
4657: inPath = (pmap[x][y].flags & IS_IN_PATH) ? true : false;
4658: pmap[x][y].flags &= ~IS_IN_PATH;
4659: getCellAppearance(x, y, &displayChar, &foreColor, &backColor);
4660: applyColorBounds(&foreColor, 0, 100);
4661: applyColorBounds(&backColor, 0, 100);
4662: if (inPath) {
4663: pmap[x][y].flags |= IS_IN_PATH;
4664: }
4665: if (dim) {
4666: applyColorAverage(&foreColor, &black, 50);
4667: applyColorAverage(&backColor, &black, 50);
4668: }
4669: plotCharWithColor(displayChar, 0, py, &foreColor, &backColor);
4670: printString(": ", 1, py, (dim ? &gray : &white), &black, 0);
4671: strcpy(name, description);
4672: upperCase(name);
4673: lineCount = wrapText(NULL, name, 20-3);
4674: for (i=initialY + 1; i <= initialY + lineCount + 1 && i < ROWS - 1; i++) {
4675: printString(" ", 0, i, (dim ? &darkGray : &gray), &black, 0);
4676: }
4677: textColor = flavorTextColor;
4678: if (dim) {
4679: applyColorScalar(&textColor, 50);
4680: }
4681: py = printStringWithWrapping(name, 3, py, 20-3, &textColor, &black, NULL); // Advances y.
4682: }
4683:
4684: if (highlight) {
4685: for (i=0; i<20; i++) {
4686: highlightStrength = smoothHiliteGradient(i, 20-1) / 10;
4687: for (j=initialY; j <= py && j < ROWS - 1; j++) {
4688: highlightScreenCell(i, j, &white, highlightStrength);
4689: }
4690: }
4691: }
4692: py += 2;
4693:
4694: restoreRNG;
4695: return py;
4696: }
4697:
4698: void rectangularShading(short x, short y, short width, short height,
4699: const color *backColor, short opacity, cellDisplayBuffer dbuf[COLS][ROWS]) {
4700: short i, j, dist;
4701:
4702: assureCosmeticRNG;
4703: for (i=0; i<COLS; i++) {
4704: for (j=0; j<ROWS; j++) {
4705: storeColorComponents(dbuf[i][j].backColorComponents, backColor);
4706:
4707: if (i >= x && i < x + width
4708: && j >= y && j < y + height) {
4709: dbuf[i][j].opacity = min(100, opacity);
4710: } else {
4711: dist = 0;
4712: dist += max(0, max(x - i, i - x - width + 1));
4713: dist += max(0, max(y - j, j - y - height + 1));
4714: dbuf[i][j].opacity = (int) ((opacity - 10) / max(1, dist));
4715: if (dbuf[i][j].opacity < 3) {
4716: dbuf[i][j].opacity = 0;
4717: }
4718: }
4719: }
4720: }
4721:
4722: // for (i=0; i<COLS; i++) {
4723: // for (j=0; j<ROWS; j++) {
4724: // if (i >= x && i < x + width && j >= y && j < y + height) {
4725: // plotCharWithColor(' ', i, j, &white, &darkGreen);
4726: // }
4727: // }
4728: // }
4729: // displayMoreSign();
4730:
4731: restoreRNG;
4732: }
4733:
4734: #define MIN_DEFAULT_INFO_PANEL_WIDTH 33
4735:
4736: // y and width are optional and will be automatically calculated if width <= 0.
4737: // Width will automatically be widened if the text would otherwise fall off the bottom of the
4738: // screen, and x will be adjusted to keep the widening box from spilling off the right of the
4739: // screen.
4740: // If buttons are provided, we'll extend the text box downward, re-position the buttons,
4741: // run a button input loop and return the result.
4742: // (Returns -1 for canceled; otherwise the button index number.)
4743: short printTextBox(char *textBuf, short x, short y, short width,
4744: color *foreColor, color *backColor,
4745: cellDisplayBuffer rbuf[COLS][ROWS],
4746: brogueButton *buttons, short buttonCount) {
4747: cellDisplayBuffer dbuf[COLS][ROWS];
4748:
4749: short x2, y2, lineCount, i, bx, by, padLines;
4750:
4751: if (width <= 0) {
4752: // autocalculate y and width
4753: if (x < DCOLS / 2 - 1) {
4754: x2 = mapToWindowX(x + 10);
4755: width = (DCOLS - x) - 20;
4756: } else {
4757: x2 = mapToWindowX(10);
4758: width = x - 20;
4759: }
4760: y2 = mapToWindowY(2);
4761:
4762: if (width < MIN_DEFAULT_INFO_PANEL_WIDTH) {
4763: x2 -= (MIN_DEFAULT_INFO_PANEL_WIDTH - width) / 2;
4764: width = MIN_DEFAULT_INFO_PANEL_WIDTH;
4765: }
4766: } else {
4767: y2 = y;
4768: x2 = x;
4769: }
4770:
4771: while (((lineCount = wrapText(NULL, textBuf, width)) + y2) >= ROWS - 2 && width < COLS-5) {
4772: // While the text doesn't fit and the width doesn't fill the screen, increase the width.
4773: width++;
4774: if (x2 + (width / 2) > COLS / 2) {
4775: // If the horizontal midpoint of the text box is on the right half of the screen,
4776: // move the box one space to the left.
4777: x2--;
4778: }
4779: }
4780:
4781: if (buttonCount > 0) {
4782: padLines = 2;
4783: bx = x2 + width;
4784: by = y2 + lineCount + 1;
4785: for (i=0; i<buttonCount; i++) {
4786: if (buttons[i].flags & B_DRAW) {
4787: bx -= strLenWithoutEscapes(buttons[i].text) + 2;
4788: buttons[i].x = bx;
4789: buttons[i].y = by;
4790: if (bx < x2) {
4791: // Buttons can wrap to the next line (though are double-spaced).
4792: bx = x2 + width - (strLenWithoutEscapes(buttons[i].text) + 2);
4793: by += 2;
4794: padLines += 2;
4795: buttons[i].x = bx;
4796: buttons[i].y = by;
4797: }
4798: }
4799: }
4800: } else {
4801: padLines = 0;
4802: }
4803:
4804: clearDisplayBuffer(dbuf);
4805: printStringWithWrapping(textBuf, x2, y2, width, foreColor, backColor, dbuf);
4806: rectangularShading(x2, y2, width, lineCount + padLines, backColor, INTERFACE_OPACITY, dbuf);
4807: overlayDisplayBuffer(dbuf, rbuf);
4808:
4809: if (buttonCount > 0) {
4810: return buttonInputLoop(buttons, buttonCount, x2, y2, width, by - y2 + 1 + padLines, NULL);
4811: } else {
4812: return -1;
4813: }
4814: }
4815:
4816: void printMonsterDetails(creature *monst, cellDisplayBuffer rbuf[COLS][ROWS]) {
4817: char textBuf[COLS * 100];
4818:
4819: monsterDetails(textBuf, monst);
4820: printTextBox(textBuf, monst->xLoc, 0, 0, &white, &black, rbuf, NULL, 0);
4821: }
4822:
4823: // Displays the item info box with the dark blue background.
4824: // If includeButtons is true, we include buttons for item actions.
4825: // Returns the key of an action to take, if any; otherwise -1.
4826: unsigned long printCarriedItemDetails(item *theItem,
4827: short x, short y, short width,
4828: boolean includeButtons,
4829: cellDisplayBuffer rbuf[COLS][ROWS]) {
4830: char textBuf[COLS * 100], goldColorEscape[5] = "", whiteColorEscape[5] = "";
4831: brogueButton buttons[20] = {{{0}}};
4832: short b;
4833:
4834: itemDetails(textBuf, theItem);
4835:
4836: for (b=0; b<20; b++) {
4837: initializeButton(&(buttons[b]));
4838: buttons[b].flags |= B_WIDE_CLICK_AREA;
4839: }
4840:
4841: b = 0;
4842: if (includeButtons) {
4843: encodeMessageColor(goldColorEscape, 0, KEYBOARD_LABELS ? &yellow : &white);
4844: encodeMessageColor(whiteColorEscape, 0, &white);
4845:
4846: if (theItem->category & (FOOD | SCROLL | POTION | WAND | STAFF | CHARM)) {
4847: sprintf(buttons[b].text, " %sa%spply ", goldColorEscape, whiteColorEscape);
4848: buttons[b].hotkey[0] = APPLY_KEY;
4849: b++;
4850: }
4851: if (theItem->category & (ARMOR | WEAPON | RING)) {
4852: if (theItem->flags & ITEM_EQUIPPED) {
4853: sprintf(buttons[b].text, " %sr%semove ", goldColorEscape, whiteColorEscape);
4854: buttons[b].hotkey[0] = UNEQUIP_KEY;
4855: b++;
4856: } else {
4857: sprintf(buttons[b].text, " %se%squip ", goldColorEscape, whiteColorEscape);
4858: buttons[b].hotkey[0] = EQUIP_KEY;
4859: b++;
4860: }
4861: }
4862: sprintf(buttons[b].text, " %sd%srop ", goldColorEscape, whiteColorEscape);
4863: buttons[b].hotkey[0] = DROP_KEY;
4864: b++;
4865:
4866: sprintf(buttons[b].text, " %st%shrow ", goldColorEscape, whiteColorEscape);
4867: buttons[b].hotkey[0] = THROW_KEY;
4868: b++;
4869:
4870: if (itemCanBeCalled(theItem)) {
4871: sprintf(buttons[b].text, " %sc%sall ", goldColorEscape, whiteColorEscape);
4872: buttons[b].hotkey[0] = CALL_KEY;
4873: b++;
4874: }
4875:
4876: if (KEYBOARD_LABELS) {
4877: sprintf(buttons[b].text, " %sR%selabel ", goldColorEscape, whiteColorEscape);
4878: buttons[b].hotkey[0] = RELABEL_KEY;
4879: b++;
4880: }
4881:
4882: // Add invisible previous and next buttons, so up and down arrows can page through items.
4883: // Previous
4884: buttons[b].flags = B_ENABLED; // clear everything else
4885: buttons[b].hotkey[0] = UP_KEY;
4886: buttons[b].hotkey[1] = NUMPAD_8;
4887: buttons[b].hotkey[2] = UP_ARROW;
4888: b++;
4889: // Next
4890: buttons[b].flags = B_ENABLED; // clear everything else
4891: buttons[b].hotkey[0] = DOWN_KEY;
4892: buttons[b].hotkey[1] = NUMPAD_2;
4893: buttons[b].hotkey[2] = DOWN_ARROW;
4894: b++;
4895: }
4896: b = printTextBox(textBuf, x, y, width, &white, &interfaceBoxColor, rbuf, buttons, b);
4897:
4898: if (!includeButtons) {
4899: waitForKeystrokeOrMouseClick();
4900: return -1;
4901: }
4902:
4903: if (b >= 0) {
4904: return buttons[b].hotkey[0];
4905: } else {
4906: return -1;
4907: }
4908: }
4909:
4910: // Returns true if an action was taken.
4911: void printFloorItemDetails(item *theItem, cellDisplayBuffer rbuf[COLS][ROWS]) {
4912: char textBuf[COLS * 100];
4913:
4914: itemDetails(textBuf, theItem);
4915: printTextBox(textBuf, theItem->xLoc, 0, 0, &white, &black, rbuf, NULL, 0);
4916: }
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IO.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / brogue-ce / src / brogue