Trying to create a Main for Turtle Graphics.

[neyels]

I will be honest, this is a homework a homework question.(kind of).

I'm taking my first year programming class, and I'm at the end our professor gave us two broken class codes and said if we fix them before our exam, it'll help us, and we can bring whatever codes we write beforehand in. (However, didn't explain what the exam will be until we start)

I've fixed both, and furthermore, I believe they're part of a Turtle Graphics Program. The closest thing we've done to that is a VERY elementary ACSCII ART assignment.

So, what I'd like to ask is, how should I go about trying to implement these classes into a main, and what should I do with the pen.h

I'd rather not have anyone actually write out full code, but just advice as to where to start and what to do.

Canvass .CPP

  #include "Canvas.h"

bool Canvas::growHoriztontal()
{
	if (getWidth() < MAX_HORI) {
		for (unsigned int i = 0; i < getHeight(); i++) {
			_canvas[i].push_back(false);
		}
		return true;
	}
	return false;
}

bool Canvas::growVertical()
{
	if (getHeight() != MAX_VERTI) {
		_canvas.push_back(std::vector<bool>(getWidth(), false));
		return true;
	}
	return false;
}

bool Canvas::processDrawAction(PEN_AXIS plane, int extent)
{
	if (plane == DEPTH) {
		if (_currInstruction != NULL) {
			_instructions.push_back(_currInstruction);
		}
		if (extent == 1) {
			_instructions.push_back((new Instruction(SET, _pen._x, _pen._y)));
		}
	}
	else if (isPenDown()) {
		INSTRUCTION newInstruction = plane == HORI ? DRH : DRV;
		if (_currInstruction != NULL) {
			if (_currInstruction->cmd == newInstruction) {
				_currInstruction->arg1 += extent;
			}
			else {
				_instructions.push_back(_currInstruction);
				_currInstruction = new Instruction(newInstruction, extent);
			}
		}
		else {
			_currInstruction = new Instruction(newInstruction, extent);
		}
		return true;
	}
	return false;
}

void Canvas::stop()
{
	if (_currInstruction != NULL) {
		_instructions.push_back(_currInstruction);
		_currInstruction = NULL;
	}
}

void Canvas::mark()
{
	if (isPenDown())
	{
		_canvas[_pen._y][_pen._x] = true;
	}
}

Canvas::Canvas()
{
	for (unsigned int i = 0; i < INIT_DIM; i++) {
		_canvas.push_back(std::vector<bool>(INIT_DIM, false));
	}
}

void Canvas::draw(std::ostream & sout, bool showDetails)
{
	if (showDetails) {
		sout << "Pen Position: " << _pen._x << "," << _pen._y << std::endl;
		sout << "Image Size:" << getWidth() << "," << getHeight() << std::endl;
	}

	for (unsigned int y = 0; y < getHeight(); y++) {
		for (unsigned int x = 0; x < getWidth(); x++) {
			if (_pen._show && _pen._x == x && _pen._y == y) {
				sout << (_pen._down ? PEN_STATUS_DOWN : PEN_STATUS_UP);
			}
			else {
				sout << (_canvas[y][x] ? '*' : ' ');
			}
		}
		sout << std::endl;
	}
}

unsigned int Canvas::getWidth()
{
	return _canvas[0].size();
}

unsigned int Canvas::getHeight()
{
	return _canvas.size();
}

unsigned int Canvas::getPenX()
{
	return _pen._x;
}

unsigned int Canvas::getPenY()
{
	return _pen._y;
}

bool Canvas::movePen(PEN_AXIS pa, bool positive)
{
	mark();
	if (pa == HORI) {
		if (positive) {
			if (_pen._x + 1 == getWidth())
			{
				if (!growHoriztontal()) {
					return false;
				}
			}
			_pen._x++;
			processDrawAction(pa, 1);
			return true;
		}
		else {
			if (_pen._x <= 0) {
				return false;
			}
			_pen._x--;
			processDrawAction(pa, -1);
			return true;
		}
	}
	else {
		if (positive) {
			if (_pen._y + 1 == getHeight())
			{
				if (!growVertical()) {
					return false;
				}
			}
			_pen._y++;
			processDrawAction(pa, 1);
			return true;
		}
		else {
			if (_pen._y <= 0) {
				return false;
			}
			_pen._y--;
			processDrawAction(pa, -1);
			return true;
		}
	}

	return false;
}

