Página principal | Lista de namespace | Lista de archivos

propiedad.h

00001 /***********************************************************************************
00002  *  CLASE PROPIEDAD
00003  *  Clase que representa una propiedad del juego del monopoly. Es una clase derivada
00004  *  de la clase casilla y a su vez es una clase base de los distintos tipos de 
00005  *  propiedades del juego: calle, estacion y servicio.
00006  *
00007  *  Esta clase tiene como particularidad que se puede comprar y por lo tanto tendrá
00008  *  un propietario.
00009  *
00010  *  Esta clase hereda de la clase casilla el número de casilla y el nombre y aporta
00011  *  como atributos el precio de la propiedad, su hipoteca y el estado hipotecado e
00012  *  hipotecable (ambos verdadero o falso)
00013  *
00014  *  Requiere:
00015  *     - clase casilla (herencia)
00016  *     - clase propietario (y derivadas jugador y banca)
00017  *     - clase monopolio
00018  *     - clases de la STL string y list
00019  *
00020  *  Autor: Javier Aragón Zabalegui (PFC para la uc3m: street Master's)
00021  *  Contacto: 100039831@alumnos.uc3m.es
00022  *  version 1.0
00023  **********************************************************************************/
00024 
00025 #ifndef __PROPIEDAD__
00026 #define __PROPIEDAD__
00027 
00028 #include "propietario.h"
00029 #include "jugador.h"
00030 #include "banca.h"
00031 #include "monopolio.h"
00032 #include "casilla.h"
00033 #include <string>
00034 #include <list>
00035 using namespace std;
00036 
00037 class propiedad : public casilla {
00038 
00039  private:
00040 
00041   //Atributos
00042   long _precio;
00043   long _hipoteca;
00044   bool _hipotecado;
00045   bool _hipotecable;
00046 
00047  protected:  
00048   propietario *_esPropiedad;
00049   monopolio* _perteneceMonopolio;
00050 
00051  public:
00052 
00053   // Constructor por defecto
00054   propiedad ();
00055   
00056   // Constructor explícito
00057   propiedad ( int numero, string nombre, string nombreCorto, long precio, long hipoteca, bool hipotecado, bool hipotecable, 
00058               propietario *p);
00059   
00060   // Copy constructor
00061   propiedad (const propiedad& right);
00062 
00063   // Operador menor
00064   bool operator< ( propiedad *compara );
00065   
00066   // Operador de asignación
00067   propiedad& operator= (const propiedad& right);
00068   
00069   // Sobrecarga del operador de salida
00070   friend ostream& operator<< (ostream& os, propiedad* c);
00071 
00072   // Destructor
00073   ~propiedad ();
00074 
00075   // Métodos GET
00076   long get_precio () const;
00077   long get_hipoteca () const;
00078   bool get_hipotecado () const;
00079   bool get_hipotecable () const; 
00080   propietario* get_esPropiedad () const;
00081   monopolio* get_perteneceMonopolio () const;
00082   long get_deshipoteca () const;
00083 
00084 
00085   // Métodos SET
00086   void set_precio (long value);
00087   void set_hipoteca (long value);
00088   void set_hipotecado (bool value);
00089   void set_hipotecable (bool value);
00090   void set_esPropiedad (propietario* j);
00091   void set_perteneceMonopolio ( monopolio* perteneceMonopolio );
00092 
00093   // OTROS MÉTODOS
00094   
00099   bool esMonopolio ( string color );
00100 
00106   void crearMonopolio ( string color );
00107 
00112   void asignarMonopolio ( propiedad* p );
00113 
00117   string verColor ();
00118   
00122   bool disponible ();
00123 
00124   //Metodos virtuales: POLIMORFISMOS
00125 
00129   virtual string mostrar ();
00130 
00136   virtual string dibujarCasillaHorizontal ( int fila, int anchoCasilla );
00137   
00143   virtual string dibujarCasillaVertical ( int fila, int anchoCasilla );
00144 
00154   virtual string dibujarCasillaEnTablero (); 
00155   
00159   virtual long calcularAlquiler ( jugador *j );
00160 
00165   virtual int adjudicarA ( propietario* j );
00166 
00172   int pagarAlquiler ( jugador* j );
00173   
00180   virtual int accion ( jugador *player );
00181 
00186   virtual int comprar ( jugador* j );
00187   
00191   bool mismoPropietario ( propiedad* p );
00192 
00196   virtual string infoString ();
00197 
00202   virtual int hipotecar ();
00203 
00208   virtual int deshipotecar ();
00209   
00213   virtual bool esOfertable ();
00214 
00218   set <propiedad*> get_monopolioCompleto ( propiedad *p );
00219 
00224   virtual void liberar ( propietario *j);
00225 
00230   virtual string guardar();
00231 
00235   bool monopolioLibre ();
00236 
00241   bool ultimaPropiedadMonopolio ( jugador *j );
00242 
00247   bool unicoPoseedorMonopolio ( jugador *j );  
00248   
00252   bool poseeParteMonopolio ( jugador *j );
00253 
00258   bool ultimaPropiedadMonopolioOtroJugador ( jugador *j );
00259 
00260 };
00261 
00262 inline long propiedad::get_precio () const
00263 {
00264   return _precio;
00265 }
00266 
00267 inline long propiedad::get_hipoteca () const
00268 {
00269   return _hipoteca;
00270 }
00271 
00272 inline bool propiedad::get_hipotecable () const
00273 {
00274   return _hipotecable;
00275 }
00276 
00277 inline bool propiedad::get_hipotecado () const
00278 {
00279   return _hipotecado;
00280 }
00281 
00282 inline propietario* propiedad::get_esPropiedad () const
00283 {
00284   return _esPropiedad;
00285 }
00286 
00287 inline monopolio* propiedad::get_perteneceMonopolio () const
00288 {
00289   return _perteneceMonopolio;
00290 }
00291  
00292 inline long propiedad::get_deshipoteca () const
00293 {
00294   return ( _hipoteca * ( 12 / 10 ) );
00295 }
00296 
00297 inline void propiedad::set_precio (long value)
00298 {
00299   _precio = value;
00300 }
00301 
00302 inline void propiedad::set_hipoteca (long value)
00303 {
00304   _hipoteca = value;
00305 }
00306 
00307 inline void propiedad::set_hipotecado (bool value)
00308 {
00309   _hipotecado = value;
00310 }
00311 
00312 inline void propiedad::set_hipotecable (bool value)
00313 {
00314   _hipotecable = value;
00315 }
00316 
00317 inline void propiedad::set_esPropiedad ( propietario* j )
00318 {
00319   _esPropiedad = j;
00320 }
00321 
00322 inline void propiedad::set_perteneceMonopolio ( monopolio* perteneceMonopolio )
00323 {
00324   _perteneceMonopolio = perteneceMonopolio;
00325 }
00326 
00327 #endif

Generado el Fri Jun 30 12:38:29 2006 para Street Master's por  doxygen 1.3.9.1