void Point::setValue(unsigned int i, double v)
{
if (i >= __dim) {
throw OutOfBoundsEx(__dim, i);
}
__values[i] = v;
}
void Game::addStrategic(unsigned x, unsigned y, Strategy *s) {
int index = y + (x * __width);
if (y >= __width || x >= __height) throw OutOfBoundsEx(__width, __height, x, y);
if (__grid[index]) throw PositionNonemptyEx(x, y);
__grid[index] = new Strategic(*this, Position(x, y), STARTING_AGENT_ENERGY, s);
}
void Game::addSimple(const Position &position, double energy) { // used for testing only
int index = position.y + (position.x * __width);
if (position.y >= __width || position.x >= __height) throw OutOfBoundsEx(__width, __height, position.x, position.y);
if (__grid[index]) throw PositionNonemptyEx(position.x, position.y);
__grid[index] = new Simple(*this, position, energy);
}
void Game::addSimple(unsigned y, unsigned x, double energy) {
int index = y + (x * __width);
if (y >= __width || x >= __height) throw OutOfBoundsEx(__width, __height, x, y);
if (__grid[index]) throw PositionNonemptyEx(x, y);
__grid[index] = new Simple(*this, Position(x, y), energy);
}
void Game::addStrategic(const Position &position, Strategy *s) {
int index = position.y + (position.x * __width);
if (position.y >= __width || position.x >= __height) throw OutOfBoundsEx(__width, __height, position.x, position.y);
if (__grid[index]) throw PositionNonemptyEx(position.x, position.y);
__grid[index] = new Strategic(*this, position, STARTING_AGENT_ENERGY, s);
}
const double & Point::operator[] (unsigned int index) const
{
if (index >= __dim)
throw OutOfBoundsEx(__dim,index);
return __values[index];
}
void Game::addAdvantage(unsigned x, unsigned y) {
int index = y + (x * __width);
if (y >= __width || x >= __height) throw OutOfBoundsEx(__width, __height, x, y);
if (__grid[index]) throw PositionNonemptyEx(x, y);
__grid[index] = new Advantage(*this, Position(x, y), STARTING_RESOURCE_CAPACITY);
}
double Point::getValue(unsigned int i) const
{
if (i >= __dim) {
throw OutOfBoundsEx(__dim, i);
}
return __values[i];
}
void Game::addAdvantage(const Position &position) {
int index = position.y + (position.x * __width);
if (position.y >= __width || position.x >= __height) throw OutOfBoundsEx(__width, __height, position.x, position.y);
if (__grid[index]) throw PositionNonemptyEx(position.x, position.y);
__grid[index] = new Advantage(*this, position, STARTING_RESOURCE_CAPACITY);
}
double Point::getValue(unsigned int index) const
{
if (index >= __dim)
throw OutOfBoundsEx(__dim,index);
return __values[index];
}
void Game::addFood(const Position &position) {
int location = position.y + (position.x * __width);
if (position.x < 0 || position.x >= __height || position.y < 0 || position.y >= __width)
throw OutOfBoundsEx(__width, __height, position.x, position.y);
if (__grid[location])
throw PositionNonemptyEx(position.x, position.y);
__grid[location] = new Food(*this, position,STARTING_RESOURCE_CAPACITY);
}
void Game::addSimple(const Position &position, double energy) {
if (position.y >= __width || position.x >= __height) {
throw OutOfBoundsEx(__width, __height, position.x, position.y);
}
if (__grid[(position.x * __width)+position.y]) {
throw PositionNonemptyEx(position.x, position.y);
}
__grid[(position.x * __width)+position.y] = new Simple(*this, position, energy);
}
void Game::addAdvantage(unsigned x, unsigned y) {
if (y >= __width || x >= __height) {
throw OutOfBoundsEx(__width, __height, x, y);
}
if (__grid[(x *__width)+y]) {
throw PositionNonemptyEx(x, y);
}
__grid[(x *__width)+y] = new Advantage(*this, Position(x, y), STARTING_RESOURCE_CAPACITY);
}
void Game::addAdvantage(const Position &position) {
if (position.y >= __width || position.x >= __height) {
throw OutOfBoundsEx(__width, __height, position.x, position.y);
}
if (__grid[(position.x *__width)+position.y]) {
throw PositionNonemptyEx(position.x, position.y);
}
__grid[(position.x *__width)+position.y] = new Advantage(*this, position, STARTING_RESOURCE_CAPACITY);
}
void Game::addStrategic(const Position &position, Strategy *s) {
if (position.y >= __width || position.x >= __height) {
throw OutOfBoundsEx(__width, __height, position.x, position.y);
}
if (__grid[(position.x * __width)+position.y]) {
throw PositionNonemptyEx(position.x, position.y);
}
__grid[(position.x * __width)+position.y] = new Strategic(*this, position, STARTING_AGENT_ENERGY, s);
}
void Game::addSimple(unsigned x, unsigned y) {
if (y >= __width || x >= __height) {
throw OutOfBoundsEx(__width, __height, x, y);
}
if (__grid[(x*__width)+y]) {
throw PositionNonemptyEx(x, y);
}
__grid[(x*__width)+y] = new Simple(*this, Position(x, y), STARTING_AGENT_ENERGY);
}
void Point::setValue(unsigned int new_dim,double Value)
{
if (new_dim >= __dim)
throw OutOfBoundsEx(__dim,new_dim);
__values[new_dim] = Value;
}
void Game::addAdvantage(unsigned x, unsigned y) {
Position pos(x,y);
int location = y +(x *__width);
if (x < 0 || x >= __height || y < 0 || y >= __width)
throw OutOfBoundsEx(__width, __height, x, y);
if (__grid[location])
throw PositionNonemptyEx(x, y);
__grid[location] = new Advantage(*this, pos, STARTING_RESOURCE_CAPACITY);
}
void Game::addStrategic(unsigned x, unsigned y, Strategy *s) {
Position pos(x,y);
int location = y + (x * __width);
if (x < 0 || x >= __height || y < 0 || y >= __width)
throw OutOfBoundsEx(__width, __height, x, y);
if (__grid[location])
throw PositionNonemptyEx(x, y);
__grid[location] = new Strategic(*this, pos, STARTING_AGENT_ENERGY,s);
}
const Piece* Game::getPiece(unsigned int x, unsigned int y) const
{
if(y >= __width || x >=__height)
throw OutOfBoundsEx(__height, __width, x, y);
if (__grid[y + (x * __width)] == nullptr) throw PositionEmptyEx(x, y);
return __grid[y + (x * __width)];
}
void Game::addSimple(unsigned y, unsigned x, double energy) {
if (y >= __width || x >= __height) {
throw OutOfBoundsEx(__width, __height, x, y);
}
if (__grid[(x*__width)+y]) {
throw PositionNonemptyEx(x, y);
}
__grid[(x*__width)+y] = new Simple(*this, Position(x, y), energy);
}
void Game::addSimple(const Position &position, double energy) {
//exception for out of bounds
int location = position.y + (position.x * __width);
if(position.x < 0 || position.x >= __height || position.y < 0 || position.y >= __width){
throw OutOfBoundsEx(__width,__height,position.x,position.y);
}
if(__grid[location])
throw PositionNonemptyEx(position.x,position.y);
__grid[location] = new Simple(*this, position,energy);
}
const Piece *Game::getPiece(unsigned int x, unsigned int y) const {
//TODO would i return the piece that is at that location??
int location = y +(x* __width); //will look for this location on the grid
if (x < 0 || x >= __height || y < 0 || y >= __width)
throw OutOfBoundsEx(__width, __height, x, y);
if (__grid[location] == nullptr)
throw PositionEmptyEx(x, y);
return __grid[location]; //returns the location on the grid
}
void Game::addSimple(unsigned x, unsigned y, double energy) {
//exception for out of bounds
Position pos(x,y);
int location = y + (x * __width);
if (x < 0 || x >= __height || y < 0 || y >= __width)
throw OutOfBoundsEx(__width, __height, x, y);
if (__grid[location])
throw PositionNonemptyEx(x, y);
__grid[location] = new Simple(*this, pos,energy);
}
void Game::addSimple(unsigned x, unsigned y)
{
int place = y + x * __width;
if (y >= __width || x >= __height)
throw OutOfBoundsEx(__width, __height, x, y);
if (__grid[place])
throw PositionNonemptyEx(x, y);
__grid[place] = new Simple(*this, Position(x, y), STARTING_AGENT_ENERGY);
}
void Game::addSimple(unsigned int x, unsigned int y)
{ int i = x * __width + y;
if( y >= __width || x >= __height)
throw OutOfBoundsEx(__height, __width, x, y);
if(__grid[i])
throw PositionNonemptyEx(x, y);
__grid[i] = new Simple(*this, Position(x,y), Game::STARTING_AGENT_ENERGY);
}
void Game::addAdvantage(const Position &position){
Advantage *newAdvantage = new Advantage(*this, position, STARTING_RESOURCE_CAPACITY);
if((position.y*__width + position.x)>__grid.size() || position.x > __width)
throw OutOfBoundsEx(__width,__height,position.x,position.y);
if((__grid[position.y*__width + position.x])!=nullptr)
throw PositionNonemptyEx(position.x,position.y);
__grid[position.y*__width + position.x] = newAdvantage;
}
void Game::addStrategic(const Position &position, Strategy *s/* = new DefaultAgentStrategy()*/){
Strategic *newStrat = new Strategic(*this, position, STARTING_AGENT_ENERGY,s);
if((position.y*__width + position.x)>__grid.size() || position.x > __width)
throw OutOfBoundsEx(__width,__height,position.x,position.y);
if((__grid[position.y*__width + position.x])!=nullptr)
throw PositionNonemptyEx(position.x,position.y);
__grid[position.y*__width + position.x] = newStrat;
}
void Game::addSimple(const Position &position, double energy){
Simple *newSimple = new Simple(*this, position, STARTING_AGENT_ENERGY);
if((position.y*__width + position.x)>__grid.size() || position.x > __width)
throw OutOfBoundsEx(__width,__height,position.x,position.y);
if((__grid[position.y*__width + position.x])!=nullptr)
throw PositionNonemptyEx(position.x,position.y);
__grid[position.y*__width + position.x] = newSimple;
}
void Game::addAdvantage(unsigned int x, unsigned int y)
{
int i = x * __width + y;
if(y >= __width || x>=__height)
throw OutOfBoundsEx(__height, __width, x, y);
if(__grid[i])
throw PositionNonemptyEx(x, y);
__grid[i] = new Advantage(*this, Position(x,y), Game::STARTING_RESOURCE_CAPACITY);
}