void Canvas::togglePen()
{
	processDrawAction(DEPTH, _pen._down ? -1 : 1);
	_pen._down = !_pen._down;
}

void Canvas::toggleShowPen()
{
	_pen._show = !_pen._show;
}

bool Canvas::isPenDown()
{
	return _pen._down;
}

bool Canvas::doCommand(ACTION a)
{
	switch (a) {
	case LEFT:
		movePen(HORI, false);
		break;
	case RIGHT:
		movePen(HORI, true);
		break;
	case DOWN:
		movePen(VERTI, true);
		break;
	case UP:
		movePen(VERTI, false);
		break;
	case PEN_TOGGLE:
		togglePen();
		break;
	case PEN_POSITION:
		toggleShowPen();
		break;
	case STOP:
		stop();
		break;
	}

	return false;
}

std::vector<Instruction*> Canvas::getInstructions()
{
	return _instructions;
}

Canvass.h

#pragma once
#include <vector>
#include <iostream>
#include "Pen.h"
#include "Instruction.h"

enum ACTION { UP, DOWN, LEFT, RIGHT, PEN_TOGGLE, STOP, PEN_POSITION, NONE };
const unsigned int INIT_DIM = 4, MAX_HORI = 50, MAX_VERTI = 18;

class Canvas
{
private:
	Pen _pen;
	std::vector<std::vector<bool>> _canvas;
	std::vector<Instruction*> _instructions;
	Instruction* _currInstruction = NULL;
	bool growHoriztontal();
	bool growVertical();
	bool processDrawAction(PEN_AXIS, int);
	void stop();
	void mark();

public:
	Canvas();
	void draw(std::ostream&, bool = true);
	unsigned int getWidth();
	unsigned int getHeight();
	unsigned int getPenX();
	unsigned int getPenY();
	bool movePen(PEN_AXIS, bool);
	void togglePen();
	void toggleShowPen();
	bool isPenDown();
	bool doCommand(ACTION);
	std::vector<Instruction*> getInstructions();
};

instructions.cpp

#include "Instruction.h"

Instruction::Instruction(INSTRUCTION cmd, int arg1)
{
	this->cmd = cmd;
	this->arg1 = arg1;
	this->numArg = 1;
}

Instruction::Instruction(INSTRUCTION cmd, unsigned int arg1, unsigned int arg2)
{
	this->cmd = cmd;
	this->arg1 = static_cast<int>(arg1);
	this->arg2 = static_cast<int>(arg2);
	this->numArg = 2;
}

std::string Instruction::ToString()
{
	std::string r;
	switch (cmd)
	{
	case SET:
		r = "SET ";
		break;
	case DRV:
		r = "DRV ";
		break;
	case DRH:
		r = "DRH ";
		break;
	}

	r += std::to_string(arg1);
	if (numArg == 2) {
		r += " " + std::to_string(arg2);
	}
	return r;
}

instructions.h

#pragma once

#include <string>

enum INSTRUCTION { SET, DRV, DRH };
struct Instruction
{
public:
	INSTRUCTION cmd;
	int arg1, arg2;
	unsigned int numArg;
	Instruction(INSTRUCTION cmd, int arg1);
	Instruction(INSTRUCTION cmd, unsigned int arg1, unsigned int arg2);
	std::string ToString();
};

Pen.h

#pragma once
enum PEN_AXIS { HORI, VERTI, DEPTH };
const char PEN_STATUS_UP = 'O', PEN_STATUS_DOWN = 'X';
struct Pen
{
public:

	unsigned int _x = 0, _y = 0;
	bool _down = false, _show = true;
};

Thanks guys, I have tried extensively on my own, but simply can't figure it ouyt.

*EDIT* If you guys see any glaring errors please do point them out :D

[Thomas1965]

You can use the canvas class like this:

#include <iostream>
#include <string>
#include "canvas.h"

int main()
{
  Canvas canvas;

  canvas.doCommand(UP);
  canvas.movePen(HORI, true);
  canvas.movePen(VERTI, true);
  canvas.doCommand(DOWN);
  canvas.draw(std::cout);
}

OUTPUT

Pen Position: 1,2
Image Size:4,4


 O

Pen.h is used inside the Canvas class so you don't have to bother about it.