Files
Color8/color8.c
T
Brian Holman e8edf6455e Import Color8 0.1.14 upstream source snapshot
Original author: Pierre Sarrazin.
Source: http://sarrazip.com/dev/color8-0.1.14.tar.gz
Archive SHA-256: a98828720d91ac2b9c0939102bf5873650cd3df79323c7d6e086db9604546361
2026-11-09 23:45:11 -07:00

1502 lines
39 KiB
C

/* color8.c - COLOR EIGHTS - A game of Eights for the Color Computer (1, 2 and 3).
Copyright (C) 2003-2024 Pierre Sarrazin <http://sarrazip.com/>
This program 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 3 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, see <http://www.gnu.org/licenses/>.
*/
/* To compile into color8.bin (for Disk Basic), see the Makefile.
To test in the XRoar emulator:
xroar -machine cocous -cart-autorun -cart color8.rom
*/
#include "cardgame.h"
///////////////////////////////////////////////////////////////////////////////
#ifdef OS9
#include "Keyboard.h" /* bcontrol */
// bcontrol keyboard support.
//
Keyboard keyboard;
#define inkey() (Keyboard_poll(&keyboard))
// blinkCursor: TRUE is not supported.
//
byte
waitkey(byte blinkCursor)
{
for (;;)
{
byte key = inkey();
if (key)
return key;
}
}
void
pcls(byte byteToClearWith)
{
memset(scrnBuffer, byteToClearWith, BYTES_PER_SCREEN);
}
// OS9Timer_init() must have been called successfully.
//
#define getTimer() (OS9Timer_getTimer())
// OS9Timer_init() must have been called successfully.
//
#define setTimer(newValue) (OS9Timer_setTimer(newValue))
#endif /* OS9 */
///////////////////////////////////////////////////////////////////////////////
#define PROGRAM_FULL_NAME "Color Eights"
#define BY_LINE "By Pierre Sarrazin"
#define COLOR_EIGHTS_URL "sarrazip.com/dev/color8.html"
#define USER_HAND_ROW 149
#define DISPLAYED_CARD_COL 14
#define DISPLAYED_CARD_ROW 48
#define CARDS_PER_ROW 15
#define OVERLAY_HEIGHT 30 /* A card on top of another one must be drawn this many pixels lower, so enough of the bottom card shows. */
#define STATUS_COL 6
#define STATUS_ROW 1 // in characters
#define DECK_COL 21 // in bytes of pixels
#define DECK_ROW 8 // in pixels
#define EVENT_ROW 13
#define REQUESTED_SUIT_COL 19 // in characters
#define REQUESTED_SUIT_ROW 9 // in characters
#define QUIT_GAME 0
#define NEXT_PLAYER_PLAYS 1
#define NEXT_PLAYER_PASSES 2
#define PLAY_NEW_GAME 3
///////////////////////////////////////////////////////////////////////////////
byte mainDeck[NUMCARDS];
byte numCardsMainDeck;
byte discardDeck[NUMCARDS];
byte numDiscardedCards;
byte displayedCard;
byte requestedSuit;
byte userHand[NUMCARDS];
byte numUserCards;
byte computerHand[NUMCARDS];
byte numComputerCards;
void initDecks()
{
numCardsMainDeck = NUMCARDS;
for (byte i = 0; i < numCardsMainDeck; ++i)
mainDeck[i] = i + 1;
numDiscardedCards = 0;
displayedCard = 0;
numUserCards = 0;
numComputerCards = 0;
}
void shuffleMainDeck()
{
shuffleDeck(mainDeck, numCardsMainDeck);
}
// Transfers all cards from the discarded deck into the main deck,
// then calls shuffleMainDeck().
//
void reshuffle()
{
assertf(numCardsMainDeck + numDiscardedCards <= NUMCARDS, "%u, %u", numCardsMainDeck, numDiscardedCards);
for (byte i = 0; i < numDiscardedCards; i++)
mainDeck[numCardsMainDeck++] = discardDeck[i];
numCardsMainDeck = numDiscardedCards;
numDiscardedCards = 0;
shuffleMainDeck();
}
// Determines if 'card' is a card that does not make the other player
// pick cards, pass a turn or change the requested suit.
//
byte isOrdinaryCard(byte card)
{
if (getCardType(card) == SUIT_JOKER)
return FALSE;
switch (getCardValue(card))
{
case 2:
case 8:
case 11: // jack
return FALSE;
default:
return TRUE;
}
}
void putOrdinaryCardOnTopOfDeck()
{
if (numCardsMainDeck == 0)
return;
// Find the topmost (highest index) powerless card in the main deck.
//
byte i;
for (i = numCardsMainDeck; i--; )
if (isOrdinaryCard(mainDeck[i]))
break;
if (i == 0xFF) // if no ordinary card
return; // do nothing
byte topIndex = numCardsMainDeck - 1;
if (i == topIndex) // if topmost ordinary card is already on top
return; // nothing to do
// Swap found card with top card.
//
byte found = mainDeck[i];
mainDeck[i] = mainDeck[topIndex];
mainDeck[topIndex] = found;
}
byte pickCardFromMainDeck()
{
return pickCardFromDeck(mainDeck, &numCardsMainDeck);
}
byte isPlayableCard(byte card)
{
byte type = getCardType(card);
if (type == SUIT_JOKER)
return TRUE;
byte val = getCardValue(card);
if (val == 8)
return TRUE;
if (type == requestedSuit)
return TRUE;
return getCardType(displayedCard) != SUIT_JOKER
&& val == getCardValue(displayedCard);
}
byte atLeastOnePlayable(byte *hand, byte numCards)
{
byte i;
for (i = 0; i < numCards; i++)
if (isPlayableCard(hand[i]))
return TRUE;
return FALSE;
}
// Ordering of cards that puts the 8s at the end.
// Jokers go after the 8s because they are cards #53 and #54
// (see getCardType() in cardgame.h).
//
byte cardComesAfter(byte card0, byte card1)
{
assertf(card0 != card1, "%u", card0);
if (getCardValue(card0) == 8)
if (getCardValue(card1) == 8)
return card0 > card1;
else
return TRUE; // card0, being an 8, comes after card1, which is not an 8
else if (getCardValue(card1) == 8)
return FALSE;
else
return card0 > card1;
}
// Returns the index in hand[] where newCard was inserted.
//
byte insertCardInDisplayOrder(byte *hand, byte initNumCards, byte newCard)
{
assertf(initNumCards <= NUMCARDS, "%u", initNumCards);
assertf(newCard >= 1 && newCard <= NUMCARDS, "%u", newCard);
// Find the first card in hand[] that comes after 'newCard'.
//
byte i = 0;
for ( ; i < initNumCards; ++i)
if (cardComesAfter(hand[i], newCard))
break;
// Insert newCard at i (which may be initNumCards).
//
if (initNumCards > 0)
for (byte j = initNumCards; j > i; --j)
hand[j] = hand[j - 1];
hand[i] = newCard;
return i;
#if 0 // Debugging.
printf("Inserted %2u at %2u (init # %2u):", newCard, i, initNumCards);
for (byte j = 0; j < initNumCards + 1; ++j)
printf(" %3u", hand[j]);
printf("\n");
debugBufIndex = 0;
printf("[%3u] [%3u]\n", 7, 0);
byte debugBufIndex_ = debugBufIndex;
restoreOriginalTextMode();
printf("debugBufIndex=%u\n", debugBufIndex_);
for (byte j = 0; j < debugBufIndex_; ++j)
printf(" %02x", debugBuf[j]);
printf(".\n");
exit(0);
#endif
}
// Evaluates hand[], of length 'numCards' and returns a score for each suit
// in suitScores[4], the number of 8-cards in *nbEights and the number of
// jokers in *nbJokers.
// The score of a suit is higher if the player would be more advantaged
// if that suit were the required one.
// If 'playableCardsOnly' is true, then the score of a suit is zero if
// that suit is currently not playable. Passing FALSE is useful when
// playing an 8 or joker and any suit becomes admissible.
// Returns the suit (suit_{HEARTS,SPADES,DIAMONDS,CLUBS} with the
// highest score (as returned in suitScores[]).
//
byte evaluateHand(byte *suitScores, byte *nbEights, byte *nbJokers,
byte *hand, byte numCards, byte playableCardsOnly)
{
suitScores[0] = 0;
suitScores[1] = 0;
suitScores[2] = 0;
suitScores[3] = 0;
*nbEights = 0;
*nbJokers = 0;
byte playableSuit[4];
playableSuit[0] = FALSE;
playableSuit[1] = FALSE;
playableSuit[2] = FALSE;
playableSuit[3] = FALSE;
byte i;
for (i = 0; i < numCards; i++)
{
byte card = hand[i];
byte suit = getCardType(card);
byte val;
if (suit == SUIT_JOKER)
(*nbJokers)++;
else if ((val = getCardValue(card)) == 8)
(*nbEights)++;
else
{
if (isPlayableCard(card))
playableSuit[suit] = TRUE;
byte s = 2;
if (val == 11) // if jack
s += 2;
if (val == 2) // 2 forces 2- or 4-card pick
{
s += 8;
if (suit == SUIT_SPADES) // 2 of spades forces 4-card pick
s += 6;
}
suitScores[suit] += s;
}
}
if (playableCardsOnly)
for (byte suit = 0; suit < 4; suit++)
if (!playableSuit[suit])
suitScores[suit] = 0;
byte bestSuit = 0;
for (byte suit = 0; suit < 4; suit++)
if (suitScores[suit] > suitScores[bestSuit])
bestSuit = suit;
return bestSuit;
}
byte eventRowUsed = FALSE; // text row where most messages appear
#define autoMode FALSE // for debugging: when TRUE, user always picks
void clearEventRow()
{
moveCursor(0, EVENT_ROW);
printf(" ");
eventRowUsed = FALSE;
}
void printEvent(const char *str)
{
if (eventRowUsed)
{
optDelay(60);
clearEventRow();
}
printCentered(EVENT_ROW, str);
eventRowUsed = TRUE;
}
// Changes requestedSuit in the computer's interest.
//
void chooseComputerSuit()
{
byte suitScores[4];
byte nbEights;
byte nbJokers;
requestedSuit = evaluateHand(suitScores, &nbEights, &nbJokers,
computerHand, numComputerCards, FALSE);
char msg[33];
concat(msg, sizeof(msg), "I change the suit to ", getSuitName(requestedSuit), ".", NULL);
printEvent(msg);
}
// Puts a card on the discarded deck and makes it the new displayed card.
// This function must be the only way to make a card the displayed card.
//
void discardCard(byte card)
{
assertf(card >= 1 && card <= NUMCARDS, "%u", card);
assertf(numDiscardedCards < NUMCARDS, "%u", numDiscardedCards);
discardDeck[numDiscardedCards++] = card;
displayedCard = card;
}
byte getPixelRowOfFirstCard(byte numCards, byte lastAdmissibleRow)
{
if (numCards > 30)
numCards = 30; // fallback
assertf(numCards <= NUMCARDS, "%u", numCards);
assertf(lastAdmissibleRow >= OVERLAY_HEIGHT && lastAdmissibleRow < PIXEL_ROWS_PER_SCREEN, "%u", lastAdmissibleRow);
byte numRowsUsed = (numCards + (CARDS_PER_ROW - 1)) / CARDS_PER_ROW;
assertf(numRowsUsed > 0 && numRowsUsed <= 2, "%u, %u", numRowsUsed, numCards);
byte row = lastAdmissibleRow - (numRowsUsed - 1) * OVERLAY_HEIGHT;
assertf(row < PIXEL_ROWS_PER_SCREEN, "%u", row);
return row;
}
// CARDS_PER_ROW is the max number of cards per screen row.
// OVERLAY_HEIGHT is used if more than one row necessary.
// Continue putting cards towards the top of the screen
// if continueUpwards is true, towards the bottom otherwise.
//
void drawHand(byte *hand, byte numCards, byte y, byte continueUpwards)
{
if (numCards == 0)
return;
if (numCards > 30)
numCards = 30; // fallback
y = getPixelRowOfFirstCard(numCards, y);
byte col = 0;
byte x = 0;
for (byte i = 0; i < numCards; ++i)
{
byte card = hand[i];
byte suit = getCardType(card);
byte val = getCardValue(card);
//printf("%2u. %2u %2u %2u ", i, card, suit, val);
drawCompiledCard(val, suit, x, y);
x += 2;
++col;
if (col == CARDS_PER_ROW) // if next card will be on a new row:
{
col = 0;
x = 0;
y += OVERLAY_HEIGHT;
}
}
}
void drawUserHand()
{
// Black out card region before drawing cards.
byte y = getPixelRowOfFirstCard(CARDS_PER_ROW << 1, USER_HAND_ROW);
word byteOffset = (word) y * BYTES_PER_SCREEN_ROW;
assertf(byteOffset < 0x1800, "%u", byteOffset);
memset(scrnBuffer + byteOffset, 0, 0x1800 - byteOffset);
drawHand(userHand, numUserCards, USER_HAND_ROW, TRUE);
}
// Show the given card sliding to the place of the displayed card.
//
void animatePlayedCard(byte card, byte isUsersTurn)
{
byte rowsPerCard = getNumPixelRowsPerCard();
byte val = getCardValue(card);
byte type = getCardType(card);
byte ticks = 15;
// Slide the card up or down.
//
byte col = DISPLAYED_CARD_COL - 5;
byte rowInc = (isUsersTurn ? -8 : 8);
byte row = DISPLAYED_CARD_ROW + (isUsersTurn ? +24 : -24);
for (byte i = 0; i < 4; ++i, row += rowInc)
{
drawCompiledCard(val, type, col, row);
optDelay(ticks);
// Blacken the bottom or top 8 pixel rows of the currently displayed card.
//
byte firstRowToBlacken = row;
if (isUsersTurn)
firstRowToBlacken += rowsPerCard - 8;
word *writer = (word *) (scrnBuffer + (word) firstRowToBlacken * BYTES_PER_SCREEN_ROW + col);
for (byte r = 8; r--; writer += WORDS_PER_SCREEN_ROW)
*writer = writer[1] = 0x0000;
}
ticks = 0;
// Slide to the right.
//
for ( ; col < DISPLAYED_CARD_COL; ++col)
{
drawCompiledCard(val, type, col, DISPLAYED_CARD_ROW);
optDelay(ticks);
ticks = 15;
// Blacken the left column of the currently displayed card.
//
byte *writer = scrnBuffer + (word) DISPLAYED_CARD_ROW * BYTES_PER_SCREEN_ROW + col;
for (byte i = rowsPerCard; i--; writer += BYTES_PER_SCREEN_ROW)
*writer = 0x00;
}
drawCompiledCard(val, type, col, DISPLAYED_CARD_ROW);
}
void drawDisplayedCard()
{
drawCompiledCard(getCardValue(displayedCard), getCardType(displayedCard), DISPLAYED_CARD_COL, DISPLAYED_CARD_ROW);
}
// Blackens the area where the "which suit" menu is drawn.
//
void clearSuitMenu()
{
byte *dest = scrnBuffer + ((word) EVENT_ROW * PIXEL_ROWS_PER_TEXT_ROW - 1) * BYTES_PER_SCREEN_ROW;
word numBytes = (word) BYTES_PER_SCREEN_ROW * ((word) ROWS_PER_SUIT * 2 + 2);
memset(dest, 0, numBytes);
}
// Returns whether the next player must pass their turn.
//
byte playCard(byte card, byte isUsersTurn)
{
animatePlayedCard(card, isUsersTurn);
discardCard(card);
drawDisplayedCard();
byte cardType = getCardType(card);
byte cardValue = getCardValue(card);
byte nextPlayerPasses = FALSE;
byte nextPlayerPicks = 0; // number of cards
byte changesRequestedSuit = FALSE;
// Determine the effects of the played card:
if (cardType != SUIT_JOKER)
{
if (cardValue == 2)
{
nextPlayerPasses = TRUE;
if (cardType == SUIT_SPADES)
nextPlayerPicks = 4;
else
nextPlayerPicks = 2;
}
else if (cardValue == 8)
changesRequestedSuit = TRUE;
else if (cardValue == 11)
nextPlayerPasses = TRUE;
}
else
{
nextPlayerPasses = TRUE;
nextPlayerPicks = 5;
changesRequestedSuit = TRUE;
}
// Apply the effects of the played card.
if (nextPlayerPicks)
{
char msg[33], s[11]; // argument of dwtoa() MUST have at least 11 bytes
concat(msg, sizeof(msg),
isUsersTurn ? "You" : "I",
" make ",
isUsersTurn ? "me" : "you",
" pick ",
dwtoa(s, 0, nextPlayerPicks),
" card",
nextPlayerPicks > 1 ? "s." : ".",
NULL);
assertf(strlen(msg) < sizeof(msg), "%u", strlen(msg));
printEvent(msg);
for ( ; nextPlayerPicks; --nextPlayerPicks)
{
if (numCardsMainDeck == 0)
reshuffle();
if (numCardsMainDeck == 0)
break;
byte pickedCard = pickCardFromMainDeck();
if (isUsersTurn)
computerHand[numComputerCards++] = pickedCard;
else
{
insertCardInDisplayOrder(userHand, numUserCards, pickedCard);
++numUserCards;
}
}
}
if (nextPlayerPasses)
{
if (isUsersTurn)
printEvent("You make me pass a turn.");
else
printEvent("I make you pass a turn.");
}
// If the card just played allows its player to change the requested suit,
// but no player has won yet, then let the player choose a suit.
// If a player has won, don't bother: the caller is expected to end the game.
//
if (changesRequestedSuit && numUserCards > 0 && numComputerCards > 0)
{
if (isUsersTurn)
{
// Redraw the user hand and the displayed card so that
// the screen shows the 8 or joker has been played.
//
drawUserHand();
drawDisplayedCard();
// Draw a menu of suits to choose from.
//
printEvent("Which suit? H S D C ");
for (byte suit = 0; suit < 4; ++suit)
drawSuit(14 + suit * 5, EVENT_ROW * PIXEL_ROWS_PER_TEXT_ROW, suit);
// Process keyboard input.
//
for (;;)
{
char c = (autoMode ? 'H' : (char) toupper(waitkey(FALSE)));
if (c == 'H')
requestedSuit = SUIT_HEARTS;
else if (c == 'S')
requestedSuit = SUIT_SPADES;
else if (c == 'D')
requestedSuit = SUIT_DIAMONDS;
else if (c == 'C')
requestedSuit = SUIT_CLUBS;
else
continue;
break;
}
clearSuitMenu();
}
else
chooseComputerSuit();
}
else
requestedSuit = cardType;
return nextPlayerPasses;
}
/* Utility function to draw a horizontal line.
void drawPixelRow(byte y, byte byteToWrite)
{
byte *row = scrnBuffer + (word) y * BYTES_PER_SCREEN_ROW;
for (int i = BYTES_PER_SCREEN_ROW; i--; )
*++row = byteToWrite;
}
*/
void drawStatus()
{
byte statusRow = STATUS_ROW;
moveCursor(STATUS_COL, statusRow);
printf("Computer:");
moveCursor(STATUS_COL, ++statusRow);
if (numComputerCards == 0)
printf("no cards");
else
printf("%u card%s ", numComputerCards, numComputerCards > 1 ? "s" : "");
moveCursor(DECK_COL + 1, (DECK_ROW >> 3) + 3);
printf("%2u", numCardsMainDeck);
}
void drawAllCards()
{
drawUserHand();
drawDisplayedCard();
byte requestedCol = REQUESTED_SUIT_COL;
byte requestedRow = REQUESTED_SUIT_ROW;
moveCursor(requestedCol, requestedRow);
printf("Requested:");
drawSuit(requestedCol + 3, ((requestedRow + 1) << 3) + 2, requestedSuit);
drawStatus();
}
#define NUM_CURSOR_ROWS 4
word savedBG[NUM_CURSOR_ROWS];
word *cursorAddr;
// Changes cursorAddr and saves the new cursor background in savedBG[].
// selectedCardIndex: Must be < numUserCards.
//
void computeCursorAddress(byte selectedCardIndex)
{
byte cursorByteCol = (selectedCardIndex % CARDS_PER_ROW) << 1;
byte rowOfFirstCard = getPixelRowOfFirstCard(numUserCards, USER_HAND_ROW);
byte cursorPixelRow = rowOfFirstCard + selectedCardIndex / CARDS_PER_ROW * OVERLAY_HEIGHT + 1;
assertf(cursorPixelRow < PIXEL_ROWS_PER_SCREEN, "%u", cursorPixelRow);
cursorAddr = (word *) (scrnBuffer + (word) cursorPixelRow * BYTES_PER_SCREEN_ROW + (word) cursorByteCol);
assertf(cursorAddr >= scrnBuffer && cursorAddr < scrnBuffer + BYTES_PER_SCREEN, "%p, %p", cursorAddr, scrnBuffer);
for (byte i = 0; i < NUM_CURSOR_ROWS; ++i)
savedBG[i] = cursorAddr[((word) i) << 4];
}
// Uses cursorAddr and savedBG.
//
void restoreCursorBG()
{
assertf(cursorAddr >= scrnBuffer && cursorAddr < scrnBuffer + BYTES_PER_SCREEN, "%p, %p", cursorAddr, scrnBuffer);
for (byte i = 0; i < NUM_CURSOR_ROWS; ++i)
cursorAddr[((word) i) << 4] = savedBG[i];
}
byte basicHelpShown; // is the H=HELP Q=QUIT prompt currently shown
void showBasicHelp()
{
if (basicHelpShown)
return;
moveCursor(1, REQUESTED_SUIT_ROW);
printf("H=help");
moveCursor(1, REQUESTED_SUIT_ROW + 1);
printf("Q=quit");
basicHelpShown = TRUE;
}
void hideBasicHelp()
{
if (! basicHelpShown)
return;
moveCursor(1, REQUESTED_SUIT_ROW);
putstr(" ", 6);
moveCursor(1, REQUESTED_SUIT_ROW + 1);
putstr(" ", 6);
basicHelpShown = FALSE;
}
void initPlayScreen()
{
pcls(0);
// Draw the deck as a face-down card.
//
moveCursor(DECK_COL, DECK_ROW >> 3);
printf("Deck");
drawFaceDownCard(DECK_ROW + PIXEL_ROWS_PER_TEXT_ROW, DECK_COL);
basicHelpShown = FALSE;
}
// Help lines must be at most 30 characters.
const char *helpLines0[] =
{
"",
"|" PROGRAM_FULL_NAME,
"|" "V" VERSION,
"",
"|" BY_LINE,
"|" COLOR_EIGHTS_URL,
"",
"",
"Derived from Crazy Eights.",
"",
"Left and right arrows: move",
"the cursor over your cards.",
"",
"SPACE: play the current card.",
"P: pick a card.",
"Q: quit the program.",
"",
"You cannot pick if one of your",
"cards is playable. If the card",
"picked is playable, it is",
"played.",
"",
"|" "Press [Space] to continue.",
0
};
const char *helpLines1[] =
{
"",
"An 8 changes the requested",
"suit.",
"",
"So does the joker, which also",
"makes the opponent pass their",
"turn and makes them pick five",
"cards.",
"",
"A 2 makes the opponent pass",
"their turn and pick 2 cards",
"(4 cards if it is a 2 of",
"spades).",
"",
"A jack makes the opponent",
"pass their turn.",
"",
"",
"",
"",
"",
"|" "Press [Space] to return",
"|" "to the game.",
0
};
// A line that starts with '|' gets centered instead of
// being left-justified.
//
void showTextLines(const char *lines[])
{
for (byte i = 0; lines[i]; ++i)
{
byte row = i;
if (row >= TEXT_ROWS_PER_SCREEN)
return;
const char *line = lines[i];
byte len = (byte) strlen(line);
byte col;
if (line[0] == '|') // if centered line
{
++line;
--len;
col = (TEXT_COLS_PER_ROW - len) / 2;
}
else
col = 1;
moveCursor(col, row);
putstr(line, len);
}
}
void waitForSpaceKey(void)
{
while (waitkey(FALSE) != ' ')
;
}
void showHelpScreen()
{
pcls(0);
showTextLines(helpLines0);
waitForSpaceKey();
pcls(0);
showTextLines(helpLines1);
waitForSpaceKey();
initPlayScreen();
drawAllCards();
}
void warnIfComputerLowOnCards()
{
byte writtenByte;
if (numComputerCards >= 3)
writtenByte = 0x00;
else
writtenByte = (getTimer() & 0x20 ? 0x00 : 0xAA); // blinking red line
// Point
byte *p = scrnBuffer + (STATUS_ROW + 2) * BYTES_PER_TEXT_ROW + STATUS_COL;
byte numBytes = (numComputerCards > 1 ? 7 : 6);
memset(p, writtenByte, numBytes);
}
void eraseLowCardWarning()
{
byte *p = scrnBuffer + (STATUS_ROW + 2) * BYTES_PER_TEXT_ROW + STATUS_COL;
memset(p, 0, 7);
}
byte selectedCardIndex = 0; // index in userHand[], must be < numUserCards
byte playUserTurn()
{
if (numUserCards == 0)
return NEXT_PLAYER_PLAYS; // failsafe
if (selectedCardIndex >= numUserCards)
selectedCardIndex = numUserCards - 1;
computeCursorAddress(selectedCardIndex); // init cursorAddr and resave background
word prevPattern = 0;
byte result = QUIT_GAME;
for (;;)
{
byte key = autoMode ? 'P' : (char) toupper(inkey());
if (key == '?' || key == 'H')
{
showHelpScreen();
continue;
}
if (key == 'Q')
{
hideBasicHelp();
restoreCursorBG();
clearEventRow(); // avoid delay that would occur if printEvent() called on non-empty event row
#ifdef CARTRIDGE_ROM
printEvent("Start a new game? (Y/N)");
#else
printEvent("Quit this program? (Y/N)");
#endif
byte key = (byte) toupper(waitkey(FALSE));
if (key != 'Y')
{
clearEventRow();
continue;
}
result = QUIT_GAME;
break;
}
if (key && eventRowUsed)
{
clearEventRow();
eventRowUsed = FALSE;
}
if (key == 'P') // if user picks
{
result = NEXT_PLAYER_PLAYS;
#ifndef ALWAYS_ALLOW_PICKING
if (atLeastOnePlayable(userHand, numUserCards))
{
printEvent("You are not allowed to pick.");
continue;
}
#endif
if (numCardsMainDeck == 0)
reshuffle();
if (numCardsMainDeck == 0)
{
hideBasicHelp();
restoreCursorBG();
printEvent("No more cards to be picked.");
if (!autoMode) waitkey(FALSE);
printEvent("Another game? (Y/N)");
byte key = autoMode ? 'Y' : (char) toupper(waitkey(FALSE));
return key == 'Y' ? PLAY_NEW_GAME : QUIT_GAME;
}
else
{
byte pickedCard = pickCardFromMainDeck();
selectedCardIndex = insertCardInDisplayOrder(userHand, numUserCards, pickedCard);
++numUserCards;
assertf(numUserCards <= NUMCARDS, "%u", numUserCards);
if (isPlayableCard(pickedCard))
{
key = ' '; // simulate manual selection on picked card
printEvent("You pick a card and play it.");
// Wait and clear, because the animation will draw over the event row.
optDelay(60);
clearEventRow();
}
else
{
printEvent("You pick a card: not playable.");
break;
}
}
}
if (key == ' ') // [Space] to play current card
{
assertf(numUserCards <= NUMCARDS, "%u", numUserCards);
assertf(selectedCardIndex < numUserCards, "%u", selectedCardIndex);
if (! isPlayableCard(userHand[selectedCardIndex]))
{
printEvent("This card cannot be played.");
continue;
}
hideBasicHelp();
restoreCursorBG();
// Take the card out of the user's hand:
byte selectedCard = userHand[selectedCardIndex];
for (byte j = selectedCardIndex + 1; j < numUserCards; ++j)
userHand[j - 1] = userHand[j];
--numUserCards;
drawUserHand();
byte computerPasses = playCard(selectedCard, TRUE);
if (numUserCards == 0)
{
#ifdef CARTRIDGE_ROM
printEvent("You win.");
waitkey(FALSE);
return PLAY_NEW_GAME;
#else
printEvent("You win. Another game? (Y/N)");
byte key = (byte) toupper(waitkey(FALSE));
return key == 'Y' ? PLAY_NEW_GAME : QUIT_GAME;
#endif
}
if (computerPasses)
result = NEXT_PLAYER_PASSES;
else
result = NEXT_PLAYER_PLAYS;
break;
}
if (key == 8 || key == 9) // if left or right arrow
{
restoreCursorBG();
if (key == 8) // if left
selectedCardIndex = (selectedCardIndex == 0 ? numUserCards - 1 : selectedCardIndex - 1);
else if (key == 9)
selectedCardIndex = (selectedCardIndex == numUserCards - 1 ? 0 : selectedCardIndex + 1);
assertf(selectedCardIndex < numUserCards, "%u, %u", selectedCardIndex, numUserCards);
computeCursorAddress(selectedCardIndex); // update cursorAddr and resave background
}
showBasicHelp(); // if not already shown
// Change cursor pattern a few times per second, using TIMER.
//
word curPattern = (getTimer() & 0x10) ? (word) 0x5555 : 0xAAAA;
if (curPattern != prevPattern)
{
word *dest = cursorAddr;
for (byte i = 0; i < NUM_CURSOR_ROWS; ++i)
{
*dest = curPattern;
dest += WORDS_PER_SCREEN_ROW;
}
prevPattern = curPattern;
}
warnIfComputerLowOnCards();
}
hideBasicHelp();
restoreCursorBG();
eraseLowCardWarning();
return result;
}
byte findSuitChangingCard(byte eightWanted)
{
assertf(numComputerCards < NUMCARDS, "%u", numComputerCards);
for (byte i = 0; i < numComputerCards; i++)
{
byte card = computerHand[i];
byte suit = getCardType(card);
if (eightWanted && suit != SUIT_JOKER && getCardValue(card) == 8)
return i;
if (!eightWanted && suit == SUIT_JOKER)
return i;
}
return BAD_INDEX;
}
/** Find a card of the appropriate suit in the computer's hand.
Does not choose a card whose value is 8 nor cards that are jokers.
@param suit requested suit (not SUIT_JOKER)
@param danger boolean that indicates that the computer
should give preference to cards that can
make the user pick cards and pass his turn
@returns an index into computerHand[], or 0xFF on failure
*/
byte findComputerCard(byte suit, byte danger)
{
byte maxScore = 0;
byte index = 0xFF;
byte i;
for (i = 0; i < numComputerCards; i++)
{
byte card = computerHand[i];
byte cardValue = getCardValue(card);
byte cardType = getCardType(card);
if (cardType == suit && cardValue != 8 && isPlayableCard(card))
{
byte score = 6;
if (cardValue == 2 || cardValue == 11)
{
score++;
if (cardValue == 2)
{
score += 2;
if (cardType == SUIT_SPADES)
score += 2;
}
}
// Here, score is expected to be between 6 and 11 inclusively.
if (!danger)
score = 12 - score;
if (score > maxScore)
{
maxScore = score;
index = i;
}
}
}
return index;
}
byte chooseComputerCard()
{
byte suitScores[4];
byte nbEights;
byte nbJokers;
byte bestSuit = evaluateHand(suitScores, &nbEights, &nbJokers,
computerHand, numComputerCards, TRUE);
assertf(bestSuit < 4, "%u", bestSuit);
byte danger = (numUserCards <= 4);
if (danger)
{
if (nbJokers > 0)
return findSuitChangingCard(FALSE);
if (suitScores[bestSuit] > 0)
return findComputerCard(bestSuit, TRUE);
if (nbEights > 0)
return findSuitChangingCard(TRUE);
}
else
{
if (suitScores[bestSuit] > 0)
return findComputerCard(bestSuit, FALSE);
if (nbEights > 0)
return findSuitChangingCard(TRUE);
if (nbJokers > 0)
return findSuitChangingCard(FALSE);
}
return 99; // pick
}
byte playComputerTurn()
{
optDelay(60);
byte index = chooseComputerCard();
if (index == 99)
{
if (numCardsMainDeck == 0)
reshuffle();
if (numCardsMainDeck == 0)
printEvent("No more cards to be picked.");
else
{
byte pickedCard = pickCardFromMainDeck();
assertf(numComputerCards < NUMCARDS, "%u", numComputerCards);
computerHand[numComputerCards++] = pickedCard;
if (isPlayableCard(pickedCard))
{
printEvent("I pick a card and play it.");
optDelay(60);
index = numComputerCards - 1;
}
else
{
printEvent("I pick a card: not playable.");
}
}
}
if (index == 99)
return NEXT_PLAYER_PLAYS;
// Take the card out of the computer's hand:
assertf(index < numComputerCards, "%u, %u", index, numComputerCards);
byte chosenCard = computerHand[index];
assertf(numComputerCards > 0 && index < NUMCARDS, "%u, %u", numComputerCards, index);
computerHand[index] = computerHand[--numComputerCards];
byte userPasses = playCard(chosenCard, FALSE);
if (numComputerCards == 0)
{
drawAllCards();
#ifdef CARTRIDGE_ROM
printEvent("I win.");
waitkey(FALSE);
return PLAY_NEW_GAME;
#else
printEvent("I win. Another game (Y/N)?");
byte key = autoMode ? 'Y' : (byte) toupper(waitkey(FALSE));
return key == 'Y' ? PLAY_NEW_GAME : QUIT_GAME;
#endif
}
if (userPasses)
return NEXT_PLAYER_PASSES;
return NEXT_PLAYER_PLAYS;
}
#define assertNumCards() assertf(numUserCards + numComputerCards + numCardsMainDeck + numDiscardedCards == NUMCARDS, \
"%u %u %u %u", numUserCards, numComputerCards, numCardsMainDeck, numDiscardedCards)
void eights()
{
for (;;)
{
initPlayScreen();
initDecks();
assertNumCards();
shuffleMainDeck();
assertNumCards();
// Initialize the two players' hands:
byte i;
for (i = 8; i > 0; i--)
{
insertCardInDisplayOrder(userHand, numUserCards, pickCardFromMainDeck());
++numUserCards;
computerHand[numComputerCards++] = pickCardFromMainDeck();
}
assertNumCards();
putOrdinaryCardOnTopOfDeck();
discardCard(pickCardFromMainDeck());
requestedSuit = getCardType(displayedCard);
if (requestedSuit == SUIT_JOKER)
requestedSuit = SUIT_HEARTS;
clearEventRow();
drawAllCards();
byte userPasses = FALSE;
byte code = NEXT_PLAYER_PLAYS;
for (;;)
{
assertNumCards();
if (userPasses)
{
code = NEXT_PLAYER_PLAYS;
}
else
{
code = playUserTurn();
if (code == QUIT_GAME || code == PLAY_NEW_GAME)
break;
drawAllCards();
}
assertNumCards();
if (code == NEXT_PLAYER_PASSES)
{
code = NEXT_PLAYER_PLAYS;
}
else
{
code = playComputerTurn();
if (code == QUIT_GAME || code == PLAY_NEW_GAME)
break;
drawAllCards();
userPasses = (code == NEXT_PLAYER_PASSES);
}
}
#ifndef CARTRIDGE_ROM // The cart version does not return from this function.
if (code == QUIT_GAME)
return;
#endif
}
}
///////////////////////////////////////////////////////////////////////////////
// Returns the key pressed by the user to start the game.
//
byte showPresentation()
{
byte row = 0;
printCentered(++row, PROGRAM_FULL_NAME);
++row;
++row;
printCentered(++row, BY_LINE);
++row;
++row;
printCentered(++row, "Version " VERSION); // this statement defines the version number
printCentered(++row, "Copyright (C) 2003-2024");
++row;
printCentered(++row, COLOR_EIGHTS_URL);
printCentered(TEXT_ROWS_PER_SCREEN - 2, "Press [Space] to start.");
// Wait for a key while drawing the 8 card in different suits.
//
word origTimer = getTimer();
setTimer(0);
byte key = 0;
for (byte prevSuit = SUIT_NONE; key != ' '; key = inkey())
{
byte curSuit = (byte) ((getTimer() & 0x00C0) >> 6);
if (curSuit != prevSuit)
{
drawCompiledCard(8, curSuit, 14, 108);
prevSuit = curSuit;
}
}
setTimer(getTimer() + origTimer); // allows use of original timer for srand() seed
return key;
}
asm void printUpperCase(const char *str)
{
#if 0 // Original code:
for ( ; *str; ++str)
putchar(toupper(*str));
#else
asm
{
ldx 2,s // str (not using U because of 'asm' on function definition)
bra printUpperCase_cond
printUpperCase_loop
cmpa #97 // 'a'
blo printUpperCase_putchar
cmpa #122 // 'z'
bhi printUpperCase_putchar
suba #32 // to upper-case
printUpperCase_putchar
#ifndef CMOC_MONOLITH
CHROUT IMPORT
#endif
jsr [CHROUT,PCR]
printUpperCase_cond
lda ,x+ // get char
bne printUpperCase_loop // loop if not end of string
printUpperCase_end
}
#endif
}
#ifdef CHECK_NULL
void nullPointerHandler(char *addressOfFailedCheck)
{
moveCursor(0, 0);
printf("*** NULL AT %p ***", addressOfFailedCheck);
for (;;)
;
}
#endif
int main()
{
#ifdef CARTRIDGE_ROM
asm
{
// We come here from a JMP $C000 in Color Basic (normally at $A10A in v1.2).
// At this point, the 60 Hz interrupt has not been enabled yet, so enable it.
lda $ff03 // get control register of PIA0, port B
ora #1
sta $ff03 // enable 60 Hz interrupt
// Unmask interrupts to allow the timer IRQ to be processed.
andcc #$af
}
#endif
void *screenBuffer;
#ifdef OS9
{
byte err = OS9Timer_init(1); // increment a counter at every 60 Hz tick
if (err != 0)
{
printf("FAILED TO INIT OS-9 TIMER: ERROR #%u\n", err);
return 1;
}
}
Keyboard_init(&keyboard);
screenBuffer = NULL;
#else
screenBuffer = (void *) (((word) * (byte *) 0x00BC) << 8);
#endif
openCardGame(screenBuffer, TRUE);
#ifdef CHECK_NULL
// Install a null pointer handler. It will only be called if this program
// is compiled with --check-null -DCHECK_NULL=1
//
set_null_ptr_handler(nullPointerHandler);
#endif
byte key = showPresentation();
word seed = getTimer();
#if 0 // For debugging: pressing S uses fixed seed.
if (toupper(key) == 'S')
seed = 1;
#endif
srand(seed);
pcls(0);
eights();
closeCardGame();
#ifndef OS9
screen(0, 0); // text mode
cls(255);
printf("THANK YOU FOR PLAYING\nCOLOR EIGHTS.\n\n"
"VERSION: " VERSION "\n"
"COPYRIGHT 2003-23\n\n");
printUpperCase(COLOR_EIGHTS_URL);
printf("\n\n");
#else
putstr("\x12\x0E", 2); // End Graphics, Display Alpha (text mode)
#endif
//printf("SEED WAS %u.\n", seed);
#ifdef OS9
Keyboard_shutdown(&keyboard);
{
byte err = OS9Timer_shutdown();
if (err != 0)
{
printf("FAILED TO CLOSE OS-9 TIMER: ERROR #%u\n", err);
return 1;
}
}
#endif
return 0;
}