lj/lj046-2players: src/debrief.c comparison

comparison src/debrief.c @ 2:80a2761bd3a4

change DS keys (add alt. rotate)

author	paulo@localhost
date	Mon, 23 Mar 2009 01:19:12 -0700
parents
children

comparison

equal deleted inserted replaced

--1:000000000000
+:18d9d109289f
+/* PC frontend for LOCKJAW, an implementation of the Soviet Mind Game
+Copyright (C) 2006 Damian Yerrick <tepples+lj@spamcop.net>
+This work is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+Original game concept and design by Alexey Pajitnov.
+The Software is not sponsored or endorsed by Alexey Pajitnov, Elorg,
+or The Tetris Company LLC.
+*/
+#include "ljplay.h"
+#include "options.h"
+#include <stdio.h>
+#ifndef NO_DATETIME
+#include <time.h>
+#endif
+#define USING_DEBRIEF_PAGE 1
+#define MIN_RECTUM_ROWS 4
+#define MIN_ZIGZAG_ROWS 2
+// On newlib, use a variant of sprintf that doesn't handle floating
+// point formats. On other C libraries, use standard sprintf.
+#ifdef HAS_FPU
+#define siprintf sprintf
+#ifndef HAS_FOPEN
+#define HAS_FOPEN
+#endif
+#define DEBRIEF_TO_STDOUT
+#endif
+#ifdef HAS_FOPEN
+#include "ljpath.h"  // for ljfopen
+#endif
+const char *const debriefBoolNames[2] = {
+"Off", "On"
+};
+typedef struct TimeResultMSF {
+unsigned int pieces_100m;
+unsigned int garbage_100m;
+unsigned int minutes;
+unsigned char seconds;
+unsigned char frames;
+} TimeResultMSF;
+void frames2msf(unsigned int gameTime,
+unsigned int nPieces,
+unsigned int outGarbage,
+TimeResultMSF *out) {
+unsigned int gameSeconds = gameTime / 60U;
+unsigned int gameMinutes = gameSeconds / 60U;
+out->pieces_100m = gameTime
+? 360000ULL * nPieces / gameTime
+: 0;
+out->garbage_100m = gameTime
+? 360000ULL * outGarbage / gameTime
+: 0;
+out->minutes = gameMinutes;
+out->seconds = gameSeconds - gameMinutes * 60U;
+out->frames = gameTime - gameSeconds * 60U;
+}
+static unsigned int countBlocksLeft(const LJField *p) {
+unsigned int n = 0;
+for (int y = 0; y < LJ_PF_HT; ++y) {
+for (int x = 0; x < LJ_PF_WID; ++x) {
+if (p->b[y][x]) {
+++n;
+}
+}
+}
+return n;
+}
+/**
+* Calculates the number of rows starting at the bottom that
+* conform to a zigzag pattern.
+* @param p the playfield to test
+* @return the number of rows successfully completed
+*/
+unsigned int calcZigzagGrade(const LJField *p) {
+unsigned int hole = p->leftWall;
+int delta = 1;
+for (size_t y = 0; y < p->ceiling; ++y) {
+// invariant:
+// at this point, y equals the number of rows known to conform
+for (size_t x = p->leftWall; x < p->rightWall; ++x) {
+unsigned int blk = p->b[y][x];
+// A block should be in all cells of the row
+// except for the hole cell, which should be empty.
+if (x == hole) {
+// if there's a block where a hole should be, this row
+// doesn't conform, but all the rows below do conform
+if (blk) {
+return y;
+}
+} else {
+// if there's a hole where a block should be, this row
+// doesn't conform, but all the rows below do conform
+if (!blk) {
+return y;
+}
+}
+}
+// if this hole isn't covered up on the next row,
+// this row doesn't conform either
+// changed in 0.43 after a clarification from Kitaru
+if (!p->b[y + 1][hole]) {
+return y;
+}
+// by now we know that the row conforms,
+// so move the hole for the next row
+if (hole == p->rightWall - 1) {
+delta = -1;
+} else if (hole == p->leftWall) {
+delta = 1;
+}
+hole += delta;
+}
+return p->ceiling;
+}
+/**
+* Calculates the number of rows in a playfield that were prepared
+* for an I tetromino.
+* Rule for this pattern:
+* 1. Only one hole on the bottom row.
+* 2. This column must be unoccupied below the ceiling.
+* 3. Conforming rows must be full except for the hole.
+*
+* Easy test procedure for this pattern:
+* Level 4 garbage
+* @return the number of rows that conform to constraint 3, or 0 if the
+* field does not conform to constraint 1 or 2.
+*/
+unsigned int calcRectumGrade(const LJField *p) {
+unsigned int hole = LJ_PF_WID;
+// search for the first hole on the bottom row
+for (unsigned int x = p->leftWall;
+x < p->rightWall;
+++x) {
+if (!p->b[0][x]) {
+hole = x;
+break;
+}
+}
+// If there is no hole in the bottom row, then 0 rows conform.
+// This shouldn't happen in standard smg because the line would be
+// cleared, but eventually LJ will support games other than SMG,
+// and checking the array bounds is O(1), so why not?
+if (hole >= p->rightWall) {
+return 0;
+}
+// make sure that the row is clear through the whole visible
+// portion of the playfield
+for (unsigned int y = 0; y < p->ceiling; ++y) {
+// If this column isn't empty, the whole field doesn't conform.
+if (p->b[y][hole]) {
+return 0;
+}
+}
+for (unsigned int y = 0; y < p->ceiling; ++y) {
+// At this point, the bottom y rows conform.
+for (unsigned int x = p->leftWall; x < p->rightWall; ++x) {
+// Disregarding the hole column, if there's an empty cell
+// in this row, then this row does not conform.
+if (x != hole && !p->b[y][x]) {
+return y;
+}
+}
+}
+return p->ceiling;
+}
+/**
+* Converts a rank number (0-19) to a text rank.
+* 0-9: 10-1 kyu; 10-99: 1-90 dan; 100+: grandmaster
+* @return number of characters written
+*/
+static size_t printSecretGrade(char *dst, int rank) {
+if (rank >= 100) {
+return siprintf(dst, "GM");
+} else if (rank >= 10) {
+return siprintf(dst, "S%d", rank - 9);
+} else {
+return siprintf(dst, "%d", 10 - rank);
+}
+}
+static size_t printFracG(char *dst, unsigned int value) {
+if (value == 0) {
+return siprintf(dst, "Instant");
+} else if (value == 1) {
+return siprintf(dst, "1G");
+} else {
+return siprintf(dst, "1/%dG", value);
+}
+}
+#include <string.h>  // remove once fourcc transition is complete
+static size_t printFourCC(char *dst, FourCC f) {
+const char *data = ljGetFourCCName(f);
+if (data) {
+int pos = 0;
+for(pos = 0; *data; ++pos) {
+dst[pos] = *data++;
+}
+return pos;
+} else {
+int pos = 0;
+for(pos = 0; f.c[pos] && pos < 4; ++pos) {
+dst[pos] = f.c[pos];
+}
+return pos;
+}
+}
+size_t buildOptionsReportPage(char *dst, const LJView *v) {
+size_t pos = 0;
+#if USING_DEBRIEF_PAGE
+const LJField *p = v->field;
+pos += siprintf(dst + pos,
+"Options\n\n"
+"Well: %dx%d%s, Enter: %s\n"
+"Speed: ",
+p->rightWall - p->leftWall,
+p->ceiling,
+v->hidePF ? " invisible" : "",
+p->enterAbove ? "Above" : "Below");
+pos += printFourCC(dst + pos,
+optionsSpeedCurveNames[(size_t)p->speedState.curve]);
+pos += siprintf(dst + pos,
+", ARE: %d ms\n"
+"Randomizer: ",
+v->field->areStyle * 50 / 3);
+pos += printFourCC(dst + pos,
+optionsRandNames[(size_t)p->randomizer]);
+pos += siprintf(dst + pos, " of ");
+pos += printFourCC(dst + pos,
+optionsPieceSetNames[(size_t)p->pieceSet]);
+pos += siprintf(dst + pos, "\nHold: ");
+pos += printFourCC(dst + pos,
+optionsHoldStyleNames[(size_t)p->holdStyle]);
+pos += siprintf(dst + pos, ", Rotation: ");
+pos += printFourCC(dst + pos,
+optionsRotNames[(size_t)p->rotationSystem]);
+if (p->maxUpwardKicks < 20) {
+pos += siprintf(dst + pos,
+" %d FK",
+(int)p->maxUpwardKicks);
+}
+if (v->control->initialRotate) {
+pos += siprintf(dst + pos, "+initial");
+}
+pos += siprintf(dst + pos,
+"\nLock: ");
+if (p->setLockDelay >= 128) {
+pos += siprintf(dst + pos, "Never");
+} else {
+if (p->setLockDelay > 0) {
+pos += siprintf(dst + pos,
+"%d ms ",
+p->setLockDelay * 50 / 3);
+}
+pos += printFourCC(dst + pos,
+optionsLockdownNames[(size_t)p->lockReset]);
+}
+pos += siprintf(dst + pos,
+", Deep: %s\n",
+debriefBoolNames[p->bottomBlocks]);
+pos += siprintf(dst + pos,
+"Line clear: %d ms ",
+p->speed.lineDelay * 50 / 3);
+pos += printFourCC(dst + pos,
+optionsGravNames[(size_t)p->clearGravity]);
+pos += siprintf(dst + pos,
+", Gluing: ");
+pos += printFourCC(dst + pos,
+optionsGluingNames[(size_t)p->gluing]);
+pos += siprintf(dst + pos,
+"\nDrop score: ");
+pos += printFourCC(dst + pos,
+optionsDropScoringNames[(size_t)p->dropScoreStyle]);
+pos += siprintf(dst + pos,
+", T-spin: ");
+pos += printFourCC(dst + pos,
+optionsTspinNames[(size_t)p->tSpinAlgo]);
+pos += siprintf(dst + pos,
+"\nGarbage: ");
+pos += printFourCC(dst + pos,
+optionsGarbageNames[(size_t)p->garbageStyle]);
+pos += siprintf(dst + pos,
+", DAS: %d ms ",
+v->control->dasDelay * 50 / 3);
+pos += printFracG(dst + pos, v->control->dasSpeed);
+pos += siprintf(dst + pos,
+"\nSoft drop: ");
+pos += printFracG(dst + pos, v->control->softDropSpeed + 1);
+dst[pos++] = ' ';
+pos += printFourCC(dst + pos,
+optionsZangiNames[v->control->softDropLock]);
+pos += siprintf(dst + pos,
+", Hard drop: ");
+pos += printFourCC(dst + pos,
+optionsZangiNames[v->control->hardDropLock]);
+pos += siprintf(dst + pos, "\nShadow: ");
+pos += printFourCC(dst + pos,
+optionsShadowNames[v->hideShadow]);
+pos += siprintf(dst + pos,
+", Next: %d\n",
+v->nextPieces);
+#else
+pos += siprintf(dst, "\n\nDebrief disabled.\n");
+#endif
+dst[pos] = 0;
+return pos;
+}
+#ifdef DEBRIEF_SHORT
+static const char *const naiveGravity[8] = {
+"1L", "2L", "3L", "4L",
+"T1", "T2", "T3"
+};
+static const char *const cascadeGravity[8] = {
+"1L", "2L", "3L", "4L",
+"5L", "6L", "7L", "8L+"
+};
+#else
+static const char *const naiveGravity[8] = {
+"single", "double", "triple", "home run",
+"T single", "T double", "T triple"
+};
+static const char *const cascadeGravity[8] = {
+"single", "double", "triple", "quad",
+"5L", "6L", "7L", "8L+"
+};
+#endif
+static size_t printLineCounts(char *dst, const LJField *p) {
+size_t pos = 0;
+const char *const *names = (p->clearGravity == LJGRAV_NAIVE)
+? naiveGravity : cascadeGravity;
+dst[pos++] = '(';
+for (int i = 0; i < 8; ++i) {
+if (names[i]) {
+pos += siprintf(dst + pos,
+"%s%s: %u",
+i ? "; " : "",
+names[i],
+p->nLineClears[i]);
+}
+}
+dst[pos++] = ')';
+dst[pos++] = '\n';
+return pos;
+}
+size_t buildDebriefPage(char *dst, const LJView *v) {
+size_t pos = 0;
+#if USING_DEBRIEF_PAGE
+#ifndef NO_DATETIME
+const time_t finishTimeUNIX = time(NULL);
+const struct tm *finishTime = localtime(&finishTimeUNIX);
+char finishTimeStr[64];
+/* I would have used
+strftime(finishTimeStr, sizeof(finishTimeStr), "%Y-%m-%d at %H:%M", finishTime);
+but it brings in the floating-point library on GBA/DS. */
+siprintf(finishTimeStr,
+"%04d-%02d-%02d at %02d:%02d",
+finishTime->tm_year + 1900,
+finishTime->tm_mon + 1, finishTime->tm_mday,
+finishTime->tm_hour, finishTime->tm_min);
+#endif
+const LJField *p = v->field;
+unsigned long int keys_100m = p->nPieces
+? 100U * v->control->presses / p->nPieces
+: 666;
+TimeResultMSF gameMSF, activeMSF;
+const char *wordPieces = (p->nPieces != 1) ? "tetrominoes" : "tetromino";
+if (p->pieceSet == LJRAND_234BLK) {
+wordPieces = (p->nPieces != 1) ? "pieces" : "piece";
+}
+/* Secret grades */
+unsigned int nBlocksLeft = countBlocksLeft(p);
+unsigned int nZigzagRows = calcZigzagGrade(p);
+unsigned int nRectumRows = calcRectumGrade(p);
+pos += siprintf(dst + pos,
+"Result:\n\n%s ",
+v->control->countdown <= 0 ? "Cleared" : "Stopped");
+pos += printFourCC(dst + pos, gimmickNames[p->gimmick]);
+pos += siprintf(dst + pos,
+" at level %d\n",
+p->speedState.level);
+#if !defined(NO_DATETIME) || defined(WITH_REPLAY)
+#ifndef NO_DATETIME
+pos += siprintf(dst + pos, "on %s", finishTimeStr);
+#endif
+#ifdef WITH_REPLAY
+if (p->reloaded) {
+pos += siprintf(dst + pos, " from saved state");
+}
+#endif
+dst[pos++] = '\n';
+#endif
+frames2msf(p->gameTime, p->nPieces, p->outGarbage, &gameMSF);
+frames2msf(p->activeTime, p->nPieces, p->outGarbage, &activeMSF);
+pos += siprintf(dst + pos,
+"Played %d %s in %u:%02u.%02u (%u.%02u/min)\n",
+p->nPieces,
+wordPieces,
+gameMSF.minutes,
+(unsigned int)gameMSF.seconds,
+gameMSF.frames * 5U / 3U,
+(unsigned int) (gameMSF.pieces_100m / 100),
+(unsigned int) (gameMSF.pieces_100m % 100));
+pos += siprintf(dst + pos,
+"(active time only: %u:%02u.%02u, %u.%02u/min)\n",
+activeMSF.minutes,
+(unsigned int)activeMSF.seconds,
+activeMSF.frames * 5U / 3U,
+(unsigned int) (activeMSF.pieces_100m / 100),
+(unsigned int) (activeMSF.pieces_100m % 100));
+pos += siprintf(dst + pos,
+"Pressed %u keys (%u.%02u/piece)\n\n",
+v->control->presses,
+(unsigned int) (keys_100m / 100),
+(unsigned int) (keys_100m % 100));
+pos += siprintf(dst + pos,
+"Made %u lines",
+p->lines);
+if (p->gluing == LJGLUING_SQUARE) {
+pos += siprintf(dst + pos,
+" and %u pure + %u squares",
+p->monosquares, p->multisquares);
+}
+dst[pos++] = '\n';
+pos += printLineCounts(dst + pos, p);
+pos += siprintf(dst + pos,
+"Sent %u garbage (%u.%02u per minute)\n",
+p->outGarbage,
+(unsigned int) (gameMSF.garbage_100m / 100),
+(unsigned int) (gameMSF.garbage_100m % 100));
+if (nZigzagRows >= MIN_ZIGZAG_ROWS) {
+pos += siprintf(dst + pos,
+"Made %u rows of > for grade ",
+nZigzagRows);
+pos += printSecretGrade(dst + pos,
+nZigzagRows >= 19 ? 100 : nZigzagRows);
+} else if (nRectumRows >= MIN_RECTUM_ROWS) {
+pos += siprintf(dst + pos,
+"Made %u-row rectum for grade ",
+nRectumRows);
+pos += printSecretGrade(dst + pos,
+nRectumRows >= 20 ? 100 : nRectumRows - 1);
+} else if (nBlocksLeft >= 110 && nBlocksLeft <= 111) {
+pos += siprintf(dst + pos,
+"Secret grade: Eleventy%s",
+(nBlocksLeft & 1) ? "-one" : "");
+} else {
+pos += siprintf(dst + pos,
+"Left %d blocks behind",
+nBlocksLeft);
+}
+dst[pos++] = '\n';
+dst[pos++] = '\n';
+pos += printFourCC(dst + pos, optionsScoringNames[p->scoreStyle]);
+pos += siprintf(dst + pos,
+" score: %d\n",
+p->score);
+/*
+tod stats not in lj
+points/line, 40 lines score, silver squares, gold squares
+*/
+#else
+pos += siprintf(dst, "\n\nDebrief disabled. Score: %u\n", v->field->score);
+#endif
+return pos;
+}
+void debriefDrawPage(const char *page, size_t pageNumber);
+LJBits debriefHandleKeys(void);
+extern volatile char redrawWholeScreen;
+/**
+* Reports the player's performance.
+*/
+void debrief(LJView *v) {
+char pageData[2000];  // current length is under 1000 chars
+char *page[2] = {pageData, "Page coming soon!"};
+int curPage = 0;
+{
+size_t pos;
+pos = buildDebriefPage(page[0], v);
+page[1] = page[0] + (++pos);
+pos += buildOptionsReportPage(page[1], v);
+}
+#ifdef HAS_FOPEN
+FILE *logFile = ljfopen("lj-scores.txt", "at");
+if (logFile) {
+fputs("\n\n\n", logFile);
+fputs(page[0], logFile);
+fputs(page[1], logFile);
+#ifdef DEBRIEF_TO_STDOUT
+fputs(page[0], stdout);
+fputs(page[1], stdout);
+#endif
+fclose(logFile);
+}
+#endif
+LJBits lastKeys = ~0;
+redrawWholeScreen = 1;
+debriefHandleKeys();  // call once to clear key buffer
+for (;;) {
+LJBits sounds = 0;
+if (redrawWholeScreen) {
+redrawWholeScreen = 0;
+debriefDrawPage(page[curPage], curPage);
+}
+LJBits keys = debriefHandleKeys();
+LJBits newKeys = keys & ~lastKeys;
+if (newKeys & VKEY_LEFT) {
+if (curPage > 0) {
+curPage -= 1;
+redrawWholeScreen = 1;
+sounds |= LJSND_HOLD;
+}
+}
+if (newKeys & VKEY_RIGHT) {
+if (curPage + 1 < sizeof(page) / sizeof(page[0])) {
+curPage += 1;
+redrawWholeScreen = 1;
+sounds |= LJSND_HOLD;
+}
+}
+if (newKeys & (VKEY_ROTR | VKEY_ROTL)) {
+break;
+} else {
+lastKeys = keys;
+}
+playSoundEffects(v, sounds, 100);
+}
+}

Mercurial > hg > index.fcgi > lj > lj046-2players

comparison src/debrief.c @ 2:80a2761bd3a4