POO Final 2012

#include <iostream>
#include <string>
#include <sstream>
#include <fstream>

using namespace std;

class Exception {
    string _message;
public:
    Exception(string message) : _message(message) { }

    string message() const
    {
        return _message;
    }
};


class Player {
    string _description;
    float _M;

public:
    Player(string description, float montant)
    {
        if (montant < 0)
            throw Exception("The amount should be positive");

        _M = montant;
        _description = description;
    }

    float montant() const
    {
        return _M;
    }

    void add(float x)
    {   if (x < 0)
            throw Exception("You can only add positive numbers");

        _M += x;
    }

    void sub(float x)
    {
        if (x > _M)
            throw Exception("The amount you're trying to remove is greater than the player's money");
        else if (x < 0)
            throw Exception("You can only substract positive numbers");

        _M -= x;
    }
};


class Property {
protected:
    string _nom;

public:
    Property(string nom) : _nom(nom) { }

    virtual void passThrough(Player *x) { }

    virtual void land(Player *x) = 0;

    virtual ~Property() { }
};

class Go : public Property {
    float pass_amount = 200;
    float land_amount = 400;

public:
    Go() : Property("Go") { }

    void passThrough(Player *x)
    {
        x->add(pass_amount);
    }

    void land(Player *x)
    {
        x->add(land_amount);
    }

    ~Go() { }
};

class Land : public Property {
    float _price;
    Player *_owner = 0;

public:
    Land(string nom, float price) : Property(nom)
    {
        if (price < 0)
            throw Exception("Price must be a positive value");

        _price = price;
    }

    void land(Player *x)
    {
        if (_owner == 0)
        {
            try
            {
              x->sub(_price);
            }
            catch (Exception e)
            {
                throw e;
            }

            _owner = x;
        }

        else if (_owner != x)
        {
            try
            {
              x->sub(_price / 10);
            }
            catch (Exception e)
            {
                throw e;
            }

            _owner->add(_price / 10);
        }

    }

};


class Monopoly {
    Player* players[6];
    Property* properties[36];
    int position[6];
    int playerCount = 0;

public:
    Monopoly()
    {
        for (int i = 0; i < 6; i++)
        {
            players[i] = 0;
            position[i] = 0;
        }

        properties[0] = new Go;

        stringstream s;

        for (int i = 1; i < 36; i++)
        {
            s << "L" << i;
            properties[i] = new Land(s.str(), 25);
            s.clear();
        }
    }

    Monopoly(Monopoly const &M)
    {
        for (int i = 0; i < 6; i++)
        {
            players[i] = M.players[i];
            position[i] = M.position[i];
        }

        properties[0] = new Go;

        for (int i = 1; i < 36; i++)
        {
            properties[i] = M.properties[i];
        }
    }

    virtual ~Monopoly()
    {
        for (int i = 0; i < 36; i++)
        {
            delete properties[i];
        }
    }

    Monopoly operator=(Monopoly const &M)
    {
        for (int i = 0; i < 6; i++)
        {
            players[i] = M.players[i];
            position[i] = M.position[i];
        }


        for (int i = 1; i < 36; i++)
        {
            delete properties[i];
            properties[i] = M.properties[i];
        }
    }

    void addPlayer(Player *p)
    {
        if (playerCount == 6)
            throw Exception("Maximum number of players reached");

        players[playerCount++] = p;
    }

    void movePlayer(Player *p, int n)
    {
        int index;
        for (int i = 0; i < playerCount; i++)
        {
            if (players[i] == p)
            {
                index = i;
                break;
            }
        }

        for (int i = position[index]; i < position[index] + n - 1; i++)
        {
            properties[i % 36] -> passThrough(p);
        }

        position[index] = (position[index] + n) % 36;

        try
        {
            properties[position[index]] -> land(p);
        }

        catch (Exception e)
        {
            if (e.message() == "The amount you're trying to remove is greater than the player's money")
            {
                cout << "You don't have enough money. You lost" << endl;


                for (int i = index; i < playerCount - 1; i++)
                {
                    players[i] = players[i+1];
                    position[i] = position[i+1];
                }

                playerCount -= 1;

                players[playerCount] = 0;
                position[playerCount] = 0;

            }
        }
    }

    void movePlayer(Player *p, Property *l)
    {
        int indexl;
        for (int i = 0; i < 36; i++)
        {
            if (properties[i] == l)
            {
                indexl = i;
                break;
            }
        }

        int indexp;
        for (int i = 0; i < playerCount; i++)
        {
            if (players[i] == p)
            {
                indexp = i;
                break;
            }
        }

        indexp < indexl ? movePlayer(p, indexl - indexp) : movePlayer(p, 36 + indexl - indexp);
    }

};


bool diff(string file1, string file2)
{
    ifstream f1(file1, ios::binary);
    ifstream f2(file2, ios::binary);

    if (f1.fail())
        throw Exception("File not found " + file1);
    else if(f2.fail())
        throw Exception("File not found " + file2);

    char b1;
    char b2;

    while (!f1.eof() && !f1.eof())
    {
        f1.read(&b1, 1);
        f2.read(&b2, 1);

        if(b1 != b2)
        {

            f1.close();
            f2.close();

            return true;
        }
    }

    f1.close();
    f2.close();

    return false;
}

int main()
{
    Monopoly game;
    Player *p1 = new Player("Chris", 2000);
    Player *p2 = new Player("Brian", 100);

    game.addPlayer(p1);
    game.addPlayer(p2);
    game.movePlayer(p1, 10);
    game.movePlayer(p2, 46);
    cout << p1->montant() << endl;
    cout << p2->montant() << endl;

    delete p1;
    delete p2;
    return 0;

}