Counting Squares initial repository

README.md

@@ -0,0 +1,217 @@
+[English](#markdown-header-repetition-structures-robot-counting-squares) | [Español](#markdown-header-estructuras-de-repeticion-robot-cuenta-cuartos)
+
+#Estructuras de Repetición - Robot cuenta cuartos
+
+![main1.png](images/main1.png)
+![main2.png](images/main2.png)
+![main3.png](images/main3.png)
+
+Una de las ventajas de utilizar programas de computadoras es que podemos realizar tareas repetitivas fácilmente. Los ciclos como `for`, `while`, y `do-while` son  estructuras de control que nos permiten repetir un conjunto de instrucciones. A estas estructuras también se les llama *estructuras de repetición*.
+
+Los algoritmos son uno de los conceptos más fundamentales en la Ciencia de Cómputos. Dado un pequeño conjunto de instrucciones y las estructuras básicas de programación, podemos resolver una gran cantidad de problemas. En esta experiencia de laboratorio vas a practicar la creación de algoritmos simulando un robot que debe explorar un espacio utilizando un conjunto bien limitado de instrucciones.
+
+##Objetivos:
+
+1. Diseñar algoritmos usando estructuras secuenciales, de decisión y repetición.
+2. Analizar el número de pasos de los algoritmos propuestos y tratar de minimizarlos.
+3. Practicar la invocación de métodos a un objeto.
+
+Esta experiencia de laboratorio es una adaptación de http://nifty.stanford.edu/2015/tychonievich-sherriff-layer-counting-squares/ .
+
+
+##Pre-Lab:
+
+Antes de llegar al laboratorio debes haber:
+
+1. Repasado las estructuras básicas de decisión y repetición en C++.
+2. Repasado la creación de objetos e invocación de sus métodos.
+3. Estudiado los conceptos e instrucciones para la sesión de laboratorio.
+
+
+---
+
+---
+
+
+## Robot cuenta cuartos
+
+En esta experiencia de laboratorio estaremos programando un robot que ha sido puesto en una cuadrícula (grid) de habitaciones cuadradas. Cada una de las cuatro paredes de cada cuarto puede tener una puerta. Solo las paredes que colindan con otros cuartos tienen puertas. Las paredes que forman la parte exterior de la cuadrícula  no tienen puertas.
+
+---
+
+![](images/cuarto.png)
+
+**Figura 1.** El robot está en el cuarto en el extremo superior izquierdo de la cuadrícula de 36 cuartos.
+
+---
+
+Los únicos comandos que entiende el robot son:
+
+1. Verificar si hay una puerta en la pared del norte (N), sur (S), este (E) u oeste (W) del cuarto donde se encuentra.
+2. Moverse al cuarto que queda justo al norte (N), sur (S), este (E) u oeste (W) del cuarto actual.
+4. Crear variables y asignarle valores.
+3. Realizar operaciones suma, resta, multiplicación y resta.
+5. Usar estructuras de decisión y repetición.
+6. Desplegar resultados a pantalla.
+
+
+## Objetos y métodos
+
+A continuación mostramos la función `main` de un programa básico como el que estarás creando. Durante esta experiencia de laboratorio solo tienes que programar la función `main` (dentro del archivo `main.cpp`). Los demás archivos contienen funciones que implementan la funcionalidad de las instrucciones que entiende el robot.
+
+---
+
+```cpp
+int main(int argc, char *argv[]) {
+    QApplication   a(argc, argv);
+
+    // Crear la cuadrícula y robot
+    MainGameWindow *w = new MainGameWindow(Mode::RECT_RANDOM);
+    w->show();
+
+    // Mostrar la palabra "Start"
+    w->display("Start");
+
+    // Mover el robot hacia el oeste cuanto se pueda
+    // mientras contamos el número de movidas
+
+    int ctr = 0;
+    while (w->canMove('W')) {
+        w->moveRobot('W');
+        ctr = ctr + 1;
+    }
+
+    // Desplegar el total de movidas
+    w->display("Total: " + QString::number(ctr));
+
+    return a.exec();
+}
+
+```
+
+**Figura 2** Ejemplo de una función `main`.
+
+---
+
+En el ejemplo estamos creando un robot dentro de un espacio cuadrado que solo sabe verificar si hay una puerta hacia el oeste y (si hay puerta) caminar hacia esa misma dirección.  Veamos la función, línea por línea.
+
+La primera línea crea el único objeto que debes crear, un objeto de clase `MainGameWindow`. El parámetro `Mode::SQUARE_TOP_LEFT` especifica que la cuadrícula será cuadrada y que el robot comenzará en la esquina superior izquierda. Otras opciones para el parámetro son `RECT_TOP_LEFT`, `RECT_RANDOM` y `PYRAMID_RANDOM`.
+
+```cpp
+MainGameWindow *w = new MainGameWindow(Mode::SQUARE_TOP_LEFT);
+```
+
+La siguiente es para mostrar el objeto `w`.
+
+```cpp
+w->show();
+```
+
+El método `void display(QString)` sirve para desplegar mensajes cortos a la pantalla. Por ejemplo:
+
+```cpp
+w->display("Start");
+```
+
+muestra la palabra "Start" antes de comenzar a mover el robot. El pedazo de código que le sigue:
+
+```cpp
+int ctr = 0;
+while ( w->canMove('W') ) {
+    w->moveRobot('W');
+    ctr = ctr + 1;
+}
+```
+
+ilustra el uso de los métodos `bool canMove(char)` y `void moveRobot(char)`:
+
+* `bool canMove(char)` - acepta como parámetro una de las siguientes letras: `'N'`, `'S'`, `'E'` o `'W'` y devuelve `true` si existe una puerta en esa dirección del cuarto donde se encuentra el robot.
+* `void moveRobot(char)` - acepta como parámetro una de las letras `'N'`, `'S'`, `'E'` o `'W'` y mueve el robot al cuarto próximo que se encuentra en esa dirección.
+
+En el ejemplo, el código está tratando de mover al robot todas las veces que pueda hacia el oeste (`W`) y contándo cada cuarto en esa dirección.
+
+---
+
+---
+
+
+## Sesión de laboratorio
+
+### Ejercicio 1 - Cuadrícula cuadrada de cuartos
+
+Supón que el robot se encuentra en el cuarto superior izquierdo (extremo noroeste) de un espacio **cuadrado** de cuartos, i.e. el espacio contiene igual número de filas y columnas de cuartos (como el de la Figura 1). Diseña un algoritmo para que el robot pueda computar el número de cuartos que hay en la cuadrícula.
+
+**Instrucciones**
+
+1. Descarga la carpeta `Repetitions-CountingSquares` de `Bitbucket` usando un terminal, moviéndote al directorio `Documents/eip`, y escribiendo el comando `git clone http://bitbucket.org/eip-uprrp/repetitions-countingsquares`.
+
+2. Carga a Qt creator el proyecto `CountingSquares`  haciendo doble "click" en el archivo `CountingSquares.pro` que se encuentra en la carpeta  `Documents/eip/Repetitions-CountingSquares` de tu computadora. 
+
+3. Configura el proyecto. El proyecto consiste de varios archivos. **Solo escribirás código en el archivo** `main.cpp`. Los demás archivos contienen funciones que implementan la funcionalidad de las instrucciones que entiende el robot.
+
+4. Al escribir tu algoritmo debes asegurarte de que el objeto `MainGameWindow` es creado usando el argumento `Mode::SQUARE_TOP_LEFT`.  Recuerda, el robot no sabe de antemano cuantos cuartos hay. Prueba tu algoritmo con algunos ejemplos.
+
+5. Si el tamaño de la cuadrícula es 3x3, ¿cuántos cuartos debe visitar el robot para completar tu algoritmo?. ¿Qué tal 4x4? ¿Qué tal $n \times n$ cuartos?
+
+6. Presume que deseamos ahorrar en la energía que utiliza el robot. ¿Puedes hacer un algoritmo que utilice menos movidas para el mismo tamaño de cuadrícula?
+
+7. Una vez hayas terminado el algoritmo, lo hayas hecho correcto y eficiente, entrégalo usando Entrega 1 en Moodle. En el encabezado del algoritmo escribe y explica la expresión que hayaste sobre cuántos cuartos debe visitar el robot para completar su tarea para una cuadrícula $n \times n$ (algo así como "El robot toma 2n+5 movidas, 5 para llegar al medio y 2n para contar el resto")
+
+
+### Ejercicio 2 -  Cuadrícula rectangular de cuartos
+
+**Instrucciones**
+
+1. Supón que ahora el robot se encuentra en el cuarto superior izquierdo (extremo noroeste) de un espacio **rectangular**  (no necesariamente cuadrado) de cuartos. Diseña un algoritmo para que el robot pueda computar el número de cuartos que hay en la cuadrícula.
+
+2. Para probar esta parte en programación debes asegurarte que objeto `MainGameWindow` es creado usando el argumento `Mode::RECT_TOP_LEFT`.
+
+3. Una vez hayas terminado el algoritmo, lo hayas hecho correcto y eficiente, impleméntalo en la función `main`. En el encabezado del programa escribe y explica la expresión que hayaste sobre cuántos cuartos debe visitar el robot para completar su tarea en una cuadrícula $m \times n$. 
+
+4. Entrega el archivo `main.cpp` con el código para calcular el número de cuartos del rectángulo usando Entrega 2 en Moodle.
+
+### Ejercicio 3 - Cuadrícula rectangular de cuartos, posición aleatoria
+
+**Instrucciones**
+
+1. Supón que ahora el robot comienza su recorrido en cualquiera de los cuartos de una cuadrícula **rectangular** (no necesariamente cuadrada).  Diseña un algoritmo para que el robot pueda computar el número de cuartos que hay en la cuadrícula.
+
+2. Para probar esta parte en programación debes asegurarte que objeto `MainGameWindow` es creado usando el argumento `Mode::RECT_RANDOM`.
+
+3. Una vez hayas terminado el algoritmo, lo hayas hecho correcto y eficiente, impleméntalo en la función `main`. En el encabezado del programa escribe y explica la expresión que hayaste sobre cuántos cuartos debe visitar el robot para completar su tarea en una cuadrícula $m \times n$. En este caso, el número de cuartos a visitar va a depender de la posición inicial del robot, así que expresa el peor de los casos, i.e. ¿cuántos cuartos debe visitar tu algoritmo si el robot comienza en el *peor* de los cuartos. 
+
+4. Entrega el archivo `main.cpp` con el código para calcular el número de cuartos del rectángulo con robot en posición aleatoria usando Entrega 3 en Moodle.
+
+
+
+### Ejercicio 4 -  Cuadrícula en forma de pirámide, posición aleatoria
+
+**Instrucciones**
+
+1. Supón que ahora el robot comienza su recorrido en cualquiera de los cuartos de una cuadrícula en forma de pirámide.  Diseña un algoritmo para que el robot pueda computar el número de cuartos que hay en la cuadrícula.
+
+2. Para probar esta parte en programación debes asegurarte que objeto `MainGameWindow` es creado usando el argumento `Mode::PYRAMID_RANDOM`.
+
+3. Una vez hayas terminado el algoritmo, lo hayas hecho correcto y eficiente, impleméntalo en la función `main`. En el encabezado del programa escribe y explica la expresión que hayaste sobre cuántos cuartos debe visitar el robot para completar su tarea en una cuadrícula $m \times n$. En este caso, el número de cuartos a visitar va a depender de la posición inicial del robot, así que expresa el peor de los caso, i.e. ¿cuántos cuartos visitaría tu algoritmo si el robot comienza en el *peor* de los cuartos.
+
+4. Entrega el archivo `main.cpp` con el código para calcular el número de cuartos de la pirámide con robot en posición aleatoria usando Entrega 4 en Moodle.
+
+
+
+---
+
+---
+
+## Entregas
+
+Utiliza los enlaces "Entrega" en Moodle para entregar el algoritmo del Ejercicio 1 y los  archivos `main.cpp` que contienen el código que implementaste en los ejercicios 2, 3 y 4. Recuerda utilizar buenas prácticas de programación, incluir el nombre de los programadores y documentar tu programa.
+
+
+
+---
+
+---
+
+## Referencias
+
+[1] Luther A. Tychonievich, Mark S. Sherriff, and Ryan M. Layer, http://nifty.stanford.edu/2011/feinberg-generic-scrolling-game/

countingSquares.pro

@@ -0,0 +1,31 @@
+#-------------------------------------------------
+#
+# Project created by QtCreator 2014-09-07T18:12:22
+#
+#-------------------------------------------------
+
+QT       += core gui
+
+greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
+
+TARGET = countingSquares
+TEMPLATE = app
+
+CONFIG += c++11
+SOURCES += main.cpp \
+    maingamewindow.cpp \
+    genericscrollingobject.cpp
+
+
+RESOURCES += \
+    countingSquares.qrc
+
+
+HEADERS += \
+    maingamewindow.h \
+    genericscrollingobject.h
+
+INCLUDEPATH += /usr/local/Cellar/box2d/2.3.0/include
+
+
+DEFINES += QT_NO_DEBUG_OUTPUT

countingSquares.qrc

@@ -0,0 +1,8 @@
+<RCC>
+    <qresource prefix="/">
+        <file>explosion.png</file>
+        <file>horse.png</file>
+        <file>horse.jpeg</file>
+        <file>robot.png</file>
+    </qresource>
+</RCC>

genericscrollingobject.cpp

@@ -0,0 +1,67 @@
+#include "genericscrollingobject.h"
+#include "maingamewindow.h"
+#include <QDebug>
+
+//
+// A class for the items that move.
+
+GenericScrollingObject::GenericScrollingObject(const std::string& filename, QGraphicsScene *scene,
+                                               int x, int y, int w, int h,
+                                               const QColor& transparency_color ,
+                                               MainGameWindow *parent
+                                               )
+{
+    scene->addItem(this);
+    myScene = scene;
+    alive = true;
+
+    // create a pixmap with invisible background
+    QPixmap pixmap(filename.c_str());
+    pixmap = pixmap.scaled(w,h);
+    const QBitmap mask = pixmap.createMaskFromColor(transparency_color);
+    pixmap.setMask(mask);
+    this->setPixmap(pixmap);
+
+    // set position and speed
+    myX = x;
+    myY = y;
+    toX = toY = 0;
+    myDirY = 0;
+    myDirX = 0;
+    myParent = parent;
+    setPos(myX,myY);
+}
+
+
+//
+// This method that is automatically called on each tick
+//
+void GenericScrollingObject::advance(int) {
+
+    myX = myX + myDirX;
+    myY = myY + myDirY;
+
+    if (myDirX != 0 && abs(myX-toX) < 10) { myDirX = 0; myX = toX;}
+    if (myDirY != 0 && abs(myY-toY) < 10) { myDirY = 0; myY = toY;}
+    
+    this->setPos(myX,myY);
+}
+
+
+void GenericScrollingObject::kill() {
+    alive = false;
+
+    // Show the explosion, instead of the robot
+    QPixmap pixmap(":explosion.png");
+    pixmap = pixmap.scaled(boundingRect().width(),boundingRect().height(),Qt::IgnoreAspectRatio,Qt::FastTransformation);
+
+    const QBitmap mask = pixmap.createMaskFromColor(QColor(Qt::black));
+    pixmap.setMask(mask);
+
+    setPixmap(pixmap);
+}
+
+
+
+
+

genericscrollingobject.h

@@ -0,0 +1,45 @@
+#ifndef GENERICSCROLLINGOBJECT_H
+#define GENERICSCROLLINGOBJECT_H
+#include <QGraphicsPixmapItem>
+#include <QGraphicsScene>
+#include <QBitmap>
+
+
+// A class for the items that move.
+
+class MainGameWindow;
+
+class GenericScrollingObject : public QGraphicsPixmapItem {
+public:
+    GenericScrollingObject(const std::string& filename, QGraphicsScene *scene,
+                           int x, int y, int w, int h,
+                           const QColor& transparency_color = QColor(0,255,0),
+                           MainGameWindow *parent = 0
+            );
+
+    int x() const { return myX; }
+    int y() const { return myY; }
+
+    //
+    // This method that is automatically called on each tick
+    //
+    void advance(int phase);
+
+
+    // given an integer number of pixels, move the item by that amount, vertically
+    void kill();
+    bool isAlive() {return alive;}
+    int myDirX, myDirY;
+    int myX, myY;
+    int toX, toY;
+
+private:
+    bool alive;
+    QGraphicsScene *myScene;
+    MainGameWindow *myParent;
+};
+
+
+
+
+#endif // GENERICSCROLLINGOBJECT_H

main.cpp

@@ -0,0 +1,45 @@
+#include <QApplication>
+#include "maingamewindow.h"
+#include <cmath>
+
+
+
+int main(int argc, char *argv[]) {
+    QApplication   a(argc, argv);
+
+    //MainGameWindow *w = new MainGameWindow(4,2);
+    //MainGameWindow *w = new MainGameWindow("xx x\nxx x\nx xx\n");
+    MainGameWindow *w = new MainGameWindow(Mode::SQUARE_TOP_LEFT);
+
+    w->show();
+
+    while (w->canMove('W'))
+        w->moveRobot('W');
+
+
+    while (w->canMove('N'))
+        w->moveRobot('N');
+    //w->moveRobot('N');
+
+    int width = 1;
+    w->display(width);
+    while (w->canMove('E')) {
+        width++;
+        w->moveRobot('E');
+        w->display(width);
+    }
+
+
+    int height = 1;
+    w->display(height);
+    while (w->canMove('S')) {
+        height++;
+        w->moveRobot('S');
+        w->display(height);
+    }
+
+    w->display("Total: " + QString::number(width * height));
+    w->moveRobot('J');
+
+    return a.exec();
+}

maingamewindow.cpp

@@ -0,0 +1,378 @@
+// Todo implement game modes: 1= square upper left, 2 = rect upper left, etc..
+
+#include "maingamewindow.h"
+#include <QDebug>
+#include <QTimer>
+#include <QTime>
+#include <QEventLoop>
+#include <QApplication>
+
+//
+// Initialices some of the data members
+//
+
+void MainGameWindow::initMembers() {
+    s = new QGraphicsScene(this);
+
+    s->setSceneRect(0,0,600,600);
+    this->setGeometry(0,0,600,600);
+
+    v = new QGraphicsView(s,this);
+    v->setGeometry(0,0,600,600);
+
+    pct_margin = .1;
+
+    srand(time(NULL));
+
+}
+
+//
+// Starts the timer that is used for animation purposes.
+//
+
+void MainGameWindow::startTheTimer() {
+    timer = new QTimer(s);
+    timer->connect(timer, SIGNAL(timeout()), s, SLOT(advance()));
+    timer->start(10);
+}
+
+//
+// Constructor that accepts a game mode argument. See the modes
+// definition in the .h.
+//
+
+MainGameWindow::MainGameWindow(Mode gameMode) : QMainWindow(0) {
+    initMembers();
+
+    // the initial row/col positions of the robot
+    uint initialX, initialY;
+
+    _rows = rand() % 9 + 2;
+    switch (gameMode) {
+        case Mode::SQUARE_TOP_LEFT:
+            _cols = _rows;
+            initialX = initialY = 0;
+            break;
+        case Mode::RECT_TOP_LEFT:
+            _cols = rand() % 9 + 2;
+            initialX = initialY = 0;
+            break;
+        case Mode::RECT_RANDOM:
+            _cols = rand() % 9 + 2;
+            initialX = rand() % _cols;
+            initialY = rand() % _rows;
+            break;
+        case Mode::PYRAMID_RANDOM:
+            _cols = (rand() % 4 + 2) * 2 + 1;
+            createPiramid();
+            assignValidPos(initialX, initialY);
+            break;
+    }
+
+    // This creates rectangular mazes
+    if (_maze == "") {
+        for (uint r = 0; r < _rows; r++) {
+            for (uint c = 0; c < _cols; c++) {
+                _maze.push_back('x');
+            }
+            _maze.push_back('\n');
+        }
+    }
+
+    qDebug() << "MainGameWindow::MainGameWindow(): width: " << this->width();
+    qDebug() << "_maze: " << _maze;
+
+    paintMaze(initialX, initialY);
+
+    startTheTimer();
+
+    v->show();
+}
+
+
+// Creates this type of pyramid, e.g. _cols = 7
+// 000x000
+// 00xxx00
+// 0xxxxx0
+// xxxxxxx
+
+void MainGameWindow::createPiramid() {
+    _maze = "";
+    _rows = _cols/2;
+
+
+    for (uint r = 0; r <= _rows + 1; r++) {
+        for (uint c = 0; c < _cols; c++) {
+            _maze.push_back( abs((int)c - (int)_rows) <= (int)r ? 'x':' ');
+        }
+        _maze.push_back('\n');
+    }
+
+    _rows++;
+}
+
+
+//
+// Randomly determines a valid initial position for the robot
+//
+
+void MainGameWindow::assignValidPos(uint &initialX, uint &initialY) {
+    qDebug() << _maze;
+    if (_cols <= 0 || _rows <= 0) {
+        qDebug() << "assignValidPos was called with 0 rows or cols!";
+        exit(1);
+    }
+
+    // throw the dice to determine initial random position
+    do {
+        initialX = rand() % _cols;
+        initialY = rand() % _rows;
+    } while (_maze.toStdString()[initialY * (_cols + 1) + initialX] != 'x');
+}
+
+//
+// Constructor that accepts number of rows and columns.
+//
+
+MainGameWindow::MainGameWindow(uint rows, uint cols) : QMainWindow(0) {
+    _rows = rows;
+    _cols = cols;
+
+    initMembers();
+
+    _maze = "";
+    for (uint r = 0; r < _rows; r++) {
+        for (uint c = 0; c < _cols; c++) {
+            _maze.push_back('x');
+        }
+        _maze.push_back('\n');
+    }
+
+    qDebug() << "MainGameWindow::MainGameWindow(): width: " << this->width();
+    qDebug() << "_maze: " << _maze;
+
+    paintMaze(0,0);
+
+    startTheTimer();
+
+    v->show();
+}
+
+MainGameWindow::MainGameWindow(const QString &maze) {
+    _maze = maze;
+    initMembers();
+
+    if (validMaze() ) {
+        qDebug() << "valid maze!!!!";
+        paintMaze(0,0);
+        startTheTimer();
+    }
+
+}
+
+//
+// Given a string that represents the maze, determines the number
+// of rows and cols. Returns false if the maze is malformed.
+//
+
+bool MainGameWindow::validMaze() {
+    char c;
+    uint ctr = 0;
+    _cols = 0; _rows = 0;
+    for (int i = 0; i < _maze.length(); i++){
+        c = _maze.toStdString()[i];
+        if (c == 'x' || c == ' ') ctr++;
+        else if (c == '\n') {
+            if (_cols == 0) _cols = ctr;
+            else if (_cols != ctr) return false;
+            ctr = 0;
+            _rows++;
+        }
+    }
+    qDebug() << "rows:" << _rows << " cols: " << _cols;
+    return true;
+}
+
+//
+// This is a delay that lets other events in the event loop
+// continue executing.
+//
+
+void delay(int ms)
+{
+    QTime dieTime= QTime::currentTime().addMSecs(ms);
+    while( QTime::currentTime() < dieTime )
+        QApplication::processEvents(QEventLoop::AllEvents,10);
+}
+
+//
+// Determines the underlying character of the maze.
+// This is used to determine if the robot is off the grid
+// or has entered a wall.
+//
+
+char MainGameWindow::posToChar() {
+    uint r, c;
+
+    posToRC(r, c);
+
+    if (r >= _rows || c >= _cols) return -1;
+    return _maze.toStdString()[r * (_cols + 1) + c];
+
+}
+
+//
+// Determines the poisition in row, column, based on the x, y position
+// of the robot.
+//
+
+void MainGameWindow::posToRC(uint &r, uint &c) {
+    uint realX = robot->myX - s->width() *  pct_margin;
+    uint realY = robot->myY - s->height() * pct_margin ;
+
+    r = round(static_cast<float>(realY) / rowHeight);
+    c = round(static_cast<float>(realX) / colWidth);
+}
+
+//
+// Given the direction determines if the robot may move in that
+// direction.
+//
+
+bool MainGameWindow::canMove(char dir) {
+
+    uint r, c;
+
+    posToRC(r, c);
+
+    switch(dir) {
+    case 'W': c--; break;
+    case 'E': c++; break;
+    case 'N': r--; break;
+    case 'S': r++; break;
+    default:
+        display("Bad direction: " + QString(dir));
+        return false;
+    }
+
+    if (r >= _rows || c >= _cols) return false;
+    else return _maze.toStdString()[r * (_cols + 1) + c] == 'x';
+}
+
+
+//
+// Given a character 'N', 'S', 'E', or 'W', moves the robot
+// one cell in that direction. If the target cell was invalid
+// then it destroys the robot.
+//
+
+void MainGameWindow::moveRobot(char dir) {
+    if (robot->isAlive()) {
+        uint deltaX = colWidth / 10;
+        uint deltaY = rowHeight / 10;
+
+        qDebug() << "car at:" << robot->myX;
+        switch(dir) {
+        case 'N': robot->toY = robot->myY - rowHeight; robot->myDirY = -deltaY; break;
+        case 'S': robot->toY = robot->myY + rowHeight; robot->myDirY = +deltaY; break;
+        case 'E': robot->toX = robot->myX + colWidth;  robot->myDirX = +deltaX; break;
+        case 'W': robot->toX = robot->myX - colWidth;  robot->myDirX = -deltaX; break;
+        default: display("Bad direction: " + QString(dir)); return;
+        }
+
+        qDebug() <<"colwidth" << colWidth;
+        qDebug() << "move to at:" << robot->toX;
+
+        while (robot->myDirX != 0 || robot->myDirY != 0)
+            delay(500);
+        robot->myDirX = robot->myDirY = 0;
+
+        if (posToChar() != 'x')
+            robot->kill();
+   }
+}
+
+//
+// Given a string, displays it in large letters.
+//
+
+void MainGameWindow::display(const QString &st) {
+    if (robot->isAlive()) {
+        msg->setHtml("<center>" + st + "</center>");
+        msg->show();
+        delay(500);
+        msg->hide();
+    }
+}
+
+//
+// Given an int, displays it in big letters.
+//
+
+void MainGameWindow::display(int n) {
+    display(QString::number(n));
+}
+
+
+// Paints the maze based on the contents of the _maze string.
+// Also creates the robot and the text box for display.
+
+void MainGameWindow::paintMaze(uint initialX, uint initialY) {
+
+    pct_margin = 1.0/( _cols > _rows ? _cols + 2 : _rows + 2);
+
+    qDebug() << "pct_margin " << pct_margin;
+    uint fromY = s->height()*pct_margin, toY = s->height()*(1-pct_margin);
+
+    qDebug() << "toX, toY" << fromY << "," << toY ;
+    uint fromX = s->width()*pct_margin,  toX = s->width()*(1-pct_margin);
+
+    rowHeight = (toY - fromY) / _rows;
+    colWidth =  (toX - fromX) / _cols;
+
+
+    uint strPos = 0;
+    QBrush black(Qt::black);
+    QBrush white(Qt::white);
+
+    for (uint i = 0; i < _rows; i++) {
+        uint y = i * rowHeight + s->height()*pct_margin;
+        for (uint j = 0; j < _cols; j++) {
+            uint x = j * colWidth + s->width() * pct_margin;
+            qDebug() << x << " " << y;
+            s->addRect(x, y, colWidth, rowHeight, QPen(Qt::SolidLine),
+                       _maze.at(strPos) == 'x' ? white : black);
+            strPos++;
+        }
+        strPos++;
+    }
+
+    // // Create the robot
+    //
+    // int initialX, initialY;
+    //
+    // // throw the dice to determine initial random position
+    // do {
+    //     initialX = rand() % _cols;
+    //     initialY = rand() % _rows;
+    //
+    // } while (_maze.toStdString()[initialY * (_cols + 1) + initialX] != 'x');
+
+    robot = new GenericScrollingObject(":robot.png", s,
+                                       colWidth * initialX  + s->width() * pct_margin,
+                                       rowHeight * initialY + s->height() * pct_margin, colWidth,rowHeight,
+                                       QColor(Qt::white), this);
+
+
+    // Create the text box that will be used for the display
+
+    msg = new QGraphicsTextItem;
+    msg->setPos(0, s->height()/2);
+    msg->setTextWidth(s->width());
+    msg->setHtml("<center>Barev</center>");
+    msg->setFont(QFont("Helvetica",90));
+    msg->setDefaultTextColor(Qt::green);
+    msg->hide();
+    s->addItem(msg);
+
+}

maingamewindow.h

@@ -0,0 +1,66 @@
+#ifndef MAINGAMEWINDOW_H
+#define MAINGAMEWINDOW_H
+#include <cmath>
+#include <QGraphicsView>
+#include <QMainWindow>
+#include <QGraphicsScene>
+#include <QBitmap>
+#include <QGraphicsView>
+#include <genericscrollingobject.h>
+//
+// Constants for the types of objects. We use them to determine what collisions are
+// worth processing.
+//
+const int RECT_MODE = 1;
+
+class GenericScrollingObject;
+
+typedef unsigned int uint;
+
+enum class Mode {SQUARE_TOP_LEFT,  RECT_TOP_LEFT, RECT_RANDOM, PYRAMID_RANDOM};
+
+class MainGameWindow: public QMainWindow {
+
+public:
+
+    MainGameWindow(uint rows, uint cols);
+    MainGameWindow(const QString &maze);
+    MainGameWindow(Mode gameMode);
+
+
+    void moveRobot(char dir);
+    bool canMove(char dir);
+
+    void display(const QString &st);
+    void display(int n);
+
+private:
+    QGraphicsScene *s;
+    QGraphicsView  *v;
+    uint _rows, _cols;
+
+    QString _maze;
+    GenericScrollingObject *robot;
+    QTimer *timer;
+
+    uint rowHeight, colWidth;
+    float pct_margin;
+    QGraphicsTextItem *msg;
+
+    void paintMaze(uint initialX, uint initialY);
+    void initMembers();
+    bool validMaze();
+    void createPiramid();
+    void assignValidPos(uint &initialX, uint &initialY);
+    void startTheTimer();
+    void posToRC(uint &r, uint &c);
+    char posToChar();
+    void setMaze(const QString &maze) { _maze = maze; }
+
+};
+
+void delay(int ms);
+
+#define PCT_MARGIN 0.1
+
+#endif // MAINGAMEWINDOW_H