Annotation of brogue-ce/src/brogue/Recordings.c, Revision 1.1.1.1
1.1 rubenllo 1: /*
2: * Recordings.c
3: * Brogue
4: *
5: * Created by Brian Walker on 8/8/10.
6: * Copyright 2012. All rights reserved.
7: *
8: * This program is free software: you can redistribute it and/or modify
9: * it under the terms of the GNU Affero General Public License as
10: * published by the Free Software Foundation, either version 3 of the
11: * License, or (at your option) any later version.
12: *
13: * This program is distributed in the hope that it will be useful,
14: * but WITHOUT ANY WARRANTY; without even the implied warranty of
15: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16: * GNU Affero General Public License for more details.
17: *
18: * You should have received a copy of the GNU Affero General Public License
19: * along with this program. If not, see <http://www.gnu.org/licenses/>.
20: *
21: */
22:
23: #include <time.h>
24: #include <math.h>
25: #include <limits.h>
26: #include "Rogue.h"
27: #include "IncludeGlobals.h"
28:
29: #define RECORDING_HEADER_LENGTH 32 // bytes at the start of the recording file to store global data
30:
31: static const long keystrokeTable[] = {UP_ARROW, LEFT_ARROW, DOWN_ARROW, RIGHT_ARROW,
32: ESCAPE_KEY, RETURN_KEY, DELETE_KEY, TAB_KEY, NUMPAD_0, NUMPAD_1,
33: NUMPAD_2, NUMPAD_3, NUMPAD_4, NUMPAD_5, NUMPAD_6, NUMPAD_7, NUMPAD_8, NUMPAD_9};
34:
35: static const int keystrokeCount = sizeof(keystrokeTable) / sizeof(*keystrokeTable);
36:
37: enum recordingSeekModes {
38: RECORDING_SEEK_MODE_TURN,
39: RECORDING_SEEK_MODE_DEPTH
40: };
41:
42: void recordChar(unsigned char c) {
43: inputRecordBuffer[locationInRecordingBuffer++] = c;
44: recordingLocation++;
45: }
46:
47: void considerFlushingBufferToFile() {
48: if (locationInRecordingBuffer >= INPUT_RECORD_BUFFER) {
49: flushBufferToFile();
50: }
51: }
52:
53: // compresses a int into a char, discarding stuff we don't need
54: unsigned char compressKeystroke(long c) {
55: short i;
56:
57: for (i = 0; i < keystrokeCount; i++) {
58: if (keystrokeTable[i] == c) {
59: return (unsigned char) (128 + i);
60: }
61: }
62: if (c < 256) {
63: return (unsigned char) c;
64: }
65: return UNKNOWN_KEY;
66: }
67:
68: void numberToString(unsigned long number, short numberOfBytes, unsigned char *recordTo) {
69: short i;
70: unsigned long n;
71:
72: n = number;
73: for (i=numberOfBytes - 1; i >= 0; i--) {
74: recordTo[i] = n % 256;
75: n /= 256;
76: }
77: if (n > 0) {
78: printf("\nError: the number %li does not fit in %i bytes.", number, numberOfBytes);
79: brogueAssert(false);
80: }
81: }
82:
83: // numberOfBytes can't be greater than 10
84: void recordNumber(unsigned long number, short numberOfBytes) {
85: short i;
86: unsigned char c[10];
87:
88: numberToString(number, numberOfBytes, c);
89: for (i=0; i<numberOfBytes; i++) {
90: recordChar(c[i]);
91: }
92: }
93:
94: // Events are recorded as follows:
95: // Keystrokes: Event type, keystroke value, modifier flags. (3 bytes.)
96: // All other events: Event type, x-coordinate of the event, y-coordinate of the event, modifier flags. (4 bytes.)
97: // Note: these must be sanitized, because user input may contain more than one byte per parameter.
98: void recordEvent(rogueEvent *event) {
99: unsigned char c;
100:
101: if (rogue.playbackMode) {
102: return;
103: }
104:
105: recordChar((unsigned char) event->eventType);
106:
107: if (event->eventType == KEYSTROKE) {
108: // record which key
109: c = compressKeystroke(event->param1);
110: if (c == UNKNOWN_KEY) {
111: return;
112: }
113: recordChar(c);
114: } else {
115: recordChar((unsigned char) event->param1);
116: recordChar((unsigned char) event->param2);
117: }
118:
119: // record the modifier keys
120: c = 0;
121: if (event->controlKey) {
122: c += Fl(1);
123: }
124: if (event->shiftKey) {
125: c += Fl(2);
126: }
127: recordChar(c);
128: }
129:
130: // For convenience.
131: void recordKeystroke(int keystroke, boolean controlKey, boolean shiftKey) {
132: rogueEvent theEvent;
133:
134: if (rogue.playbackMode) {
135: return;
136: }
137:
138: theEvent.eventType = KEYSTROKE;
139: theEvent.param1 = keystroke;
140: theEvent.controlKey = controlKey;
141: theEvent.shiftKey = shiftKey;
142: recordEvent(&theEvent);
143: }
144:
145: // record a series of keystrokes; string must end with a null terminator
146: void recordKeystrokeSequence(unsigned char *keystrokeSequence) {
147: short i;
148: for (i=0; keystrokeSequence[i] != '\0'; i++) {
149: recordKeystroke(keystrokeSequence[i], false, false);
150: }
151: }
152:
153: // For convenience.
154: void recordMouseClick(short x, short y, boolean controlKey, boolean shiftKey) {
155: rogueEvent theEvent;
156:
157: if (rogue.playbackMode) {
158: return;
159: }
160:
161: theEvent.eventType = MOUSE_UP;
162: theEvent.param1 = x;
163: theEvent.param2 = y;
164: theEvent.controlKey = controlKey;
165: theEvent.shiftKey = shiftKey;
166: recordEvent(&theEvent);
167: }
168:
169: void writeHeaderInfo(char *path) {
170: unsigned char c[RECORDING_HEADER_LENGTH];
171: short i;
172: FILE *recordFile;
173:
174: // Zero out the entire header to start.
175: for (i=0; i<RECORDING_HEADER_LENGTH; i++) {
176: c[i] = 0;
177: }
178:
179: // Note the version string to gracefully deny compatibility when necessary.
180: for (i = 0; rogue.versionString[i] != '\0'; i++) {
181: c[i] = rogue.versionString[i];
182: }
183: c[15] = rogue.wizard;
184: i = 16;
185: numberToString(rogue.seed, 4, &c[i]);
186: i += 4;
187: numberToString(rogue.playerTurnNumber, 4, &c[i]);
188: i += 4;
189: numberToString(rogue.deepestLevel, 4, &c[i]);
190: i += 4;
191: numberToString(lengthOfPlaybackFile, 4, &c[i]);
192: i += 4;
193:
194: if (!fileExists(path)) {
195: recordFile = fopen(path, "wb");
196: if (recordFile) {
197: fclose(recordFile);
198: }
199: }
200:
201: recordFile = fopen(path, "r+b");
202: rewind(recordFile);
203: for (i=0; i<RECORDING_HEADER_LENGTH; i++) {
204: putc(c[i], recordFile);
205: }
206: if (recordFile) {
207: fclose(recordFile);
208: }
209:
210: if (lengthOfPlaybackFile < RECORDING_HEADER_LENGTH) {
211: lengthOfPlaybackFile = RECORDING_HEADER_LENGTH;
212: }
213: }
214:
215: void flushBufferToFile() {
216: short i;
217: FILE *recordFile;
218:
219: if (rogue.playbackMode) {
220: return;
221: }
222:
223: lengthOfPlaybackFile += locationInRecordingBuffer;
224: writeHeaderInfo(currentFilePath);
225:
226: if (locationInRecordingBuffer != 0) {
227:
228: recordFile = fopen(currentFilePath, "ab");
229:
230: for (i=0; i<locationInRecordingBuffer; i++) {
231: putc(inputRecordBuffer[i], recordFile);
232: }
233:
234: if (recordFile) {
235: fclose(recordFile);
236: }
237:
238: locationInRecordingBuffer = 0;
239: }
240: }
241:
242: void fillBufferFromFile() {
243: // short i;
244: FILE *recordFile;
245:
246: recordFile = fopen(currentFilePath, "rb");
247: fseek(recordFile, positionInPlaybackFile, SEEK_SET);
248:
249: fread((void *) inputRecordBuffer, 1, INPUT_RECORD_BUFFER, recordFile);
250:
251: positionInPlaybackFile = ftell(recordFile);
252: fclose(recordFile);
253:
254: locationInRecordingBuffer = 0;
255: }
256:
257: unsigned char recallChar() {
258: unsigned char c;
259: if (recordingLocation > lengthOfPlaybackFile) {
260: return END_OF_RECORDING;
261: }
262: c = inputRecordBuffer[locationInRecordingBuffer++];
263: recordingLocation++;
264: if (locationInRecordingBuffer >= INPUT_RECORD_BUFFER) {
265: fillBufferFromFile();
266: }
267: return c;
268: }
269:
270: long uncompressKeystroke(unsigned char c) {
271: if (c >= 128 && (c - 128) < keystrokeCount) {
272: return keystrokeTable[c - 128];
273: }
274: return (long)c;
275: }
276:
277: unsigned long recallNumber(short numberOfBytes) {
278: short i;
279: unsigned long n;
280:
281: n = 0;
282:
283: for (i=0; i<numberOfBytes; i++) {
284: n *= 256;
285: n += (unsigned long) recallChar();
286: }
287: return n;
288: }
289:
290: #define OOS_APOLOGY "Playback of the recording has diverged from the originally recorded game.\n\n\
291: This could be caused by recording or playing the file on a modified version of Brogue, or it could \
292: simply be the result of a bug. (The recording feature is still in beta for this reason.)\n\n\
293: If this is a different computer from the one on which the recording was saved, the recording \
294: might succeed on the original computer."
295:
296: void playbackPanic() {
297: cellDisplayBuffer rbuf[COLS][ROWS];
298:
299: if (!rogue.playbackOOS) {
300: rogue.playbackFastForward = false;
301: rogue.playbackPaused = true;
302: rogue.playbackOOS = true;
303: rogue.creaturesWillFlashThisTurn = false;
304: blackOutScreen();
305: displayLevel();
306: refreshSideBar(-1, -1, false);
307:
308: confirmMessages();
309: message("Playback is out of sync.", false);
310:
311: printTextBox(OOS_APOLOGY, 0, 0, 0, &white, &black, rbuf, NULL, 0);
312:
313: rogue.playbackMode = false;
314: displayMoreSign();
315: rogue.playbackMode = true;
316:
317: overlayDisplayBuffer(rbuf, 0);
318:
319: printf("Playback panic at location %li! Turn number %li.\n", recordingLocation - 1, rogue.playerTurnNumber);
320: overlayDisplayBuffer(rbuf, 0);
321:
322: mainInputLoop();
323: }
324: }
325:
326: void recallEvent(rogueEvent *event) {
327: unsigned char c;
328: boolean tryAgain;
329:
330: do {
331: tryAgain = false;
332: c = recallChar();
333: event->eventType = c;
334:
335: switch (c) {
336: case KEYSTROKE:
337: // record which key
338: event->param1 = uncompressKeystroke(recallChar());
339: event->param2 = 0;
340: break;
341: case SAVED_GAME_LOADED:
342: tryAgain = true;
343: flashTemporaryAlert(" Saved game loaded ", 1000);
344: break;
345: case MOUSE_UP:
346: case MOUSE_DOWN:
347: case MOUSE_ENTERED_CELL:
348: case RIGHT_MOUSE_UP:
349: case RIGHT_MOUSE_DOWN:
350: event->param1 = recallChar();
351: event->param2 = recallChar();
352: break;
353: case RNG_CHECK:
354: case END_OF_RECORDING:
355: case EVENT_ERROR:
356: default:
357: message("Unrecognized event type in playback.", true);
358: printf("Unrecognized event type in playback: event ID %i", c);
359: tryAgain = true;
360: playbackPanic();
361: break;
362: }
363: } while (tryAgain && !rogue.gameHasEnded);
364:
365: // record the modifier keys
366: c = recallChar();
367: event->controlKey = (c & Fl(1)) ? true : false;
368: event->shiftKey = (c & Fl(2)) ? true : false;
369: }
370:
371: void loadNextAnnotation() {
372: unsigned long currentReadTurn;
373: short i;
374: FILE *annotationFile;
375:
376: if (rogue.nextAnnotationTurn == -1) {
377: return;
378: }
379:
380: annotationFile = fopen(annotationPathname, "r");
381: fseek(annotationFile, rogue.locationInAnnotationFile, SEEK_SET);
382:
383: for (;;) {
384:
385: // load turn number
386: if (fscanf(annotationFile, "%lu\t", &(currentReadTurn)) != 1) {
387: if (feof(annotationFile)) {
388: rogue.nextAnnotation[0] = '\0';
389: rogue.nextAnnotationTurn = -1;
390: break;
391: } else {
392: // advance to the end of the line
393: fgets(rogue.nextAnnotation, 5000, annotationFile);
394: continue;
395: }
396: }
397:
398: // load description
399: fgets(rogue.nextAnnotation, 5000, annotationFile);
400:
401: if (currentReadTurn > rogue.playerTurnNumber ||
402: (currentReadTurn <= 1 && rogue.playerTurnNumber <= 1 && currentReadTurn >= rogue.playerTurnNumber)) {
403: rogue.nextAnnotationTurn = currentReadTurn;
404:
405: // strip the newline off the end
406: rogue.nextAnnotation[strlen(rogue.nextAnnotation) - 1] = '\0';
407: // strip out any gremlins in the annotation
408: for (i=0; i<5000 && rogue.nextAnnotation[i]; i++) {
409: if (rogue.nextAnnotation[i] < ' '
410: || rogue.nextAnnotation[i] > '~') {
411: rogue.nextAnnotation[i] = ' ';
412: }
413: }
414: break;
415: }
416: }
417: rogue.locationInAnnotationFile = ftell(annotationFile);
418: fclose(annotationFile);
419: }
420:
421: void displayAnnotation() {
422: cellDisplayBuffer rbuf[COLS][ROWS];
423:
424: if (rogue.playbackMode
425: && rogue.playerTurnNumber == rogue.nextAnnotationTurn) {
426:
427: if (!rogue.playbackFastForward) {
428: refreshSideBar(-1, -1, false);
429:
430: printTextBox(rogue.nextAnnotation, player.xLoc, 0, 0, &black, &white, rbuf, NULL, 0);
431:
432: rogue.playbackMode = false;
433: displayMoreSign();
434: rogue.playbackMode = true;
435:
436: overlayDisplayBuffer(rbuf, 0);
437: }
438:
439: loadNextAnnotation();
440: }
441: }
442:
443: // Attempts to extract the patch version of versionString into patchVersion,
444: // according to the global pattern. Returns 0 if successful.
445: static boolean getPatchVersion(char *versionString, unsigned short *patchVersion) {
446: int n = sscanf(versionString, BROGUE_PATCH_VERSION_PATTERN, patchVersion);
447: return n == 1;
448: }
449:
450: // creates a game recording file, or if in playback mode,
451: // initializes based on and starts reading from the recording file
452: void initRecording() {
453: short i;
454: boolean wizardMode;
455: unsigned short gamePatch, recPatch;
456: char buf[100], *versionString = rogue.versionString;
457: FILE *recordFile;
458:
459: #ifdef AUDIT_RNG
460: if (fileExists(RNG_LOG)) {
461: remove(RNG_LOG);
462: }
463: RNGLogFile = fopen(RNG_LOG, "a");
464: #endif
465:
466: locationInRecordingBuffer = 0;
467: positionInPlaybackFile = 0;
468: recordingLocation = 0;
469: maxLevelChanges = 0;
470: rogue.playbackOOS = false;
471: rogue.playbackOmniscience = false;
472: rogue.nextAnnotationTurn = 0;
473: rogue.nextAnnotation[0] = '\0';
474: rogue.locationInAnnotationFile = 0;
475: rogue.patchVersion = 0;
476:
477: if (rogue.playbackMode) {
478: lengthOfPlaybackFile = 100000; // so recall functions don't freak out
479: rogue.playbackDelayPerTurn = DEFAULT_PLAYBACK_DELAY;
480: rogue.playbackDelayThisTurn = rogue.playbackDelayPerTurn;
481: rogue.playbackPaused = false;
482:
483: fillBufferFromFile();
484:
485: for (i=0; i<15; i++) {
486: versionString[i] = recallChar();
487: }
488: wizardMode = recallChar();
489:
490: if (getPatchVersion(versionString, &recPatch)
491: && getPatchVersion(BROGUE_RECORDING_VERSION_STRING, &gamePatch)
492: && recPatch <= gamePatch) {
493: rogue.patchVersion = recPatch;
494: } else if (strcmp(versionString, "CE 1.9") == 0) {
495: // Temporary measure until next release, as "CE 1.9" recording string
496: // doesn't have a patch version (".0"), but we can load it.
497: rogue.patchVersion = 0;
498: } else if (strcmp(versionString, BROGUE_RECORDING_VERSION_STRING) != 0) {
499: // If we have neither a patch pattern match nor an exact match, we can't load.
500: rogue.playbackMode = false;
501: rogue.playbackFastForward = false;
502: sprintf(buf, "This file is from version %s and cannot be opened in version %s.", versionString, BROGUE_VERSION_STRING);
503: dialogAlert(buf);
504: rogue.playbackMode = true;
505: rogue.playbackPaused = true;
506: rogue.playbackFastForward = false;
507: rogue.playbackOOS = false;
508: rogue.gameHasEnded = true;
509: }
510:
511: if (wizardMode != rogue.wizard && rogue.patchVersion > 1) { // (don't perform the check for version 1.9.1 or earlier)
512: // wizard game cannot be played in normal mode and vice versa
513: rogue.playbackMode = false;
514: rogue.playbackFastForward = false;
515: if (wizardMode) {
516: sprintf(buf, "This game was played in wizard mode. You must start Brogue in wizard mode to replay it.");
517: } else {
518: sprintf(buf, "To play this regular recording, please restart Brogue without the wizard mode option.");
519: }
520: dialogAlert(buf);
521: rogue.playbackMode = true;
522: rogue.playbackPaused = true;
523: rogue.playbackFastForward = false;
524: rogue.playbackOOS = false;
525: rogue.gameHasEnded = true;
526: }
527:
528: rogue.seed = recallNumber(4); // master random seed
529: rogue.howManyTurns = recallNumber(4); // how many turns are in this recording
530: maxLevelChanges = recallNumber(4); // how many times the player changes depths
531: lengthOfPlaybackFile = recallNumber(4);
532: seedRandomGenerator(rogue.seed);
533: previousGameSeed = rogue.seed;
534:
535: if (fileExists(annotationPathname)) {
536: loadNextAnnotation();
537: } else {
538: rogue.nextAnnotationTurn = -1;
539: }
540: } else {
541: // If present, set the patch version for playing the game.
542: getPatchVersion(BROGUE_RECORDING_VERSION_STRING, &rogue.patchVersion);
543: strcpy(versionString, BROGUE_RECORDING_VERSION_STRING);
544:
545: lengthOfPlaybackFile = 1;
546: remove(currentFilePath);
547: recordFile = fopen(currentFilePath, "wb"); // create the file
548: fclose(recordFile);
549:
550: flushBufferToFile(); // header info never makes it into inputRecordBuffer when recording
551: rogue.recording = true;
552: }
553: rogue.currentTurnNumber = 0;
554: }
555:
556: void OOSCheck(unsigned long x, short numberOfBytes) {
557: unsigned char eventType;
558: unsigned long recordedNumber;
559:
560: if (rogue.playbackMode) {
561: eventType = recallChar();
562: recordedNumber = recallNumber(numberOfBytes);
563: if (eventType != RNG_CHECK || recordedNumber != x) {
564: if (eventType != RNG_CHECK) {
565: printf("Event type mismatch in RNG check.\n");
566: playbackPanic();
567: } else if (recordedNumber != x) {
568: printf("Expected RNG output of %li; got %i.\n", recordedNumber, (int) x);
569: playbackPanic();
570: }
571: }
572: } else {
573: recordChar(RNG_CHECK);
574: recordNumber(x, numberOfBytes);
575: considerFlushingBufferToFile();
576: }
577: }
578:
579: // compare a random number once per player turn so we instantly know if we are out of sync during playback
580: void RNGCheck() {
581: short oldRNG;
582: unsigned long randomNumber;
583:
584: oldRNG = rogue.RNG;
585: rogue.RNG = RNG_SUBSTANTIVE;
586:
587: //#ifdef AUDIT_RNG
588: //reportRNGState();
589: //#endif
590:
591: randomNumber = (unsigned long) rand_range(0, 255);
592: OOSCheck(randomNumber, 1);
593:
594: rogue.RNG = oldRNG;
595: }
596:
597: boolean unpause() {
598: if (rogue.playbackOOS) {
599: flashTemporaryAlert(" Out of sync ", 2000);
600: } else if (rogue.playbackPaused) {
601: rogue.playbackPaused = false;
602: return true;
603: }
604: return false;
605: }
606:
607: #define PLAYBACK_HELP_LINE_COUNT 20
608:
609: void printPlaybackHelpScreen() {
610: short i, j;
611: cellDisplayBuffer dbuf[COLS][ROWS], rbuf[COLS][ROWS];
612: char helpText[PLAYBACK_HELP_LINE_COUNT][80] = {
613: "Commands:",
614: "",
615: " <space>: ****pause or unpause playback",
616: " k or up arrow: ****play back faster",
617: " j or down arrow: ****play back slower",
618: " <: ****go to previous level",
619: " >: ****go to next level",
620: " 0-9: ****skip to specified turn number",
621: "l or right arrow: ****advance one turn (shift for 5 turns; control for 20)",
622: "",
623: " <tab>: ****enable or disable omniscience",
624: " return: ****examine surroundings",
625: " i: ****display inventory",
626: " D: ****display discovered items",
627: " V: ****view saved recording",
628: " O: ****open and resume saved game",
629: " N: ****begin a new game",
630: " Q: ****quit to title screen",
631: "",
632: " -- press any key to continue --"
633: };
634:
635: // Replace the "****"s with color escapes.
636: for (i=0; i<PLAYBACK_HELP_LINE_COUNT; i++) {
637: for (j=0; helpText[i][j]; j++) {
638: if (helpText[i][j] == '*') {
639: j = encodeMessageColor(helpText[i], j, &white);
640: }
641: }
642: }
643:
644: clearDisplayBuffer(dbuf);
645:
646: for (i=0; i<PLAYBACK_HELP_LINE_COUNT; i++) {
647: printString(helpText[i], mapToWindowX(5), mapToWindowY(i), &itemMessageColor, &black, dbuf);
648: }
649:
650: for (i=0; i<COLS; i++) {
651: for (j=0; j<ROWS; j++) {
652: dbuf[i][j].opacity = (i < STAT_BAR_WIDTH ? 0 : INTERFACE_OPACITY);
653: }
654: }
655: overlayDisplayBuffer(dbuf, rbuf);
656:
657: rogue.playbackMode = false;
658: waitForAcknowledgment();
659: rogue.playbackMode = true;
660: overlayDisplayBuffer(rbuf, NULL);
661: }
662:
663: static void resetPlayback() {
664: boolean omniscient, stealth, trueColors;
665:
666: omniscient = rogue.playbackOmniscience;
667: stealth = rogue.displayAggroRangeMode;
668: trueColors = rogue.trueColorMode;
669:
670: freeEverything();
671: randomNumbersGenerated = 0;
672: rogue.playbackMode = true;
673: initializeRogue(0); // Seed argument is ignored because we're in playback.
674:
675: rogue.playbackOmniscience = omniscient;
676: rogue.displayAggroRangeMode = stealth;
677: rogue.trueColorMode = trueColors;
678:
679: rogue.playbackFastForward = false;
680: blackOutScreen();
681: rogue.playbackFastForward = true;
682: startLevel(rogue.depthLevel, 1);
683: }
684:
685: static void seek(unsigned long seekTarget, enum recordingSeekModes seekMode) {
686: unsigned long progressBarRefreshInterval = 1, startTurnNumber = 0, targetTurnNumber = 0, avgTurnsPerLevel = 1;
687: rogueEvent theEvent;
688: boolean pauseState, useProgressBar = false, arrivedAtDestination = false;
689: cellDisplayBuffer dbuf[COLS][ROWS];
690:
691: pauseState = rogue.playbackPaused;
692:
693: // configure progress bar
694: switch (seekMode) {
695: case RECORDING_SEEK_MODE_DEPTH :
696: if (maxLevelChanges > 0) {
697: avgTurnsPerLevel = rogue.howManyTurns / maxLevelChanges;
698: }
699: if (seekTarget <= rogue.depthLevel) {
700: startTurnNumber = 0;
701: targetTurnNumber = avgTurnsPerLevel * seekTarget;
702: } else {
703: startTurnNumber = rogue.playerTurnNumber;
704: targetTurnNumber = rogue.playerTurnNumber + avgTurnsPerLevel;
705: }
706: break;
707: case RECORDING_SEEK_MODE_TURN :
708: if (seekTarget < rogue.playerTurnNumber) {
709: startTurnNumber = 0;
710: targetTurnNumber = seekTarget;
711: } else {
712: startTurnNumber = rogue.playerTurnNumber;
713: targetTurnNumber = seekTarget;
714: }
715: break;
716: }
717:
718: if (targetTurnNumber - startTurnNumber > 100) {
719: useProgressBar = true;
720: progressBarRefreshInterval = max(1, (targetTurnNumber) / 500);
721: }
722:
723: // there is no rewind, so start over at depth 1
724: if ((seekMode == RECORDING_SEEK_MODE_TURN && seekTarget < rogue.playerTurnNumber)
725: || (seekMode == RECORDING_SEEK_MODE_DEPTH && seekTarget <= rogue.depthLevel)) {
726:
727: resetPlayback();
728: if ((seekMode == RECORDING_SEEK_MODE_DEPTH && seekTarget == 1)
729: || (seekMode == RECORDING_SEEK_MODE_TURN && seekTarget == 0)) {
730: arrivedAtDestination = true;
731: }
732: }
733:
734: if (useProgressBar) {
735: clearDisplayBuffer(dbuf);
736: rectangularShading((COLS - 20) / 2, ROWS / 2, 20, 1, &black, INTERFACE_OPACITY, dbuf);
737: overlayDisplayBuffer(dbuf, 0);
738: commitDraws();
739: }
740: rogue.playbackFastForward = true;
741:
742: while (!arrivedAtDestination && !rogue.gameHasEnded && !rogue.playbackOOS) {
743: if (useProgressBar && !(rogue.playerTurnNumber % progressBarRefreshInterval)) {
744: rogue.playbackFastForward = false; // so that pauseBrogue looks for inputs
745: printProgressBar((COLS - 20) / 2, ROWS / 2, "[ Loading... ]",
746: rogue.playerTurnNumber - startTurnNumber,
747: targetTurnNumber - startTurnNumber, &darkPurple, false);
748: while (pauseBrogue(0)) { // pauseBrogue(0) is necessary to flush the display to the window in SDL
749: if (rogue.gameHasEnded) {
750: return;
751: }
752: rogue.creaturesWillFlashThisTurn = false; // prevent monster flashes from showing up on screen
753: nextBrogueEvent(&theEvent, true, false, true); // eat the input if it isn't clicking x
754: }
755: rogue.playbackFastForward = true;
756: }
757:
758: rogue.RNG = RNG_COSMETIC; // dancing terrain colors can't influence recordings
759: rogue.playbackDelayThisTurn = 0;
760: nextBrogueEvent(&theEvent, false, true, false);
761: rogue.RNG = RNG_SUBSTANTIVE;
762: executeEvent(&theEvent);
763:
764: if ((seekMode == RECORDING_SEEK_MODE_DEPTH && rogue.depthLevel == seekTarget)
765: || (seekMode == RECORDING_SEEK_MODE_TURN && rogue.playerTurnNumber == seekTarget)) {
766:
767: arrivedAtDestination = true;
768: }
769: }
770:
771: rogue.playbackPaused = pauseState;
772: rogue.playbackFastForward = false;
773: confirmMessages();
774: updateMessageDisplay();
775: refreshSideBar(-1, -1, false);
776: displayLevel();
777: }
778:
779: void promptToAdvanceToLocation(short keystroke) {
780: char entryText[30], buf[max(30, DCOLS)];
781: unsigned long destinationFrame;
782: boolean enteredText;
783:
784: if (rogue.playbackOOS || !rogue.playbackPaused || unpause()) {
785: buf[0] = (keystroke == '0' ? '\0' : keystroke);
786: buf[1] = '\0';
787:
788: rogue.playbackMode = false;
789: enteredText = getInputTextString(entryText, "Go to turn number: ", 9, buf, "", TEXT_INPUT_NUMBERS, false);
790: confirmMessages();
791: rogue.playbackMode = true;
792:
793: if (enteredText && entryText[0] != '\0') {
794: sscanf(entryText, "%lu", &destinationFrame);
795:
796: if (destinationFrame >= rogue.howManyTurns) {
797: flashTemporaryAlert(" Past end of recording ", 3000);
798: } else if (rogue.playbackOOS && destinationFrame > rogue.playerTurnNumber) {
799: flashTemporaryAlert(" Out of sync ", 3000);
800: } else if (destinationFrame == rogue.playerTurnNumber) {
801: sprintf(buf, " Already at turn %li ", destinationFrame);
802: flashTemporaryAlert(buf, 1000);
803: } else {
804: seek(destinationFrame, RECORDING_SEEK_MODE_TURN);
805: }
806: rogue.playbackPaused = true;
807: }
808: }
809: }
810:
811: void pausePlayback() {
812: //short oldRNG;
813: if (!rogue.playbackPaused) {
814: rogue.playbackPaused = true;
815: messageWithColor(KEYBOARD_LABELS ? "recording paused. Press space to play." : "recording paused.",
816: &teal, false);
817: refreshSideBar(-1, -1, false);
818: //oldRNG = rogue.RNG;
819: //rogue.RNG = RNG_SUBSTANTIVE;
820: mainInputLoop();
821: //rogue.RNG = oldRNG;
822: messageWithColor("recording unpaused.", &teal, false);
823: rogue.playbackPaused = false;
824: refreshSideBar(-1, -1, false);
825: rogue.playbackDelayThisTurn = DEFAULT_PLAYBACK_DELAY;
826: }
827: }
828:
829: // Used to interact with playback -- e.g. changing speed, pausing.
830: boolean executePlaybackInput(rogueEvent *recordingInput) {
831: signed long key;
832: short newDelay, frameCount, x, y;
833: unsigned long destinationFrame;
834: boolean proceed;
835: char path[BROGUE_FILENAME_MAX];
836:
837: if (!rogue.playbackMode) {
838: return false;
839: }
840:
841: if (recordingInput->eventType == KEYSTROKE) {
842: key = recordingInput->param1;
843: stripShiftFromMovementKeystroke(&key);
844:
845: switch (key) {
846: case UP_ARROW:
847: case UP_KEY:
848: newDelay = max(1, min(rogue.playbackDelayPerTurn * 2/3, rogue.playbackDelayPerTurn - 1));
849: if (newDelay != rogue.playbackDelayPerTurn) {
850: flashTemporaryAlert(" Faster ", 300);
851: }
852: rogue.playbackDelayPerTurn = newDelay;
853: rogue.playbackDelayThisTurn = rogue.playbackDelayPerTurn;
854: return true;
855: case DOWN_ARROW:
856: case DOWN_KEY:
857: newDelay = min(3000, max(rogue.playbackDelayPerTurn * 3/2, rogue.playbackDelayPerTurn + 1));
858: if (newDelay != rogue.playbackDelayPerTurn) {
859: flashTemporaryAlert(" Slower ", 300);
860: }
861: rogue.playbackDelayPerTurn = newDelay;
862: rogue.playbackDelayThisTurn = rogue.playbackDelayPerTurn;
863: return true;
864: case ACKNOWLEDGE_KEY:
865: if (rogue.playbackOOS && rogue.playbackPaused) {
866: flashTemporaryAlert(" Out of sync ", 2000);
867: } else {
868: rogue.playbackPaused = !rogue.playbackPaused;
869: }
870: return true;
871: case TAB_KEY:
872: rogue.playbackOmniscience = !rogue.playbackOmniscience;
873: displayLevel();
874: refreshSideBar(-1, -1, false);
875: if (rogue.playbackOmniscience) {
876: messageWithColor("Omniscience enabled.", &teal, false);
877: } else {
878: messageWithColor("Omniscience disabled.", &teal, false);
879: }
880: return true;
881: case ASCEND_KEY:
882: seek(max(rogue.depthLevel - 1, 1), RECORDING_SEEK_MODE_DEPTH);
883: return true;
884: case DESCEND_KEY:
885: if (rogue.depthLevel == maxLevelChanges) {
886: flashTemporaryAlert(" Already reached deepest depth explored ", 2000);
887: return false;
888: }
889: seek(rogue.depthLevel + 1, RECORDING_SEEK_MODE_DEPTH);
890: return true;
891: case INVENTORY_KEY:
892: rogue.playbackMode = false;
893: displayInventory(ALL_ITEMS, 0, 0, true, false);
894: rogue.playbackMode = true;
895: return true;
896: case RIGHT_KEY:
897: case RIGHT_ARROW:
898: case LEFT_KEY:
899: case LEFT_ARROW:
900: if (key == RIGHT_KEY || key == RIGHT_ARROW) {
901: frameCount = 1;
902: } else {
903: frameCount = -1;
904: }
905: if (recordingInput->shiftKey) {
906: frameCount *= 5;
907: }
908: if (recordingInput->controlKey) {
909: frameCount *= 20;
910: }
911:
912: if (frameCount < 0) {
913: if ((unsigned long) (frameCount * -1) > rogue.playerTurnNumber) {
914: destinationFrame = 0;
915: } else {
916: destinationFrame = rogue.playerTurnNumber + frameCount;
917: }
918: } else {
919: destinationFrame = min(rogue.playerTurnNumber + frameCount, rogue.howManyTurns - 1);
920: }
921:
922: if (destinationFrame == rogue.playerTurnNumber) {
923: flashTemporaryAlert(" Already at end of recording ", 1000);
924: } else if (frameCount < 0) {
925: rogue.playbackMode = false;
926: proceed = (rogue.playerTurnNumber < 100 || confirm("Rewind?", true));
927: rogue.playbackMode = true;
928: if (proceed) {
929: seek(destinationFrame, RECORDING_SEEK_MODE_TURN);
930: }
931: } else {
932: // advance by the right number of turns
933: seek(destinationFrame, RECORDING_SEEK_MODE_TURN);
934: }
935: return true;
936: case BROGUE_HELP_KEY:
937: printPlaybackHelpScreen();
938: return true;
939: case DISCOVERIES_KEY:
940: rogue.playbackMode = false;
941: printDiscoveriesScreen();
942: rogue.playbackMode = true;
943: return true;
944: case MESSAGE_ARCHIVE_KEY:
945: rogue.playbackMode = false;
946: displayMessageArchive();
947: rogue.playbackMode = true;
948: return true;
949: case VIEW_RECORDING_KEY:
950: confirmMessages();
951: rogue.playbackMode = false;
952: if (dialogChooseFile(path, RECORDING_SUFFIX, "View recording: ")) {
953: if (fileExists(path)) {
954: strcpy(rogue.nextGamePath, path);
955: rogue.nextGame = NG_VIEW_RECORDING;
956: rogue.gameHasEnded = true;
957: } else {
958: message("File not found.", false);
959: }
960: }
961: rogue.playbackMode = true;
962: return true;
963: case LOAD_SAVED_GAME_KEY:
964: confirmMessages();
965: rogue.playbackMode = false;
966: if (dialogChooseFile(path, GAME_SUFFIX, "Open saved game: ")) {
967: if (fileExists(path)) {
968: strcpy(rogue.nextGamePath, path);
969: rogue.nextGame = NG_OPEN_GAME;
970: rogue.gameHasEnded = true;
971: } else {
972: message("File not found.", false);
973: }
974: }
975: rogue.playbackMode = true;
976: return true;
977: case NEW_GAME_KEY:
978: rogue.playbackMode = false;
979: if (confirm("Close recording and begin a new game?", true)) {
980: rogue.nextGame = NG_NEW_GAME;
981: rogue.gameHasEnded = true;
982: }
983: rogue.playbackMode = true;
984: return true;
985: case QUIT_KEY:
986: //freeEverything();
987: rogue.gameHasEnded = true;
988: rogue.playbackOOS = false;
989: rogue.creaturesWillFlashThisTurn = false;
990: notifyEvent(GAMEOVER_RECORDING, 0, 0, "recording ended", "none");
991: return true;
992: case TRUE_COLORS_KEY:
993: rogue.trueColorMode = !rogue.trueColorMode;
994: displayLevel();
995: refreshSideBar(-1, -1, false);
996: if (rogue.trueColorMode) {
997: messageWithColor(KEYBOARD_LABELS ? "Color effects disabled. Press '\\' again to enable." : "Color effects disabled.",
998: &teal, false);
999: } else {
1000: messageWithColor(KEYBOARD_LABELS ? "Color effects enabled. Press '\\' again to disable." : "Color effects enabled.",
1001: &teal, false);
1002: }
1003: return true;
1004: case AGGRO_DISPLAY_KEY:
1005: rogue.displayAggroRangeMode = !rogue.displayAggroRangeMode;
1006: displayLevel();
1007: refreshSideBar(-1, -1, false);
1008: if (rogue.displayAggroRangeMode) {
1009: messageWithColor(KEYBOARD_LABELS ? "Stealth range displayed. Press ']' again to hide." : "Stealth range displayed.",
1010: &teal, false);
1011: } else {
1012: messageWithColor(KEYBOARD_LABELS ? "Stealth range hidden. Press ']' again to display." : "Stealth range hidden.",
1013: &teal, false);
1014: }
1015: return true;
1016: case GRAPHICS_KEY:
1017: if (hasGraphics) {
1018: graphicsEnabled = setGraphicsEnabled(!graphicsEnabled);
1019: if (graphicsEnabled) {
1020: messageWithColor(KEYBOARD_LABELS ? "Enabled graphical tiles. Press 'G' again to disable." : "Enable graphical tiles.",
1021: &teal, false);
1022: } else {
1023: messageWithColor(KEYBOARD_LABELS ? "Disabled graphical tiles. Press 'G' again to enable." : "Disabled graphical tiles.",
1024: &teal, false);
1025: }
1026: }
1027: return true;
1028: case SEED_KEY:
1029: //rogue.playbackMode = false;
1030: //DEBUG {displayGrid(safetyMap); displayMoreSign(); displayLevel();}
1031: //rogue.playbackMode = true;
1032: printSeed();
1033: return true;
1034: case SWITCH_TO_PLAYING_KEY:
1035: #ifdef ENABLE_PLAYBACK_SWITCH
1036: if (!rogue.gameHasEnded && !rogue.playbackOOS) {
1037: switchToPlaying();
1038: lengthOfPlaybackFile = recordingLocation;
1039: }
1040: return true;
1041: #endif
1042: return false;
1043: case ESCAPE_KEY:
1044: if (!rogue.playbackPaused) {
1045: rogue.playbackPaused = true;
1046: return true;
1047: }
1048: return false;
1049: default:
1050: if (key >= '0' && key <= '9'
1051: || key >= NUMPAD_0 && key <= NUMPAD_9) {
1052:
1053: promptToAdvanceToLocation(key);
1054: return true;
1055: }
1056: return false;
1057: }
1058: } else if (recordingInput->eventType == MOUSE_UP) {
1059: x = recordingInput->param1;
1060: y = recordingInput->param2;
1061: if (windowToMapX(x) >= 0 && windowToMapX(x) < DCOLS && y >= 0 && y < MESSAGE_LINES) {
1062: // If the click location is in the message block, display the message archive.
1063: rogue.playbackMode = false;
1064: displayMessageArchive();
1065: rogue.playbackMode = true;
1066: return true;
1067: } else if (!rogue.playbackPaused) {
1068: // clicking anywhere else pauses the playback
1069: rogue.playbackPaused = true;
1070: return true;
1071: }
1072: } else if (recordingInput->eventType == RIGHT_MOUSE_UP) {
1073: rogue.playbackMode = false;
1074: displayInventory(ALL_ITEMS, 0, 0, true, false);
1075: rogue.playbackMode = true;
1076: return true;
1077: }
1078: return false;
1079: }
1080:
1081: // Pass in defaultPath (the file name WITHOUT suffix), and the suffix.
1082: // Get back either defaultPath, or "defaultPath N",
1083: // where N is the lowest counting number that doesn't collide with an existing file.
1084: void getAvailableFilePath(char *returnPath, const char *defaultPath, const char *suffix) {
1085: char fullPath[BROGUE_FILENAME_MAX];
1086: short fileNameIterator = 2;
1087:
1088: strcpy(returnPath, defaultPath);
1089: sprintf(fullPath, "%s%s", returnPath, suffix);
1090: while (fileExists(fullPath)) {
1091: sprintf(returnPath, "%s (%i)", defaultPath, fileNameIterator);
1092: sprintf(fullPath, "%s%s", returnPath, suffix);
1093: fileNameIterator++;
1094: }
1095: }
1096:
1097: boolean characterForbiddenInFilename(const char theChar) {
1098: if (theChar == '/' || theChar == '\\' || theChar == ':') {
1099: return true;
1100: } else {
1101: return false;
1102: }
1103: }
1104:
1105: void getDefaultFilePath(char *defaultPath, boolean gameOver) {
1106: char seed[21];
1107:
1108: // 32-bit numbers are printed in full
1109: // 64-bit numbers longer than 11 digits are shortened to e.g "184...51615"
1110: sprintf(seed, "%llu", (unsigned long long)rogue.seed);
1111: if (strlen(seed) > 11) sprintf(seed+3, "...%05lu", (unsigned long)(rogue.seed % 100000));
1112:
1113: if (serverMode) {
1114: // With WebBrogue, filenames must fit into 30 bytes, including extension and terminal \0.
1115: // It is enough for the seed and the optional file counter. The longest filename will be:
1116: // "#184...51615 (999).broguesave" (30 bytes)
1117: sprintf(defaultPath, "#%s", seed);
1118: return;
1119: }
1120:
1121: if (!gameOver) {
1122: sprintf(defaultPath, "Saved #%s at depth %d", seed, rogue.depthLevel);
1123: } else if (rogue.quit) {
1124: sprintf(defaultPath, "#%s Quit at depth %d", seed, rogue.depthLevel);
1125: } else if (player.bookkeepingFlags & MB_IS_DYING) {
1126: sprintf(defaultPath, "#%s Died at depth %d", seed, rogue.depthLevel);
1127: } else if (rogue.depthLevel > 26) {
1128: sprintf(defaultPath, "#%s Mastered the dungeons", seed);
1129: } else {
1130: sprintf(defaultPath, "#%s Escaped the dungeons", seed);
1131: }
1132: if (rogue.wizard) {
1133: strcat(defaultPath, " (wizard)");
1134: } else if (rogue.easyMode) {
1135: strcat(defaultPath, " (easy)");
1136: }
1137: }
1138:
1139: void saveGameNoPrompt() {
1140: char filePath[BROGUE_FILENAME_MAX], defaultPath[BROGUE_FILENAME_MAX];
1141: if (rogue.playbackMode) {
1142: return;
1143: }
1144: getDefaultFilePath(defaultPath, false);
1145: getAvailableFilePath(filePath, defaultPath, GAME_SUFFIX);
1146: flushBufferToFile();
1147: strcat(filePath, GAME_SUFFIX);
1148: rename(currentFilePath, filePath);
1149: strcpy(currentFilePath, filePath);
1150: rogue.gameHasEnded = true;
1151: rogue.recording = false;
1152: }
1153:
1154: void saveGame() {
1155: char filePath[BROGUE_FILENAME_MAX], defaultPath[BROGUE_FILENAME_MAX];
1156: boolean askAgain;
1157:
1158: if (rogue.playbackMode) {
1159: return; // Call me paranoid, but I'd rather it be impossible to embed malware in a recording.
1160: }
1161:
1162: getDefaultFilePath(defaultPath, false);
1163: getAvailableFilePath(filePath, defaultPath, GAME_SUFFIX);
1164:
1165: deleteMessages();
1166: do {
1167: askAgain = false;
1168: if (getInputTextString(filePath, "Save game as (<esc> to cancel): ",
1169: BROGUE_FILENAME_MAX - strlen(GAME_SUFFIX), filePath, GAME_SUFFIX, TEXT_INPUT_FILENAME, false)) {
1170: strcat(filePath, GAME_SUFFIX);
1171: if (!fileExists(filePath) || confirm("File of that name already exists. Overwrite?", true)) {
1172: remove(filePath);
1173: flushBufferToFile();
1174: rename(currentFilePath, filePath);
1175: strcpy(currentFilePath, filePath);
1176: rogue.recording = false;
1177: message("Saved.", true);
1178: rogue.gameHasEnded = true;
1179: } else {
1180: askAgain = true;
1181: }
1182: }
1183: } while (askAgain);
1184: deleteMessages();
1185: }
1186:
1187: void saveRecordingNoPrompt(char *filePath) {
1188: char defaultPath[BROGUE_FILENAME_MAX];
1189: if (rogue.playbackMode) {
1190: return;
1191: }
1192: getDefaultFilePath(defaultPath, true);
1193: getAvailableFilePath(filePath, defaultPath, RECORDING_SUFFIX);
1194: strcat(filePath, RECORDING_SUFFIX);
1195: remove(filePath);
1196: rename(currentFilePath, filePath);
1197: rogue.recording = false;
1198: }
1199:
1200: void saveRecording(char *filePath) {
1201: char defaultPath[BROGUE_FILENAME_MAX];
1202: boolean askAgain;
1203:
1204: if (rogue.playbackMode) {
1205: return;
1206: }
1207:
1208: getDefaultFilePath(defaultPath, true);
1209: getAvailableFilePath(filePath, defaultPath, RECORDING_SUFFIX);
1210:
1211: deleteMessages();
1212: do {
1213: askAgain = false;
1214: if (getInputTextString(filePath, "Save recording as (<esc> to cancel): ",
1215: BROGUE_FILENAME_MAX - strlen(RECORDING_SUFFIX), filePath, RECORDING_SUFFIX, TEXT_INPUT_FILENAME, false)) {
1216:
1217: strcat(filePath, RECORDING_SUFFIX);
1218: if (!fileExists(filePath) || confirm("File of that name already exists. Overwrite?", true)) {
1219: remove(filePath);
1220: rename(currentFilePath, filePath);
1221: rogue.recording = false;
1222: } else {
1223: askAgain = true;
1224: }
1225: } else { // Declined to save recording; save it anyway as LastRecording, and delete LastRecording if it already exists.
1226: strcpy(filePath, LAST_RECORDING_NAME);
1227: strcat(filePath, RECORDING_SUFFIX);
1228: if (fileExists(filePath)) {
1229: remove(filePath);
1230: }
1231: rename(currentFilePath, filePath);
1232: rogue.recording = false;
1233: }
1234: } while (askAgain);
1235: deleteMessages();
1236: }
1237:
1238: void copyFile(char *fromFilePath, char *toFilePath, unsigned long fromFileLength) {
1239: unsigned long m, n;
1240: unsigned char fileBuffer[INPUT_RECORD_BUFFER];
1241: FILE *fromFile, *toFile;
1242:
1243: remove(toFilePath);
1244:
1245: fromFile = fopen(fromFilePath, "rb");
1246: toFile = fopen(toFilePath, "wb");
1247:
1248: for (n = 0; n < fromFileLength; n += m) {
1249: m = min(INPUT_RECORD_BUFFER, fromFileLength - n);
1250: fread((void *) fileBuffer, 1, m, fromFile);
1251: fwrite((void *) fileBuffer, 1, m, toFile);
1252: }
1253:
1254: fclose(fromFile);
1255: fclose(toFile);
1256: }
1257:
1258: // at the end of loading a saved game, this function transitions into active play mode.
1259: void switchToPlaying() {
1260: char lastGamePath[BROGUE_FILENAME_MAX];
1261:
1262: getAvailableFilePath(lastGamePath, LAST_GAME_NAME, GAME_SUFFIX);
1263: strcat(lastGamePath, GAME_SUFFIX);
1264:
1265: rogue.playbackMode = false;
1266: rogue.playbackFastForward = false;
1267: rogue.playbackOmniscience = false;
1268: rogue.recording = true;
1269: locationInRecordingBuffer = 0;
1270: copyFile(currentFilePath, lastGamePath, recordingLocation);
1271: #ifndef ENABLE_PLAYBACK_SWITCH
1272: if (DELETE_SAVE_FILE_AFTER_LOADING) {
1273: remove(currentFilePath);
1274: }
1275: #endif
1276:
1277: strcpy(currentFilePath, lastGamePath);
1278:
1279: blackOutScreen();
1280: refreshSideBar(-1, -1, false);
1281: updateMessageDisplay();
1282: displayLevel();
1283: }
1284:
1285: // Return whether the load was cancelled by an event
1286: boolean loadSavedGame() {
1287: unsigned long progressBarInterval;
1288: unsigned long previousRecordingLocation;
1289: rogueEvent theEvent;
1290:
1291: cellDisplayBuffer dbuf[COLS][ROWS];
1292:
1293: randomNumbersGenerated = 0;
1294: rogue.playbackMode = true;
1295: rogue.playbackFastForward = true;
1296: initializeRogue(0); // Calls initRecording(). Seed argument is ignored because we're initially in playback mode.
1297: if (!rogue.gameHasEnded) {
1298: blackOutScreen();
1299: startLevel(rogue.depthLevel, 1);
1300: }
1301:
1302: if (rogue.howManyTurns > 0) {
1303:
1304: progressBarInterval = max(1, lengthOfPlaybackFile / 100);
1305: previousRecordingLocation = -1; // unsigned
1306: clearDisplayBuffer(dbuf);
1307: rectangularShading((COLS - 20) / 2, ROWS / 2, 20, 1, &black, INTERFACE_OPACITY, dbuf);
1308: rogue.playbackFastForward = false;
1309: overlayDisplayBuffer(dbuf, 0);
1310: rogue.playbackFastForward = true;
1311:
1312: while (recordingLocation < lengthOfPlaybackFile
1313: && rogue.playerTurnNumber < rogue.howManyTurns
1314: && !rogue.gameHasEnded
1315: && !rogue.playbackOOS) {
1316:
1317: rogue.RNG = RNG_COSMETIC;
1318: nextBrogueEvent(&theEvent, false, true, false);
1319: rogue.RNG = RNG_SUBSTANTIVE;
1320:
1321: executeEvent(&theEvent);
1322:
1323: if (recordingLocation / progressBarInterval != previousRecordingLocation / progressBarInterval && !rogue.playbackOOS) {
1324: rogue.playbackFastForward = false; // so that pauseBrogue looks for inputs
1325: printProgressBar((COLS - 20) / 2, ROWS / 2, "[ Loading... ]", recordingLocation, lengthOfPlaybackFile, &darkPurple, false);
1326: while (pauseBrogue(0)) { // pauseBrogue(0) is necessary to flush the display to the window in SDL, as well as look for inputs
1327: rogue.creaturesWillFlashThisTurn = false; // prevent monster flashes from showing up on screen
1328: nextBrogueEvent(&theEvent, true, false, true);
1329: if (rogue.gameHasEnded || theEvent.eventType == KEYSTROKE && theEvent.param1 == ESCAPE_KEY) {
1330: return false;
1331: }
1332: }
1333: rogue.playbackFastForward = true;
1334: previousRecordingLocation = recordingLocation;
1335: }
1336: }
1337: }
1338:
1339: if (!rogue.gameHasEnded && !rogue.playbackOOS) {
1340: switchToPlaying();
1341: recordChar(SAVED_GAME_LOADED);
1342: }
1343: return true;
1344: }
1345:
1346: // the following functions are used to create human-readable descriptions of playback files for debugging purposes
1347:
1348: void describeKeystroke(unsigned char key, char *description) {
1349: short i;
1350: long c;
1351: const long keyList[50] = {UP_KEY, DOWN_KEY, LEFT_KEY, RIGHT_KEY, UP_ARROW, LEFT_ARROW,
1352: DOWN_ARROW, RIGHT_ARROW, UPLEFT_KEY, UPRIGHT_KEY, DOWNLEFT_KEY, DOWNRIGHT_KEY,
1353: DESCEND_KEY, ASCEND_KEY, REST_KEY, AUTO_REST_KEY, SEARCH_KEY, INVENTORY_KEY,
1354: ACKNOWLEDGE_KEY, EQUIP_KEY, UNEQUIP_KEY, APPLY_KEY, THROW_KEY, RELABEL_KEY, DROP_KEY, CALL_KEY,
1355: //FIGHT_KEY, FIGHT_TO_DEATH_KEY,
1356: BROGUE_HELP_KEY, DISCOVERIES_KEY, RETURN_KEY,
1357: EXPLORE_KEY, AUTOPLAY_KEY, SEED_KEY, EASY_MODE_KEY, ESCAPE_KEY,
1358: RETURN_KEY, DELETE_KEY, TAB_KEY, PERIOD_KEY, VIEW_RECORDING_KEY, NUMPAD_0,
1359: NUMPAD_1, NUMPAD_2, NUMPAD_3, NUMPAD_4, NUMPAD_5, NUMPAD_6, NUMPAD_7, NUMPAD_8,
1360: NUMPAD_9, UNKNOWN_KEY};
1361: const char descList[51][30] = {"up", "down", "left", "right", "up arrow", "left arrow",
1362: "down arrow", "right arrow", "upleft", "upright", "downleft", "downright",
1363: "descend", "ascend", "rest", "auto rest", "search", "inventory", "acknowledge",
1364: "equip", "unequip", "apply", "throw", "relabel", "drop", "call",
1365: //"fight", "fight to death",
1366: "help", "discoveries", "repeat travel", "explore", "autoplay", "seed",
1367: "easy mode", "escape", "return", "delete", "tab", "period", "open file",
1368: "numpad 0", "numpad 1", "numpad 2", "numpad 3", "numpad 4", "numpad 5", "numpad 6",
1369: "numpad 7", "numpad 8", "numpad 9", "unknown", "ERROR"};
1370:
1371: c = uncompressKeystroke(key);
1372: for (i=0; i < 50 && keyList[i] != c; i++);
1373: if (key >= 32 && key <= 126) {
1374: sprintf(description, "Key: %c\t(%s)", key, descList[i]);
1375: } else {
1376: sprintf(description, "Key: %i\t(%s)", key, descList[i]);
1377: }
1378: }
1379:
1380: void appendModifierKeyDescription(char *description) {
1381: unsigned char c = recallChar();
1382:
1383: if (c & Fl(1)) {
1384: strcat(description, " + CRTL");
1385: }
1386: if (c & Fl(2)) {
1387: strcat(description, " + SHIFT");
1388: }
1389: }
1390:
1391: // Deprecated! Only used to parse recordings, a debugging feature.
1392: boolean selectFile(char *prompt, char *defaultName, char *suffix) {
1393: boolean retval;
1394: char newFilePath[BROGUE_FILENAME_MAX];
1395:
1396: retval = false;
1397:
1398: if (chooseFile(newFilePath, prompt, defaultName, suffix)) {
1399: if (openFile(newFilePath)) {
1400: retval = true;
1401: } else {
1402: confirmMessages();
1403: message("File not found.", false);
1404: retval = false;
1405: }
1406: }
1407: return retval;
1408: }
1409:
1410: void parseFile() {
1411: FILE *descriptionFile;
1412: unsigned long oldFileLoc, oldRecLoc, oldLength, oldBufLoc, i, seed, numTurns, numDepths, fileLength, startLoc;
1413: unsigned char c;
1414: char description[1000], versionString[500];
1415: short x, y;
1416:
1417: if (selectFile("Parse recording: ", "Recording.broguerec", "")) {
1418:
1419: oldFileLoc = positionInPlaybackFile;
1420: oldRecLoc = recordingLocation;
1421: oldBufLoc = locationInRecordingBuffer;
1422: oldLength = lengthOfPlaybackFile;
1423:
1424: positionInPlaybackFile = 0;
1425: locationInRecordingBuffer = 0;
1426: recordingLocation = 0;
1427: lengthOfPlaybackFile = 10000000; // hack so that the recalls don't freak out
1428: fillBufferFromFile();
1429:
1430: descriptionFile = fopen("Recording Description.txt", "w");
1431:
1432: for (i=0; i<16; i++) {
1433: versionString[i] = recallChar();
1434: }
1435:
1436: seed = recallNumber(4);
1437: numTurns = recallNumber(4);
1438: numDepths = recallNumber(4);
1439: fileLength = recallNumber(4);
1440:
1441: fprintf(descriptionFile, "Parsed file \"%s\":\n\tVersion: %s\n\tSeed: %li\n\tNumber of turns: %li\n\tNumber of depth changes: %li\n\tFile length: %li\n",
1442: currentFilePath,
1443: versionString,
1444: seed,
1445: numTurns,
1446: numDepths,
1447: fileLength);
1448: for (i=0; recordingLocation < fileLength; i++) {
1449: startLoc = recordingLocation;
1450: c = recallChar();
1451: switch (c) {
1452: case KEYSTROKE:
1453: describeKeystroke(recallChar(), description);
1454: appendModifierKeyDescription(description);
1455: break;
1456: case MOUSE_UP:
1457: case MOUSE_DOWN:
1458: case MOUSE_ENTERED_CELL:
1459: x = (short) recallChar();
1460: y = (short) recallChar();
1461: sprintf(description, "Mouse click: (%i, %i)", x, y);
1462: appendModifierKeyDescription(description);
1463: break;
1464: case RNG_CHECK:
1465: sprintf(description, "\tRNG check: %i", (short) recallChar());
1466: break;
1467: case SAVED_GAME_LOADED:
1468: strcpy(description, "Saved game loaded");
1469: break;
1470: default:
1471: sprintf(description, "UNKNOWN EVENT TYPE: %i", (short) c);
1472: break;
1473: }
1474: fprintf(descriptionFile, "\nEvent %li, loc %li, length %li:%s\t%s", i, startLoc, recordingLocation - startLoc, (i < 10 ? " " : ""), description);
1475: }
1476:
1477: fclose(descriptionFile);
1478:
1479: positionInPlaybackFile = oldFileLoc;
1480: recordingLocation = oldRecLoc;
1481: lengthOfPlaybackFile = oldLength;
1482: locationInRecordingBuffer = oldBufLoc;
1483: message("File parsed.", false);
1484: } else {
1485: confirmMessages();
1486: }
1487: }
1488:
1489: void RNGLog(char *message) {
1490: #ifdef AUDIT_RNG
1491: fputs(message, RNGLogFile);
1492: #endif
1493: }
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Recordings.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / brogue-ce / src / brogue