-         

Ergebnis 1 bis 5 von 5

Thema: RP6: Sammlung von Spielen und anderen Mini-Programmen

  1. #1
    Erfahrener Benutzer Robotik Einstein Avatar von Dirk
    Registriert seit
    30.04.2004
    Ort
    NRW
    Beiträge
    3.791

    RP6: Sammlung von Spielen und anderen Mini-Programmen

    Anzeige

    Hallo Leute,

    bei mir gibt es immer mal wieder kleinere Spiele oder Mini-Programme, die ich mit der RP6Base, der RP6Control M32, der CCPro M128 oder der RP6 Control M256 WiFi umsetze - "just for fun".

    Diese Progrämmchen haben nichts mit dem Roboter an sich zu tun, sondern sollen nur zeigen, was sonst noch mit der Hardware machbar ist.

    Deshalb mache ich hier mal einen "Spiele-Miniprogramme-Thread" auf. Die Spiele sollten keine zusätzliche Hardware brauchen,- und wenn doch, kann man die natürlich hier auch vorstellen.

    In diesem Thread gibt es schon 2 kleine Spiele bzw. Simulationen:
    http://www.roboternetz.de/community/...s-Game-Of-Life

    Wenn ihr auch eigene kleine Progrämmchen einstellen wollt, aktualisiere ich für jedes neue Programm diese Liste:

    1. Conway's Game Of Life --- Das Spiel des Lebens auf Zellebene
    2. Doc Z --- Ein Mini-Psychiater
    3. Kalaha --- Ein altes "Bohnenspiel"
    4. Oware --- Eines der ältesten Spiele der Welt
    5. Merry Christmas --- Alle Jahre wieder ...
    6. Chess --- Schach, das königliche Spiel
    Geändert von Dirk (03.01.2014 um 22:32 Uhr) Grund: Aktualisierung
    Gruß
    Dirk

  2. #2
    Erfahrener Benutzer Robotik Einstein Avatar von Dirk
    Registriert seit
    30.04.2004
    Ort
    NRW
    Beiträge
    3.791

    RP6Control M32: Kalaha

    Hier das Spiel Kalaha.

    Infos dazu: http://de.wikipedia.org/wiki/Kalaha

    Code:
    /* 
     * ****************************************************************************
     * RP6 ROBOT SYSTEM - RP6 CONTROL M32 TESTS
     * ****************************************************************************
     * Example: Kalaha
     * Author(s): Dirk
     * ****************************************************************************
     * Description:
     * This program for RP6 Control plays the old game Kalaha, invented by William
     * Julius Champion Jr in 1940.
     *
     * Rules:
     * Kalaha is usually played on a board with two rows of 6 flat deepenings
     * (called field or house) and two more bigger deepenings (called kalah, home
     * or store) on the left and right end of the two rows.
     * Both players are normally sitting opposite. The 12 fields in two rows are
     * filled with 3 seeds or other small things (like beans, stones ...). Each
     * player controls the six fields next to him and the home field to his right.
     *
     * Alternately each player decides to take all seeds out of ONE of the 6
     * fields of his row. Moving counter-clockwise, he drops one seed in each
     * field in turn, including the player's own home but not his opponent's.
     * If the last seed is sawn into the player's own home, he gets to go again.
     * There is no limit on the number of moves a player can make in his turn.
     * If the last seed is dropped into an empty field owned by the player, he
     * gains the last seed and all of the seeds in the field directly opposite
     * the one he ended in, and all of those seeds are moved into his home. When
     * one side runs out of seeds, the other player moves all seeds from his
     * fields into his home and whoever has the most in his home wins.
     *
     * Variations:
     * - Starting the game with four, five or six seeds in each field.
     * - The "Empty Capture" variant modifies the rules to prohibit a player from
     *   capturing seeds from his opponent when landing in an empty field - i.e.,
     *   only the last dropped seed is placed into the home.
     * - Not counting the remaining seeds as part of the opponent's score at the
     *   end of the game. 
     *
     * You will find further information here:
     *    http://en.wikipedia.org/wiki/Kalah
     *
     * ############################################################################
     * The Robot does NOT move in this example! You can simply put it on a table
     * next to your PC and you should connect it to the PC via the USB Interface!
     * ############################################################################
     * ****************************************************************************
     */
    /*****************************************************************************/
    // Includes:
    #include "RP6ControlLib.h"   // The RP6 Control Library (1.3beta or higher). 
            // Always needs to be included!
    /*****************************************************************************/
    // Defines:
    // Number of fields (Default: 6, Range: 2..11):
    #define MAXFIELDS   6
    // Seeds in each field (Default: 3, Range: 2..11):
    #define MAXSEEDS   3
    // 4 seeds in each field:
    //#define MAXSEEDS   4
    // 5 seeds in each field:
    //#define MAXSEEDS   5
    // 6 seeds in each field:
    //#define MAXSEEDS   6
    // Show rules:
    #define SHOW_RULES
    // -------------------------------------------------------
    // Highest index of field[]:
    #define MAXINDEX   (MAXFIELDS * 2 + 1)
    // Index of home field 1:
    #define KALAH1    MAXFIELDS
    // Index of home field 2:
    #define KALAH2    MAXINDEX
    // Number of seeds / 2 (Tie):
    #define TIE     (MAXSEEDS * MAXFIELDS)
    // Constants for gamemode:
    #define PLAYER_PLAYER  0
    #define COMPUTER_PLAYER  1
    #define COMPUTER_COMPUTER 2
    // Output delay (ms):
    #define WAIT_MS    1000
    #define WAITDEMO_MS   2000
    // -------------------------------------------------------
    // Variations:
    // "Empty Capture" variation:
    //#define EMPTY_CAPTURE
    // Don't count the opponent's seeds at the end of the game:
    //#define REMAINING_SEEDS
    /*****************************************************************************/
    // Variables:
    // Reception buffer for the function getInputLine():
    char receiveBuffer[UART_RECEIVE_BUFFER_SIZE + 1];
    uint8_t field[MAXINDEX + 1];
    uint8_t firstmove;
    uint16_t pause_ms;
    uint8_t gamemode;
    uint8_t turn;
    uint8_t move;
    uint8_t winner;
    uint8_t winner1;
    uint8_t winner2;
    /*****************************************************************************/
    // Functions:
    // UART receive functions:
    /**
     * Get chars of an input line from the UART.
     *
     * Returns 0 (false), if the UART receive buffer is empty
     * OR a character of the input line has been received.
     * Returns 1, if the whole input line has been received
     * (with a "new line" character at the end).
     * Returns 2, if the UART receive buffer overflows.
     * The input line is stored in the receiveBuffer array.
     *
     */
    uint8_t getInputLine(void)
    {static uint8_t buffer_pos = 0;
     if(getBufferLength()) { 
      receiveBuffer[buffer_pos] = readChar();
      if(receiveBuffer[buffer_pos] == '\n') {
       receiveBuffer[buffer_pos] = '\0';
       buffer_pos = 0;
       return 1;
      }
      else if(buffer_pos >= UART_RECEIVE_BUFFER_SIZE) {
       receiveBuffer[UART_RECEIVE_BUFFER_SIZE] = '\0'; 
       buffer_pos = 0;
       return 2;
      }
      buffer_pos++;
     }
     return 0;
    }
    /**
     * Get a complete input line from the UART.
     *
     * This function waits for a whole input line from the UART.
     * The input line is stored in the receiveBuffer array.
     * The function is blocking until one of the two following
     * conditions occurs:
     * - A "new line" character has been received at the end of
     *   the input line.
     * - The UART receive buffer overflows.
     *
     */
    void enterString(void)
    {
     while(!getInputLine());
    }
    /**
     * GET SEED
     *
     * Gets a starting value for srand().
     *
     */
    uint16_t get_seed(void)
    {
     uint16_t seed = 0;
     uint16_t *p = (uint16_t*) (RAMEND + 1);
     extern uint16_t __heap_start;
     while (p >= &__heap_start + 1)
      seed ^= * (--p);
     return seed;
    }
    /**
     * WRITE 6 SPACES
     *
     * Sends 6 spaces for each field via UART (used by showBoard).
     *
     */
    void write6Spaces(void)
    {
     uint8_t i;
     for (i = 0; i < KALAH1; i++) {
      writeString_P("      ");
     }
    }
    /**
     * SHOW BOARD
     *
     * Shows the Kalaha board in field[] on the terminal.
     *
     */
    void showBoard(void)
    {
     uint8_t i;
     writeString_P("\n  -2-  ");
     for (i = KALAH1; i > 0; i--) {
      writeString_P("[F");
      writeIntegerLength(i, DEC, 2);    // Player 2 fields
      writeString_P("] ");
     }
     writeString_P(" -2-\n");
     writeString_P("      < ");
     for (i = (KALAH2 - 1); i > KALAH1; i--) {
      writeIntegerLength(field[i], DEC, 3);  // Player 2 side
      writeString_P(" < ");
     }
     writeChar('\n');
     writeString_P("    v   ");
     write6Spaces();
     writeString_P("^\n");
     writeString_P("   v    ");
     write6Spaces();
     writeString_P(" ^\n");
     writeString_P("  ");
     writeIntegerLength(field[KALAH2], DEC, 3);  // Player 2 result
     writeString_P("   ");
     write6Spaces();
     writeIntegerLength(field[KALAH1], DEC, 3);  // Player 1 result
     writeString_P("\n   v    ");
     write6Spaces();
     writeString_P(" ^\n");
     writeString_P("    v   ");
     write6Spaces();
     writeString_P("^\n");
     
     writeString_P("      > ");
     for (i = 0; i < KALAH1; i++) {
      writeIntegerLength(field[i], DEC, 3);  // Player 1 side
      writeString_P(" > ");
     }
     writeChar('\n');
     writeString_P("  -1-  ");
     for (i = 1; i <= KALAH1; i++) {
      writeString_P("[F");
      writeIntegerLength(i, DEC, 2);    // Player 1 fields
      writeString_P("] ");
     }
     writeString_P(" -1-\n");
    }
    /**
     * INIT FIELD ARRAY
     *
     * Initialises the field array.
     *
     */
    void initFieldArray(void)
    {
     uint8_t i;
     for (i = 0; i <= MAXINDEX; i++) {
      field[i] = MAXSEEDS;
     }
     field[KALAH1] = 0;   // Result field 1
     field[KALAH2] = 0;   // Result field 2
    }
    /**
     * CALCULATE MOVE
     *
     * Calculates each move. The variable move contains the actual
     * field index to be processed in field[]. After the calculation
     * field[] contains the new field (board). The variable turn
     * determines the next player (1/2) or the victory condition (0).
     *
     */
    void calculateMove(void)
    {
     uint8_t actualmove;
     uint8_t resultfield;
     uint8_t I;
     uint8_t fieldindex;
    #ifndef REMAINING_SEEDS
     uint8_t seeds;
    #endif
     // Calculate a move:
     actualmove = move;
     if ((turn == 0) || (field[actualmove] == 0)) return;
     if (turn == 1) resultfield = KALAH1;
     if (turn == 2) resultfield = KALAH2;
     fieldindex = actualmove;
     do {
      actualmove += 1;
      if (actualmove > MAXINDEX) actualmove = 0;
      // Jump over the opponent's result field:
      if ((actualmove == KALAH1) && (resultfield != KALAH1)) {
       actualmove += 1;
      }
      if ((actualmove == KALAH2) && (resultfield != KALAH2)) {
       actualmove = 0;
      }
      field[actualmove] += 1;
      field[fieldindex] -= 1;
     } while (field[fieldindex] > 0);
     // Calculate the "special case":
     // Special case: Last seed drops into an empty field of the actual
     //               player and the opposite field is not empty
     if (((resultfield == KALAH1) && (actualmove < KALAH1))
      || ((resultfield == KALAH2) && (actualmove > KALAH1))) {
      if ((field[actualmove] == 1) && (actualmove != KALAH2)
       && (field[MAXINDEX - 1 - actualmove] > 0)) {
       field[actualmove] = 0;
       field[resultfield] += 1;
    #ifndef EMPTY_CAPTURE
       field[resultfield] += field[MAXINDEX - 1 - actualmove];
       field[MAXINDEX - 1 - actualmove] = 0;
    #endif
      }
     }
     // Test the victory conditions:
     // Continue playing, if own fields are not empty:
     fieldindex = 0;
    #ifndef REMAINING_SEEDS
     seeds = 0;
    #endif
     for (I = 0; I < MAXFIELDS; I++) {
      if (field[resultfield - KALAH1 + I] > 0) fieldindex = 1;
    #ifndef REMAINING_SEEDS
      seeds += field[KALAH2 - resultfield + I];
    #endif
     }
     if (fieldindex == 1) {
      if (actualmove == resultfield) return; // Once more (extra move)
     }
     else {
      turn = 0;   // No more seeds: End of game
    #ifndef REMAINING_SEEDS
      field[KALAH1 + KALAH2 - resultfield] += seeds;
      for (I = 0; I < MAXFIELDS; I++) {
       field[KALAH2 - resultfield + I] = 0;
      }
    #endif
      return;
     }
     // Change player, if his fields are not empty:
     fieldindex = 0;
    #ifndef REMAINING_SEEDS
     seeds = 0;
    #endif
     for (I = 0; I < MAXFIELDS; I++) {
      if (field[KALAH2 - resultfield + I] > 0) fieldindex = 1;
    #ifndef REMAINING_SEEDS
      seeds += field[resultfield - KALAH1 + I];
    #endif
     }
     if (fieldindex == 1) {
      turn = 3 - turn; // Change player
     }
     else {
      turn = 0;   // No more seeds: End of game
    #ifndef REMAINING_SEEDS
      field[KALAH1 + KALAH2 - resultfield] += seeds;
      for (I = 0; I < MAXFIELDS; I++) {
       field[resultfield - KALAH1 + I] = 0;
      }
    #endif
     }
    }
    /**
     * SHOW MOVE
     *
     * Shows the actual move (board) on the terminal and displays
     * the victory message at the end of a game.
     *
     */
    void showMove(void)
    {
     mSleep(1000);
     showBoard();   // Show fields
     if (turn != 0) {
      mSleep(pause_ms); // Pause the output for (pause_ms) ms
      return;
     }
     if (field[KALAH1] > field[KALAH2]) {
      writeString_P("\nSpieler/Computer 1 hat gewonnen!");
      winner = 1;
      winner1++;
     }
     if (field[KALAH1] < field[KALAH2]) {
      writeString_P("\nSpieler/Computer 2 hat gewonnen!");
      winner = 2;
      winner2++;
     }
     if (field[KALAH1] == field[KALAH2]) {
      writeString_P("\nUnentschieden!");
      winner = 0;
     }
     writeString_P(" Spielende.\n");
     writeString_P("\nSpielstand: ");
     writeInteger(winner1, DEC);
     writeString_P(" : ");
     writeInteger(winner2, DEC);
     writeString_P(" !\n");
    }
    /**
     * COMPUTER 1 MOVE
     *
     * Calculates the computer 1 move in the actual field[].
     * After processing the variable move contains the field
     * index of the new computer 1 move. This function calls
     * calculateMove() and displays a text informing about
     * the move.
     *
     */
    void computer1Move(void)
    {
    uint8_t I, J;uint8_t movefield;uint8_t fieldindex;do {I = rand() % KALAH1;
    } while (field[I] == 0);movefield = I;for (I = (MAXINDEX - 2); I > KALAH1;
    I--) {if (field[I] > 0) {fieldindex = I + field[I];if (fieldindex >= KALAH2)
    continue;if (field[fieldindex] == 0) {if (field[MAXINDEX - 1 - fieldindex] > 0)
    {movefield = MAXINDEX - 1 - fieldindex; break;}}}}for (I = KALAH1; I > 0; I--)
    {J = I - 1; if (field[J] > 0) {fieldindex = J + field[J];if (fieldindex >
    KALAH1) {movefield = J;break;}}}for (I = (KALAH1 - 1); I > 0; I--) {J = I - 1;
    if (field[J] > 0) {fieldindex = J + field[J];if (fieldindex >= KALAH1)
    continue;if (field[fieldindex] == 0) {if (field[MAXINDEX - 1 - fieldindex] > 0)
    {movefield = J;break;}}}}for (I = KALAH1; I > 0; I--) {J = I - 1;if (field[J]
    > 0) {fieldindex = J + field[J];if (fieldindex == KALAH1) {movefield = J;
    break;}}}move = movefield;calculateMove();writeString_P("\nComputer 1: Zieht Feld ");
    writeInteger((move + 1), DEC);writeString_P(".\n");}
    /**
     * COMPUTER 2 MOVE
     *
     * Calculates the computer 2 move in the actual field[].
     * After processing the variable move contains the field
     * index of the new computer 2 move. This function calls
     * calculateMove() and displays a text informing about
     * the move.
     *
     */
    void computer2Move(void)
    {
    uint8_t I, J;uint8_t movefield;uint8_t fieldindex;do {I = rand() % KALAH1 +
    KALAH1 + 1;} while (field[I] == 0);movefield = I;for (I = (KALAH1 - 1); I > 0;
    I--) {J = I - 1;if (field[J] > 0) {fieldindex = J + field[J];if (fieldindex
    >= KALAH1) continue;if (field[fieldindex] == 0) {if (field[MAXINDEX - 1 -
    fieldindex] > 0) {movefield = MAXINDEX - 1 - fieldindex;break;}}}} for (I =
    (MAXINDEX - 1); I > KALAH1; I--) {if (field[I] > 0) {fieldindex = I +
    field[I];if (fieldindex > MAXINDEX) {movefield = I;break;}}}for (I =
    (MAXINDEX - 2); I > KALAH1; I--) {if (field[I] > 0) {fieldindex = I +
    field[I];if (fieldindex >= MAXINDEX) continue;if (field[fieldindex] == 0) {
    if (field[MAXINDEX - 1 - fieldindex] > 0) {movefield = I;break;}}}}for (I =
    (MAXINDEX - 1); I > KALAH1; I--) {if (field[I] > 0) {fieldindex = I +
    field[I];if (fieldindex == MAXINDEX) {movefield = I;break;}}}move = movefield;
    calculateMove();writeString_P("\nComputer 2: Zieht Feld ");writeInteger((move
    - KALAH1), DEC);writeString_P(".\n");}
    /**
     * PLAYER 1 MOVE
     *
     * Player 1 move. The function asks for the move of player 1.
     * The player enters a number from 1 to KALAH1 to select one
     * of his fields. This function calls calculateMove().
     *
     */
    void player1Move(void)
    {
     uint8_t movefield = KALAH1;
     writeString_P("\nSpieler 1: Dein Zug (Feld 1..");
     writeInteger(movefield, DEC);
     writeString_P(")?\n");
     do {
      enterString();
      if (receiveBuffer[1] == '\0') {
       movefield = receiveBuffer[0] - 49;
      }
      else {
       if (receiveBuffer[2] == '\0') {
        movefield = (receiveBuffer[0] - 48) * 10 + receiveBuffer[1] - 49;
       }
      }
     }
     while ((movefield >= KALAH1) || (field[movefield] == 0));
     firstmove = 0;
     move = movefield; // 0..(KALAH1 - 1)
     calculateMove();
    }
    /**
     * PLAYER 2 MOVE
     *
     * Player 2 move. The function asks for the move of player 2.
     * The player enters a number from 1 to KALAH1 to select one
     * of his fields. This function calls calculateMove().
     *
     */
    void player2Move(void)
    {
     uint8_t movefield = KALAH1;
     writeString_P("\nSpieler 2: Dein Zug (Feld 1..");
     writeInteger(movefield, DEC);
     writeString_P(")?\n");
     do {
      enterString();
      if (receiveBuffer[1] == '\0') {
       movefield = receiveBuffer[0] - 48 + KALAH1;
      }
      else {
       if (receiveBuffer[2] == '\0') {
        movefield = (receiveBuffer[0] - 48) * 10 + receiveBuffer[1] - 48 + KALAH1;
       }
      }
     }
     while ((movefield <= KALAH1) || (movefield >= KALAH2)
      || (field[movefield] == 0));
     firstmove = 0;
     move = movefield; // (KALAH1 + 1)..(KALAH2 - 1)
     calculateMove();
    }
    /**
     * PLAYER V PLAYER
     *
     * Player 2 against player 1. Function only ends, if turn == 0.
     *
     */
    void playerVplayer(void)
    {
     do {
      while (turn == 1) {
       player1Move();
       showMove();
      };
      while (turn == 2) {
       player2Move();
       showMove();
      };
     } while (turn != 0);
    }
    /**
     * COMPUTER V PLAYER
     *
     * Computer 2 against player 1. Function only ends, if turn == 0.
     *
     */
    void computerVplayer(void)
    {
     do {
      while (turn == 1) {
       player1Move();
       showMove();
      };
      while (turn == 2) {
       computer2Move();
       showMove();
      };
     } while (turn != 0);
    }
    /**
     * COMPUTER DEMO
     *
     * Computer 2 against computer 1. Function only ends, if turn == 0.
     *
     */
    void computerDemo(void)
    {
     pause_ms = WAITDEMO_MS;
     do {
      while (turn == 1) {
       computer1Move();
       showMove();
      };
      while (turn == 2) {
       computer2Move();
       showMove();
      };
     } while (turn != 0);
     pause_ms = WAIT_MS;
    }
    /**
     * NEW GAME
     *
     * Performs a new Kalaha game. Function only ends, if turn == 0.
     *
     */
    void newGame(void)
    {
     // Initialisation:
     pause_ms = WAIT_MS;
     if (!gamemode) {
      gamemode = COMPUTER_PLAYER; // Default mode -> Player : Computer
     }
     turn = rand() % 2 + 1;  // Default: Random player or computer begins or
     if (winner) turn = winner; //  the last winning player or computer begins
     firstmove = 1;    // First move of a game
     // Menu:
     writeString_P("\n\n****** Kalaha Version 1.0 ******\n");
    #ifdef SHOW_RULES
     writeString_P("Spielregeln:\n");
     writeString_P("Das Kalaha-Spielbrett besteht aus zwei Muldenreihen mit\n");
     writeString_P("jeweils sechs Spielmulden. Außerdem befindet sich an\n");
     writeString_P("jedem Ende eine große Gewinnmulde, auch Kalah genannt,\n");
     writeString_P("welche im Spiel die gefangenen Samen aufnimmt.\n");
     writeString_P("Jedem Spieler gehören die sechs Spielmulden auf seiner\n");
     writeString_P("Seite des Brettes und die rechts von ihm gelegene Ge-\n");
     writeString_P("winnmulde.\n");
     writeString_P("Vorbereitung: Zu Beginn des Spiels werden alle Spiel-\n");
     writeString_P("mulden mit jeweils drei Samen gefüllt. Gewöhnlich fängt\n");
     writeString_P("der letzte Sieger das neue Spiel an.\n");
     writeString_P("Das Ziel des Spiels ist es, mehr Samen zu sammeln als\n");
     writeString_P("der Gegner. Da es nur 36 Samen gibt, reichen 19, um das\n");
     writeString_P("zu erreichen. Da es eine gerade Anzahl an Samen gibt,\n");
     writeString_P("ist ein Unentschieden möglich, wenn beide Spieler am\n");
     writeString_P("Ende 18 Samen ihr Eigen nennen.\n");
     writeString_P("Spielrunde: Die beiden Spieler sind abwechselnd am Zug.\n");
     writeString_P("Der Spieler entscheidet sich für eine seiner sechs\n");
     writeString_P("Spielmulden, nimmt alle Samen heraus und veteilt sie\n");
     writeString_P("einzeln gegen den Uhrzeigersinn (links herum) auf die\n");
     writeString_P("folgenden Spielmulden einschließlich der eigenen Ge-\n");
     writeString_P("winnmulde, aber mit Ausnahme der gegnerischen Gewinn-\n");
     writeString_P("mulde.\n");
     writeString_P("Fällt der letzte Samen in die eigene Gewinnmulde, be-\n");
     writeString_P("kommt der Spieler eine Extra-Runde, d.h. er darf erneut\n");
     writeString_P("ziehen. Dies kann auch mehrfach vorkommen.\n");
     writeString_P("Fangen: Wenn der letzte Samen in einer leeren Spiel-\n");
     writeString_P("mulde des aktiven Spielers landet und direkt gegenüber\n");
     writeString_P("in der gegnerischen Mulde Samen liegen, sind sowohl der\n");
     writeString_P("letzte Samen als auch die gegenüberliegenden Samen ge-\n");
     writeString_P("fangen und werden zu den eigenen Samen in die Gewinn-\n");
     writeString_P("mulde gelegt.\n");
     writeString_P("Spielende: Wenn ein Spieler an der Reihe ist, jedoch\n");
     writeString_P("alle seine Spielmulden leer sind, ist das Spiel be-\n");
     writeString_P("endet.\n");
     writeString_P("Der Gegner leert seine Spielmulden ebenfalls und legt\n");
     writeString_P("die Samen in seine Gewinnmulde. Gewinner ist, wer die\n");
     writeString_P("meisten Samen in seiner Gewinnmulde hat.\n\n");
     writeString_P("Weitere Informationen kann man hier finden:\n");
     writeString_P("   http://de.wikipedia.org/wiki/Kalaha\n");
    #endif
     writeString_P("\nWelches Spiel willst du spielen?\n");
     writeString_P(" -1-  Spieler : Spieler\n");
     writeString_P(" -2-  Spieler : Computer\n");
     writeString_P(" -3- Computer : Computer (Demo)\n");
     enterString();
     if (receiveBuffer[0] == '1') gamemode = PLAYER_PLAYER;
     if (receiveBuffer[0] == '2') gamemode = COMPUTER_PLAYER;
     if (receiveBuffer[0] == '3') gamemode = COMPUTER_COMPUTER;
     writeString_P("\nWer soll anfangen?\n");
     writeString_P(" -1- Spieler/Computer 1 (unten)\n");
     writeString_P(" -2- Spieler/Computer 2 (oben)\n");
     writeString_P(" -3- Zufällige Spieler-Auswahl\n");
     enterString();
     if (receiveBuffer[0] == '1') turn = 1;
     if (receiveBuffer[0] == '2') turn = 2;
     if (receiveBuffer[0] == '3') {
      turn = rand() % 2 + 1;
      writeString_P("Es beginnt der Spieler/Computer ");
      writeInteger(turn, DEC);
      writeString_P("!\n");
     }
     initFieldArray();
     showBoard();
     
     switch (gamemode) {
      // Player 2 plays against player 1:
      case PLAYER_PLAYER :
       playerVplayer();
       break;
      // Computer 2 plays against player 1:
      case COMPUTER_PLAYER :
       computerVplayer();
       break;
      // Shows the computer demo:
      case COMPUTER_COMPUTER :
       computerDemo();
       break;
     }
    }
    /*****************************************************************************/
    // Main function - The program starts here:
    int main(void)
    {
     initRP6Control(); // Always call this first! The Processor will not work
           // correctly otherwise. 
     initLCD(); // Initialize the LC-Display (LCD)
          // Always call this before using the LCD!
     // Write some text messages to the UART - just like on RP6Base:
     writeString_P("\n\n   _______________________\n");
     writeString_P("   \\| RP6  ROBOT SYSTEM |/\n");
     writeString_P("    \\_-_-_-_-_-_-_-_-_-_/\n\n");
     writeString_P("Kalaha for RP6 CONTROL!\n"); 
     // Set the four Status LEDs:
     setLEDs(0b1111);
     mSleep(500);
     setLEDs(0b0000);
     showScreenLCD("################", "################");
     mSleep(1500);
     showScreenLCD("<<RP6  Control>>", "<<LC - DISPLAY>>");
     mSleep(2500); 
     showScreenLCD("   Kalaha 1.0   ", "  ************  ");
     mSleep(2500);
     clearLCD(); // Clear the whole LCD Screen
     srand(get_seed());
     while(true) {
      newGame();
     }
     return 0;
    }
    /******************************************************************************
     * Additional info
     * ****************************************************************************
     * Changelog:
     * - v. 1.0 (initial release) 24.05.2011 by Dirk
     *
     * ****************************************************************************
     */
    /*****************************************************************************/
    Viel Spaß!
    Gruß
    Dirk

  3. #3
    Erfahrener Benutzer Robotik Einstein Avatar von Dirk
    Registriert seit
    30.04.2004
    Ort
    NRW
    Beiträge
    3.791

    RP6Control M32: Oware

    Hier das Spiel Oware. Es ist eines der ältesten Spiele der Welt und deutlich komplexer als Kalaha.
    Versucht 'mal, gegen euren ATMega32 zu gewinnen ... nicht ganz einfach.
    Aber: Die "KI" läßt sich noch deutlich verbessern!

    Infos dazu: http://de.wikipedia.org/wiki/Oware

    Viel Spaß!
    Angehängte Dateien Angehängte Dateien
    Geändert von Dirk (18.06.2011 um 21:59 Uhr)
    Gruß
    Dirk

  4. #4
    Erfahrener Benutzer Robotik Einstein Avatar von Dirk
    Registriert seit
    30.04.2004
    Ort
    NRW
    Beiträge
    3.791

    RP6Control M32: Merry Christmas

    Hallo RP6v2 Fans!

    Einen schönen 3. Advent!

    Code:
    /* 
     * ****************************************************************************
     * RP6 ROBOT SYSTEM - RP6 CONTROL M32 Examples
     * ****************************************************************************
     * Example: Christmas
     * Author(s): Dirk
     * ****************************************************************************
     * Description:
     * This program for RP6 Control plays the song Jingle Bells
     * and shows a Christmas tree on the terminal.
     *
     * ############################################################################
     * The Robot does NOT move in this example! You can simply put it on a table
     * next to your PC and you should connect it to the PC via the USB Interface!
     * ############################################################################
     * ****************************************************************************
     */
    
    /*****************************************************************************/
    // Includes:
    
    #include "RP6ControlLib.h" 		// The RP6 Control Library. 
    								// Always needs to be included!
    
    /*****************************************************************************/
    // Defines:
    
    // Define tone frequencies (well temperament):
    
    // Great Octave
    #define Tone_H      2       //123Hz
    
    // Small Octave
    #define Tone_c      16      //131Hz
    #define Tone_cis    30      //139Hz
    #define Tone_d      42      //147Hz
    #define Tone_dis    54      //156Hz
    #define Tone_e      65      //165Hz
    #define Tone_f      76      //175Hz
    #define Tone_fis    86      //185Hz
    #define Tone_g      96      //196Hz
    #define Tone_gis    105     //208Hz
    #define Tone_a      113     //220Hz
    #define Tone_ais    121     //233Hz
    #define Tone_h      128     //247Hz
    
    // ' Octave
    #define Tone_C1     136     //262Hz
    #define Tone_Cis1   142     //277Hz
    #define Tone_D1     149     //294Hz
    #define Tone_Dis1   155     //311Hz
    #define Tone_E1     160     //330Hz
    #define Tone_F1     166     //349Hz
    #define Tone_Fis1   171     //370Hz
    #define Tone_G1     175     //392Hz
    #define Tone_Gis1   180     //415Hz
    #define Tone_A1     184     //440Hz
    #define Tone_Ais1   188     //466Hz
    #define Tone_H1     192     //494Hz
    
    // '' Octave
    #define Tone_C2     195     //523Hz
    #define Tone_Cis2   199     //554Hz
    #define Tone_D2     202     //587Hz
    #define Tone_Dis2   205     //622Hz
    #define Tone_E2     208     //659Hz
    #define Tone_F2     210     //698Hz
    #define Tone_Fis2   213     //740Hz
    #define Tone_G2     215     //784Hz
    #define Tone_Gis2   217     //831Hz
    #define Tone_A2     219     //880Hz
    #define Tone_Ais2   221     //932Hz
    #define Tone_H2     223     //988Hz
    
    // ''' Octave
    #define Tone_C3     225     //1047Hz
    #define Tone_Cis3   227     //1109Hz
    #define Tone_D3     228     //1175Hz
    #define Tone_Dis3   230     //1245Hz
    #define Tone_E3     231     //1319Hz
    #define Tone_F3     233     //1397Hz
    #define Tone_Fis3   234     //1480Hz
    #define Tone_G3     235     //1568Hz
    #define Tone_Gis3   236     //1661Hz
    #define Tone_A3     237     //1760Hz
    #define Tone_Ais3   238     //1865Hz
    #define Tone_H3     239     //1976Hz
    
    // '''' Octave
    #define Tone_C4     240     //2093Hz
    #define Tone_Cis4   241     //2217Hz
    #define Tone_D4     242     //2349Hz
    #define Tone_Dis4   242     //2489Hz
    #define Tone_E4     243     //2637Hz
    #define Tone_F4     244     //2794Hz
    #define Tone_Fis4   244     //2960Hz
    #define Tone_G4     245     //3136Hz
    #define Tone_Gis4   246     //3322Hz
    #define Tone_A4     246     //3520Hz
    #define Tone_Ais4   247     //3729Hz
    #define Tone_H4     247     //3951Hz
    
    // ''''' Octave
    #define Tone_C5     248     //4186Hz
    
    // Beats per minute (BPM):
    #define Largo		50
    #define Larghetto	63
    #define Adagio		71
    #define Andante		92
    #define Moderato	114
    #define Allegro		144
    #define Presto		188
    
    /*****************************************************************************/
    // Variables:
    
    uint16_t T_1;				// Whole tone
    uint16_t T_2;				// Semitone (halftone)
    uint16_t T_4;				// Quarter tone
    uint16_t T_8;				// Quaver (eigth note)
    uint16_t T_16;				// Semiquaver
    uint16_t T_32;				// Demisemiquaver (thirty-second note)
    
    /*****************************************************************************/
    // Functions:
    
    /**
     * SET SPEED
     *
     * Input: Speed [BPM]
     *        OR Speed [Adagio] (= 71 BPM)
     *
     */
    void setSpeed(uint16_t bpm)
    {
    	T_4 = 60000 / bpm;
    	T_1 = 4 * T_4;
    	T_2 = 2 * T_4;
    	T_8 = T_4 / 2;
    	T_16 = T_4 / 4;
    	T_32 = T_4 / 8;
    }
    
    /**
     * PLAY JINGLE BELLS
     *
     */
    void jingle_bells(void)
    {
    	setSpeed(Allegro);		// Set 144 BPM
    
    	setLEDs(0b0010);
    	sound(Tone_E1,T_4, 0);
    	sound(Tone_E1,T_4, 0);
    	sound(Tone_E1,T_2, 0);
    
    	sound(Tone_E1,T_4, 0);
    	sound(Tone_E1,T_4, 0);
    	sound(Tone_E1,T_2, 0);
    
    	sound(Tone_E1,T_4, 0);
    	setLEDs(0b1000);
    	sound(Tone_G1,T_4, 0);
    	setLEDs(0b0001);
    	sound(Tone_C1,T_4, 0);
    	setLEDs(0b0010);
    	sound(Tone_D1,T_4, 0);
    
    	setLEDs(0b0100);
    	sound(Tone_E1,T_1, 0);
    
    
    	setLEDs(0b1000);
    	sound(Tone_F1,T_4, 0);
    	sound(Tone_F1,T_4, 0);
    	sound(Tone_F1,T_4, 0);
    	sound(Tone_F1,T_4, 0);
    
    	sound(Tone_F1,T_4, 0);
    	setLEDs(0b0100);
    	sound(Tone_E1,T_4, 0);
    	sound(Tone_E1,(T_4 + T_8), 0);
    	sound(Tone_E1,T_8, 0);
    
    	sound(Tone_E1,T_4, 0);
    	setLEDs(0b0010);
    	sound(Tone_D1,T_4, 0);
    	sound(Tone_D1,T_4, 0);
    	setLEDs(0b0100);
    	sound(Tone_E1,T_4, 0);
    
    	setLEDs(0b0010);
    	sound(Tone_D1,T_2, 0);
    	setLEDs(0b1000);
    	sound(Tone_G1,T_2, 0);
    
    
    	setLEDs(0b0010);
    	sound(Tone_E1,T_4, 0);
    	sound(Tone_E1,T_4, 0);
    	sound(Tone_E1,T_2, 0);
    
    	sound(Tone_E1,T_4, 0);
    	sound(Tone_E1,T_4, 0);
    	sound(Tone_E1,T_2, 0);
    
    	sound(Tone_E1,T_4, 0);
    	setLEDs(0b1000);
    	sound(Tone_G1,T_4, 0);
    	setLEDs(0b0001);
    	sound(Tone_C1,T_4, 0);
    	setLEDs(0b0010);
    	sound(Tone_D1,T_4, 0);
    
    	setLEDs(0b0100);
    	sound(Tone_E1,T_1, 0);
    
    
    	setLEDs(0b1000);
    	sound(Tone_F1,T_4, 0);
    	sound(Tone_F1,T_4, 0);
    	sound(Tone_F1,T_4, 0);
    	sound(Tone_F1,T_4, 0);
    
    	sound(Tone_F1,T_4, 0);
    	setLEDs(0b0100);
    	sound(Tone_E1,T_4, 0);
    	sound(Tone_E1,T_4, 0);
    	sound(Tone_E1,T_4, 0);
    
    	setLEDs(0b1000);
    	sound(Tone_G1,T_4, 0);
    	sound(Tone_G1,T_4, 0);
    	setLEDs(0b0100);
    	sound(Tone_F1,T_4, 0);
    	setLEDs(0b0010);
    	sound(Tone_D1,T_4, 0);
    
    	setLEDs(0b0001);
    	sound(Tone_C1,(T_4 * 3), T_4);
    	setLEDs(0b0000);
    }
    
    /*****************************************************************************/
    // Main function - The program starts here:
    
    int main(void)
    {
    	initRP6Control(); // Always call this first! The Processor will not work
    					  // correctly otherwise. 
    
    	initLCD(); // Initialize the LC-Display (LCD)
    			   // Always call this before using the LCD!
    
    	// Write some text messages to the UART - just like on RP6Base:
    	writeString_P("\n\n   _______________________\n");
    	writeString_P("   \\| RP6  ROBOT SYSTEM |/\n");
    	writeString_P("    \\_-_-_-_-_-_-_-_-_-_/\n\n");
    
    	// Set the four Status LEDs:
    	setLEDs(0b1111);
    	mSleep(500);
    	setLEDs(0b0000);
    
    	showScreenLCD("################", "################");
    	mSleep(1500);
    	showScreenLCD("<<RP6  Control>>", "<<LC - DISPLAY>>");
    	mSleep(2500); 
    	showScreenLCD(" Merry Christmas", "* Jingle Bells *");
    
    	writeString_P("              X\n");
    	writeString_P("              *\n");
    	writeString_P("             **i\n");
    	writeString_P("            *****\n");
    	writeString_P("           *i*****\n");
    	writeString_P("          *******O*\n");
    	writeString_P("         ***********\n");
    	writeString_P("        **O****i*****\n");
    	writeString_P("       *************i*\n");
    	writeString_P("      **O*i************\n");
    	writeString_P("     ***********O****i**\n");
    	writeString_P("    **i****************O*\n");
    	writeString_P("   *******O*****i*********\n");
    	writeString_P("  *****************O*****i*\n");
    	writeString_P(" ****O**i*******************\n");
    	writeString_P("**i*******************i******\n");
    	writeString_P("        &    |I|\n");
    	writeString_P("      [M32]  |I|\n");
    
    	while(true) 
    	{
    		mSleep(5000);		// Pause 5 seconds
    		jingle_bells();		// Play melody
    	}
    	return 0;
    }
    Gruß
    Dirk

  5. #5
    Erfahrener Benutzer Robotik Einstein Avatar von Dirk
    Registriert seit
    30.04.2004
    Ort
    NRW
    Beiträge
    3.791

    RP6 Control M256 WiFi: Chess

    Hallo M256 WiFi Besitzer,

    wie wäre es mit einer kleinen Schach-Partie?

    Das geht ganz gut auch mit dem ATmega2560.

    Datei: RP6M256_Chess.c:
    Code:
    /* 
     * ****************************************************************************
     * RP6 ROBOT SYSTEM - RP6 CONTROL M256 Examples
     * ****************************************************************************
     * Example: Chess
     * Author(s): Dirk
     * ****************************************************************************
     * Description:
     * This program for RP6 Control M256 WiFi plays the game chess.
     *
     * You will find further information here:
     *    http://de.wikipedia.org/wiki/Chess
     *    http://en.wikipedia.org/wiki/Chess
     *
     * ############################################################################
     * The Robot does NOT move in this example! You can simply put it on a table
     * next to your PC and you should connect it to the PC via the USB Interface!
     * You should also connect to it via WIFI.
     * ############################################################################
     * ****************************************************************************
     */
    
    /*****************************************************************************/
    // Includes:
    
    #include "RP6M256Lib.h" 					// The RP6 M256 Library. 
    											// Always needs to be included!
    
    /*****************************************************************************/
    // Defines:
    
    #define HELP							// Display help
    
    /*****************************************************************************/
    // Functions:
    
    /**
     * GET SEED
     *
     * Gets a starting value for mysrand().
     *
     */
    uint16_t get_seed(void)
    {
    	uint16_t seed = 0;
    	uint16_t *p = (uint16_t*) (RAMEND + 1);
    	extern uint16_t __heap_start;
    
    	while (p >= &__heap_start + 1)
    		seed ^= * (--p);
    
    	return seed;
    }
    
    /*****************************************************************************/
    //###########################################################################
    /*****************************************************************************/
    // micro-Max chess engine V4.8 by H. G. Muller:
    // (http://home.hccnet.nl/h.g.muller/max-src2.html)
    /***************************************************************************/
    /*                               micro-Max,                                */
    /* A chess program smaller than 2KB (of non-blank source), by H.G. Muller  */
    /* Port to Atmel ATMega644 and AVR GCC, by Andre Adrian                    */
    /* (http://www.andreadrian.de/schach/index.html)                           */
    /***************************************************************************/
    /* version 4.8 (1953 characters) features:                                 */
    /* - recursive negamax search                                              */
    /* - all-capture MVV/LVA quiescence search                                 */
    /* - (internal) iterative deepening                                        */
    /* - best-move-first 'sorting'                                             */
    /* - a hash table storing score and best move                              */
    /* - futility pruning                                                      */
    /* - king safety through magnetic, frozen king in middle-game              */
    /* - R=2 null-move pruning                                                 */
    /* - keep hash and repetition-draw detection                               */
    /* - better defense against passers through gradual promotion              */
    /* - extend check evasions in inner nodes                                  */
    /* - reduction of all non-Pawn, non-capture moves except hash move (LMR)   */
    /* - full FIDE rules (expt under-promotion) and move-legality checking     */
    
    /* 26nov2008 no hash table                                                 */
    /* 29nov2008 all IO via myputchar(), mygetchar(), pseudo random generator  */
    
    #define W while
    #define M 0x88
    #define S 128
    #define I 8000
    
    long N, T;					/* N=evaluated positions+S, T=recursion limit   */
    short Q,O,K,R,k=16;									/* k=moving side    */
    char *p,c[5],Z;							/* p=pointer to c, c=user input,*/
    									/* computer output, Z=recursion counter */
    
    char L,
    w[]={0,2,2,7,-1,8,12,23},						/* relative piece values    */
    o[]={-16,-15,-17,0,1,16,0,1,16,15,17,0,14,18,31,33,0,/* step-vector lists*/
         7,-1,11,6,8,3,6,							/* 1st dir. in o[] per piece*/
         6,3,5,7,4,5,3,6},							/* initial piece setup      */
    b[]={		/* board is left part, center-pts table is right part, and dummy*/
      22, 19, 21, 23, 20, 21, 19, 22, 28, 21, 16, 13, 12, 13, 16, 21, 
      18, 18, 18, 18, 18, 18, 18, 18, 22, 15, 10,  7,  6,  7, 10, 15, 
       0,  0,  0,  0,  0,  0,  0,  0, 18, 11,  6,  3,  2,  3,  6, 11, 
       0,  0,  0,  0,  0,  0,  0,  0, 16,  9,  4,  1,  0,  1,  4,  9, 
       0,  0,  0,  0,  0,  0,  0,  0, 16,  9,  4,  1,  0,  1,  4,  9, 
       0,  0,  0,  0,  0,  0,  0,  0, 18, 11,  6,  3,  2,  3,  6, 11, 
       9,  9,  9,  9,  9,  9,  9,  9, 22, 15, 10,  7,  6,  7, 10, 15, 
      14, 11, 13, 15, 12, 13, 11, 14, 28, 21, 16, 13, 12, 13, 16, 21, 0
    };
    
    volatile char breakpoint;									/* for debugger */
    
    /* User interface routines */
    void myputchar(char c) {
      writeChar_WIFI(c);
    }
    
    void myputs(const char *s) {
      while(*s) myputchar(*s++);
      myputchar('\n');
    }
    
    char mygetchar(void) {
      char tmp;
      do {tmp = readChar_WIFI();}
      while (tmp == 0);
      if(c[0] == 13) c[0] = 10;
      return tmp;
    //  return 10;							/* self play computer with computer */
    }
    
    /* 16bit pseudo random generator */
    #define MYRAND_MAX 65535
    
    unsigned short r = 1;						/* pseudo random generator seed */
    
    void mysrand(unsigned short r_) {
     r = r_;
    }
    
    unsigned short myrand(void) {
     return r=((r<<11)+(r<<7)+r)>>1;
    }
    
    short D(q,l,e,E,z,n)							/* recursive minimax search */
    short q,l,e;						/* (q,l)=window, e=current eval. score, */
    unsigned char E,z,n;		/* E=e.p. sqr.z=prev.dest, n=depth; return score*/        
    {                       
     short m,v,i,P,V,s;
     unsigned char t,p,u,x,y,X,Y,H,B,j,d,h,F,G,C;
     signed char r;
    
     if (++Z>30) {										/* stack underrun check */
      breakpoint=1;				/*  AVR Studio 4 Breakpoint for stack underrun  */
      myputchar('u');
      --Z;return e;                                    
     }
     
     q--;											/* adj. window: delay bonus */
     k^=24;											/* change sides             */
     d=Y=0;											/* start iter. from scratch */
     X=myrand()&~M;								/* start at random field    */
     W(d++<n||d<3||								/* iterative deepening loop */
       z&K==I&&(N<T&d<98||							/* root: deepen upto time   */
       (K=X,L=Y&~M,d=3)))							/* time's up: go do best    */
     {x=B=X;										/* start scan at prev. best */
      h=Y&S;										/* request try noncastl. 1st*/
      P=d<3?I:D(-l,1-l,-e,S,0,d-3);				/* Search null move         */
      m=-P<l|R>35?d>2?-I:e:-P;						/* Prune or stand-pat       */
      ++N;											/* node count (for timing)  */
      do{u=b[x];									/* scan board looking for   */
       if(u&k)										/*  own piece (inefficient!)*/
       {r=p=u&7;									/* p = piece type (set r>0) */
        j=o[p+16];									/* first step vector f.piece*/
        W(r=p>2&r<0?-r:-o[++j])					/* loop over directions o[] */
        {A:											/* resume normal after best */
         y=x;F=G=S;									/* (x,y)=move, (F,G)=castl.R*/
         do{										/* y traverses ray, or:     */
          H=y=h?Y^h:y+r;							/* sneak in prev. best move */
          if(y&M)break;								/* board edge hit           */
          m=E-S&b[E]&&y-E<2&E-y<2?I:m;			/* bad castling             */
          if(p<3&y==E)H^=16;						/* shift capt.sqr. H if e.p.*/
          t=b[H];if(t&k|p<3&!(y-x&7)-!t)break;	/* capt. own, bad pawn mode */
          i=37*w[t&7]+(t&192);						/* value of capt. piece t   */
          m=i<0?I:m;								/* K capture                */
          if(m>=l&d>1)goto C;						/* abort on fail high       */
          v=d-1?e:i-p;								/* MVV/LVA scoring          */
          if(d-!t>1)								/* remaining depth          */
          {v=p<6?b[x+8]-b[y+8]:0;					/* center positional pts.   */
           b[G]=b[H]=b[x]=0;b[y]=u|32;			/* do move, set non-virgin  */
           if(!(G&M))b[F]=k+6,v+=50;				/* castling: put R & score  */
           v-=p-4|R>29?0:20;						/* penalize mid-game K move */
           if(p<3)									/* pawns:                   */
           {v-=9*((x-2&M||b[x-2]-u)+				/* structure, undefended    */
                  (x+2&M||b[x+2]-u)-1				/*        squares plus bias */
                 +(b[x^16]==k+36))					/* kling to non-virgin King */
                 -(R>>2);							/* end-game Pawn-push bonus */
            V=y+r+1&S?647-p:2*(u&y+16&32);		/* promotion or 6/7th bonus */
            b[y]+=V;i+=V;							/* change piece, add score  */
           }
           v+=e+i;V=m>q?m:q;						/* new eval and alpha       */
           C=d-1-(d>5&p>2&!t&!h);
           C=R>29|d<3|P-I?C:d;						/* extend 1 ply if in check */
           do
            s=C>2|v>V?-D(-l,-V,-v,					/* recursive eval. of reply */
                                  F,0,C):v;			/* or fail low if futile    */
           W(s>q&++C<d);v=s;
           if(z&&K-I&&v+I&&x==K&y==L)				/* move pending & in root:  */
           {Q=-e-i;O=F;							/*   exit if legal & found  */
            R+=i>>7;--Z;return l;					/* captured non-P material  */
           }
           b[G]=k+6;b[F]=b[y]=0;b[x]=u;b[H]=t;	/* undo move,G can be dummy */
          }
          if(v>m)									/* new best, update max,best*/
           m=v,X=x,Y=y|S&F;						/* mark double move with S  */
          if(h){h=0;goto A;}						/* redo after doing old best*/
          if(x+r-y|u&32|							/* not 1st step,moved before*/
             p>2&(p-4|j-7||						/* no P & no lateral K move,*/
             b[G=x+3^r>>1&7]-k-6					/* no virgin R in corner G, */
             ||b[G^1]|b[G^2])						/* no 2 empty sq. next to R */
            )t+=p<5;								/* fake capt. for nonsliding*/
          else F=y;									/* enable e.p.              */
         }W(!t);									/* if not capt. continue ray*/
      }}}W((x=x+9&~M)-B);							/* next sqr. of board, wrap */
    C:if(m>I-M|m<M-I)d=98;							/* mate holds to any depth  */
      m=m+I|P==I?m:0;								/* best loses K: (stale)mate*/
      if(z&&d>2)
       {*c='a'+(X&7);c[1]='8'-(X>>4);c[2]='a'+(Y&7);c[3]='8'-(Y>>4&7);c[4]=0;
        breakpoint=2;			/* AVR Studio 4 Breakpoint for moves, watch c[] */
    //    printf("%2d ply, %9d searched, score=%6d by %c%c%c%c\n",d-1,N-S,m,
    //     'a'+(X&7),'8'-(X>>4),'a'+(Y&7),'8'-(Y>>4&7));/* uncomment for Kibitz */   
      }  
     }												/*    encoded in X S,8 bits */
     k^=24;											/* change sides back        */
     --Z;return m+=m<e;							/* delayed-loss bonus       */
    }
    
    //void print_board(void)
    //{
    // short N=-1;
    // W(++N<121)
    //  myputchar(N&8&&(N+=7)?10:".?inkbrq?I?NKBRQ"[b[N]&15]);		/* Pawn is i*/
    //}
    
    // micro-Max chess engine V4.8 end.
    /*****************************************************************************/
    //###########################################################################
    /*****************************************************************************/
    
    void print_new_board(void)
    {
     myputs("  A B C D E F G H");
     short N=-1;
     W(++N<121)
      {
        if (N&8&&(N+=7)) {
    	  myputchar(' ');
    	  writeInteger_WIFI(8-(N>>4), DEC);
    #ifdef HELP
    	  myputchar(' ');
    	  myputchar(' ');
          switch(N)
          {
    		case 15: myputs("kK = King");
    		break;
    		case 31: myputs("qQ = Queen");
    		break;
    		case 47: myputs("rR = Rook");
    		break;
    		case 63: myputs("nN = Knight");
    		break;
    		case 79: myputs("bB = Bishop");
    		break;
    		case 95: myputs("iI = Pawn");
    		break;
    		case 111: myputs("i = BLACK, I = WHITE Pawn");
    		break;
    		case 127: myputs("Move: c2c4<ENTER><ENTER>");
    		break;
            default: myputchar(10);
    	  }
    #else
          myputchar(10);
    #endif
    	  if (N < 127) writeInteger_WIFI(7-(N>>4), DEC);
    	}
        else {
    	  if (!N) myputchar('8');
    	  myputchar(' ');
    	  myputchar(".?inkbrq?I?NKBRQ"[b[N]&15]);					/* Pawn is i*/
    	}
      }
     myputs("  A B C D E F G H");
    }
    
    /*****************************************************************************/
    // Main function - The program starts here:
    
    int main(void)
    {
    	initRP6M256();    // Always call this first! The Processor will not work
    					  // correctly otherwise. 
    
    	initLCD(); // Initialize the LC-Display (LCD)
    			   // Always call this before using the LCD!
    
    	// Now write Text via the WIFI Interface:
    	writeString_P_WIFI("\n\n   _______________________\n");
    	writeString_P_WIFI("   \\| RP6  ROBOT SYSTEM |/\n");
    	writeString_P_WIFI("    \\_-_-_-_-_-_-_-_-_-_/\n\n");
    
    	writeString_P_WIFI("Chess for RP6 CONTROL M256 WIFI!\n"); 
    
    	// Set the four Status LEDs:
    	setLEDs(0b1111);
    	mSleep(500);
    	setLEDs(0b0000);
    
    	showScreenLCD("################", "################");
    	mSleep(1500);
    	showScreenLCD("RP6v2-M256-WIFI ", "<<LC - DISPLAY>>");
    	mSleep(1500); 
    	showScreenLCD("   Chess 1.1    ", "  ************  ");
    	mSleep(1500);
    	clearLCD(); // Clear the whole LCD Screen
    
    /*****************************************************************************/
    // micro-Max chess engine V4.8 (initialisation):
     mysrand(get_seed());						/*   make myrand() calls random */
    // micro-Max chess engine V4.8 (play loop):
     do{												/* play loop            */
      print_new_board();
      myputs(c);
      p=c;W((*p++=mygetchar())>10);					/* read input line      */
      K=I;												/* invalid move         */
      if(*c-10)K=*c-16*c[1]+799,L=c[2]-16*c[3]+799;	/* parse entered move   */
      N=0;T=0x3F;									/* T=Computer Play strength */
     }W(D(-I,I,Q,O,1,3)>-I+1);						/* think or check & do  */
     print_new_board();
    
    /*****************************************************************************/
    
    	return 0;
    }
    
    /******************************************************************************
     * Additional info
     * ****************************************************************************
     * Changelog:
     * - v. 1.1 New board & help text added 03.01.2014 by Dirk
     * - v. 1.0 (initial release) 03.01.2014 by Dirk
     *
     * ****************************************************************************
     */
    
    /*****************************************************************************/
    Hinweise:
    1. Im makefile die Zeile:
    OPT = s
    ... ersetzen durch:
    OPT = 2

    2. Die Warnungen beim Kompilieren ignorieren!

    3. Die Ausgaben des Programms erfolgen auf dem WiFi Terminal.

    Viel Spaß!
    Gruß
    Dirk

Ähnliche Themen

  1. Meine kleine Sammlung:
    Von the_playstat im Forum Sonstige Roboter- und artverwandte Modelle
    Antworten: 6
    Letzter Beitrag: 07.09.2009, 21:16
  2. Sammlung von Standard ICs
    Von CowZ im Forum Elektronik
    Antworten: 3
    Letzter Beitrag: 20.09.2007, 23:48
  3. Bascom USB ISP auch mit anderen Programmen?
    Von Elektronik303 im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 2
    Letzter Beitrag: 09.08.2007, 20:02
  4. Robotik und Elektronik Link Sammlung
    Von just4fun im Forum Allgemeines zum Thema Roboter / Modellbau
    Antworten: 1
    Letzter Beitrag: 24.08.2006, 19:36
  5. Sammlung: H-Brücke
    Von LLiinnuuxx im Forum Elektronik
    Antworten: 89
    Letzter Beitrag: 14.09.2004, 13:34

Stichworte

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •