Project 21.y - Game 'Puzzle 15'

Author: Carlo Lanzi Luciani

.gitignore

@@ -11,3 +11,4 @@ build
  **/*.out
 */*.out
 .idea/
+./**/*.gch

LICENSE

@@ -106,7 +106,7 @@ feature that (1) displays an appropriate copyright notice, and (2)
 tells the user that there is no warranty for the work (except to the
 extent that warranties are provided), that licensees may convey the
 work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
+the interface presents a list of user Commands or options, such as a
 menu, a prominent item in the list meets this criterion.
 
   1. Source Code.
@@ -657,8 +657,8 @@ notice like this when it starts in an interactive mode:
     This is free software, and you are welcome to redistribute it
     under certain conditions; type `show c' for details.
 
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
+The hypothetical Commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's Commands
 might be different; for a GUI interface, you would use an "about box".
 
   You should also get your employer (if you work as a programmer) or school,

learncpp.com-v09.2023/bookmark.txt

@@ -1,6 +1,7 @@
 topic 1: learncpp.com
+bookmark: 22.4
 
-21.y
+topic 2: learn smt about computer networks from 'a Top down approch'.
+Bookmark : ch1 - page18
 
-I add another topic here: learn smt about computer networks from the website of geeksforgeeks. 
-topic 2: chapter Protocols
+topic 3: https://pages.github.com/ (personlise your github page to learn some html, css and javascript. Very not-necessary for now)

learncpp.com-v09.2023/project21.y/compilation.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+cd src
+g++ -ggdb -pedantic-errors -Wall -Weffc++ -Wextra -Werror -Wsign-conversion -std=c++20 -o ../build/executable.out ./*

learncpp.com-v09.2023/project21.y/src/board.cpp

@@ -0,0 +1,85 @@
+#include"board.h"
+
+void Board::randomMove()
+{
+    this->move0(Direction::getRandom());
+}
+
+void Board::randomise()
+{
+    for(int index{}; index<100; ++index)
+    {
+        this->randomMove();
+    }
+}
+
+Point Board::getPosition(const Tile& tile) const
+{
+    // bad practice, but not avoidable easily: we used `int` for the class Point, and not std::size_t
+    int size { static_cast<int>(g_size) };
+    // linear search because the board is not ordered and we used a C-array rather than a std::array
+    for(int row_index{}; row_index < size; ++row_index)
+    {
+        for(int column_index{}; column_index< size; ++column_index)
+        {
+            if(m_grid[row_index][column_index]==tile){
+                // note that we must invert the column and row index!
+                // (matrix indices are inverted wrt cartesian coordinates)
+                return {column_index, row_index};
+            }
+        }
+    }
+    return {-1,-1};     //will never happen
+}
+
+Tile& Board::operator()(const Point& point)
+{
+    // notice: we need to invert the indices between the cartesian and the matrix indexing
+    return m_grid[point.getY()][point.getX()];
+}
+
+Board& Board::move0(const Direction& direction)
+{
+    Point zero_tile_position { this->getPosition(0) };
+    Point adiacent_position { zero_tile_position.getAdjacentPoint(direction) };
+
+    if(adiacent_position.isOnBoard()){
+        std::swap( this->operator()(zero_tile_position), this->operator()(adiacent_position));
+    }
+
+    return *this;
+}
+
+
+std::ostream& operator<<(std::ostream& out, const Board& board)
+{
+    for(int line{}; line < Konstants::g_consoleLines; ++line)
+    {
+        out << '\n';
+    }
+
+    for(std::size_t index_r{}; index_r < g_size; ++index_r)
+    {
+        for(std::size_t index_c{}; index_c < g_size; ++index_c)
+        {
+            out << board.m_grid[index_r][index_c];
+        }
+        out << '\n';
+    }
+    return out;
+}
+
+
+bool operator==(const Board& board1, const Board& board2)
+{
+    for(std::size_t index_r{}; index_r < g_size; ++index_r)
+    {
+        for(std::size_t index_c{}; index_c < g_size; ++index_c)
+        {
+            if( board1.m_grid[index_r][index_c] != board2.m_grid[index_r][index_c] ) {
+                return false;
+            }
+        }
+    }
+    return true;
+}

learncpp.com-v09.2023/project21.y/src/board.h

@@ -0,0 +1,42 @@
+#ifndef BOARD_H
+#define BOARD_H
+
+#include <iostream>
+#include <algorithm>
+
+#include "tile.h"
+#include "point.h" // which includes direction
+
+#include "konstants.h"
+#include "random.h"
+
+
+class Board
+{
+public:
+    Board() = default;
+
+    void randomMove();
+
+    void randomise();
+
+    // you can give an integer as an argument
+    Point getPosition(const Tile& tile) const;
+
+    Tile& operator()(const Point& point);
+
+    Board& move0(const Direction& direction);
+
+    friend std::ostream& operator<<(std::ostream& out, const Board& board);
+
+    friend bool operator==(const Board& board1, const Board& board2);
+
+private:
+    Tile m_grid[g_size][g_size] {
+            Tile{ 1 }, Tile { 2 }, Tile { 3 } , Tile { 4 },
+            Tile { 5 } , Tile { 6 }, Tile { 7 }, Tile { 8 },
+            Tile { 9 }, Tile { 10 }, Tile { 11 }, Tile { 12 },
+            Tile { 13 }, Tile { 14 }, Tile { 15 }, Tile { 0 } };
+};
+
+#endif

learncpp.com-v09.2023/project21.y/src/direction.cpp

@@ -0,0 +1,39 @@
+#include"direction.h"
+
+
+Direction Direction::getRandom()
+{
+    return Direction{Random::get<int>(0,3)};
+}
+
+Direction::Possible Direction::getTowards() const
+{
+    return m_towards;
+}
+
+Direction Direction::operator-() const
+{
+    if( m_towards <= 1 )
+    {
+        return Direction{ m_towards+2 };
+    } else
+    {
+        return Direction{ m_towards-2 };
+    }
+}
+
+
+std::ostream& operator<< (std::ostream& out, const Direction& direction)
+{
+    switch(direction.getTowards())
+    {
+        case 0: out << Konstants::up; break;
+        case 1: out << Konstants::right; break;
+        case 2: out << Konstants::down; break;
+        case 3: out << Konstants::left; break;
+        default: out << "unknown direction"; break;
+    }
+    return out;
+}
+
+

learncpp.com-v09.2023/project21.y/src/direction.h

@@ -0,0 +1,43 @@
+#ifndef DIRECTION_H
+#define DIRECTION_H
+
+#include<iostream>
+#include<assert.h>
+
+#include "konstants.h"
+#include "random.h"
+
+class Direction
+{
+public:
+    enum Possible
+    {
+        up,
+        right,
+        down,
+        left,
+
+        max_possible,
+    };
+
+    static Direction getRandom();
+
+    Direction(Possible possible=up) : m_towards{ possible }
+    {
+        assert(possible>=0 && possible<=3 && "direction initialised with invalid number");
+    }
+
+    Direction(int num=up) : Direction(static_cast<Direction::Possible>(num))
+    {}
+
+    Possible getTowards() const;
+
+    Direction operator-() const;
+
+    friend std::ostream& operator<< (std::ostream& out, const Direction& direction);
+
+private:
+    Possible m_towards {up};
+};
+
+#endif

learncpp.com-v09.2023/project21.y/src/konstants.h

@@ -0,0 +1,17 @@
+#ifndef KONSTANTS_H
+#define KONSTANTS_H
+
+namespace Konstants
+{
+    constexpr int g_consoleLines{ 25 };
+
+    constexpr char unknown_input='0';
+    constexpr char quit ='q';
+
+    constexpr char up='w';
+    constexpr char right='d';
+    constexpr char down='s';
+    constexpr char left='a';
+}
+
+#endif

learncpp.com-v09.2023/project21.y/src/main.cpp

@@ -0,0 +1,60 @@
+/*
+> Step #8
+
+Goal: In this step, we’ll finish our game. Randomize the initial state of the game board. Also, detect when user wins, so after that we can print a win message and quit the game.
+
+We need to be careful about how we randomize our puzzle, because not every puzzle is solvable. For example, there is no way to solve this puzzle:
+
+  1   2   3   4
+  5   6   7   8
+  9  10  11  12
+ 13  15  14
+
+If we just blindly randomize the numbers in the puzzle, there is a chance that we will generate such an unsolvable puzzle. With a physical version of the puzzle, we’d randomize the puzzle by sliding tiles in random directions until the tiles were sufficiently mixed. The solution for such a randomized puzzle is to slide each tile in the opposite direction that it was slid to randomize it in the first place. Thus, randomizing puzzles this way always generates a solvable puzzle.
+
+We can have our program randomize the board in the same way.
+
+Once the user has solved the puzzle, the program should print "\n\nYou won!\n\n" and then exit normally.
+
+*/
+
+#include <iostream>
+#include "user_input.h"
+#include "board.h"
+
+
+int main()
+{
+    std::cout << "Welcome to Puzzle 15!\n";
+
+    Board winning_board{};
+
+    Board board{};
+    board.randomise();
+    std::cout << board;
+
+    char ch{};
+
+    while(true)
+    {
+        std::cout << "\nGive me a direction with the commands '" << Konstants::up << "' '" << Konstants::right << "' '" << Konstants::down <<"' '" << Konstants::left << "' to move the empty tile around!\n";
+
+        ch = UserInput::getValidatedInput();
+
+        if(ch==Konstants::quit){
+            std::cout << "\n\nBye!\n\n";
+            return 0;
+        }
+
+        board.move0(UserInput::validChar2direction(ch));
+        std::cout << board << '\n';
+
+        if(board==winning_board)
+        {
+            std::cout << "Congratulations! You have won!";
+            std::cout << "\n\nBye!\n\n";
+            return 0;
+        }
+    }
+    return 0;
+}

learncpp.com-v09.2023/project21.y/src/point.cpp

@@ -0,0 +1,58 @@
+#include "point.h"
+
+int Point::getX() const
+{
+    return m_x;
+}
+
+int Point::getY() const
+{
+    return m_y;
+}
+
+Point Point::getAdjacentPoint(const Direction& direction)
+{
+    switch(direction.getTowards())
+    {
+        case 0: return Point{m_x, m_y-1};
+        case 1: return Point{m_x+1, m_y};
+        case 2: return Point{m_x, m_y+1};
+        case 3: return Point{m_x-1, m_y};
+        default: std::cout << "The given direction is invalid\n"; return *this;
+    }
+}
+
+bool Point::isOnBoard() const
+{
+    int size { static_cast<int>(g_size) };
+    return ( m_y>=0 && m_y<size && m_x>=0 && m_x<size );
+}
+
+bool operator==(const Point& point1, const Point& point2)
+{
+    return point1.m_x==point2.m_x && point1.m_y==point2.m_y;
+}
+
+
+bool operator!=(const Point& point1, const Point& point2)
+{
+    return !(point1==point2);
+}
+
+
+std::ostream& operator<<(std::ostream& out, const Point& point)
+{
+    out << "(" << point.getX() << "," << point.getY() << ")";
+    return out;
+}
+
+
+
+
+
+
+
+
+
+
+