doc/src-html/modelo/ov/ObjetoVolador.pas

   1 <HTML><HEAD>\r
   2 <TITLE>File: objetovolador.pas </TITLE>\r
   3 <META NAME="GENERATOR" CONTENT="PasToHTML(Bystricky Vladimir)">\r
   4 </HEAD>\r
   5 <BODY BGCOLOR="#FFFFFF">\r
   6 <A NAME=objetovolador.pas><CENTER><H3>objetovolador.pas</H3></A><I> from <A HREF=/proyecto/doc/src-html/AlgoWars.html> Project: AlgoWars.dpr</A></I></CENTER>\r
   7 <HR>\r
   8 <PRE>\r
   9 <I><FONT COLOR="Navy">{** Clase abstracta, implementa todas las funcionalidades básicas de los objetos voladores. \r
  10     De esta van a derivar la mayor parte del resto de las clases.<br> \r
  11     <i>Cambios:</i> \r
  12     <PRE> \r
  13     05/10/00: Se agregaron los métodos mGetDistancia y mColisiono. De esta manera se deja \r
  14               a los objetos voladores manejar las colisiones mas intuitivamente. \r
  15     30/10/00: Se agregó un atributo <b>aCoordenadas</b> para que se pueda orientar al objeto volador. \r
  16     02/11/00: Se agregaron métodos para cambiar solamente el modulo de la velocidad, para cambiar solo \r
  17               la direccion de la velocidad y para extraer directamente copias de los versores i, j, k y \r
  18               para rotar el objeto volador en todas direcciones. \r
  19               Los nuevos métodos son: mSetVelModulo, mSetVelDir, mGetVelModulo, \r
  20                                       mGetI, mGetJ, mGetK, mRotarEnI, \r
  21                                       mRotarEnJ, mRotarEnK \r
  22     07/11/00: Se agrega un nuevo método (mSetPosicion) y se hace a público otro (mSetVelocidad) para \r
  23               que se pueda cambiar la configuración (es temporal, se planea cambiar el sistema de \r
  24               configuración del juego para que esto no sea necesario) \r
  25     29/11/00: Se arregla un BUG en mSetVelModulo que no modificaba el modulo si la velocidad pasada \r
  26               como argumento era menor que cero. En este caso el modulo de la velocidad se setea en 0. \r
  27     02/12/00: Se cambio el dato que devuelve el método mDibujar. Ahora devuelve un tipo de dato enumerado \r
  28               tObjetosVoladores. Todas sus subclases fueron actualizadas también. \r
  29     08/12/00: Se agregan menúes para manejar la nueva vistas con varias camaras. Se agrega la opcion de \r
  30               alta calidad en el menú vista. Se carga un escenario por defecto (si existe) al iniciar el \r
  31               juego, el nombre de dicho escenario debe ser 'comun.eaw'. \r
  32               Se agrega una nueva tecla para cambiar de cámara ('C'), además de las que se provee con las \r
  33               teclas de atajo. \r
  34     </PRE>}</FONT></I> \r
  35 <B>unit</B> ObjetoVolador; \r
  36  \r
  37 <B>interface</B> \r
  38  \r
  39 <B>uses</B> \r
  40   Tipos, \r
  41   ObjetoPersistente, \r
  42   Coordenadas, \r
  43   Vectores; \r
  44  \r
  45 <B>type</B> \r
  46   <I><FONT COLOR="Navy">{** Clase abstracta, implementa todas las funcionalidades básicas de los objetos voladores. \r
  47       De esta van a derivar la mayor parte del resto de las clases.}</FONT></I> \r
  48   cObjetoVolador = <B>class</B>( cObjetoPersistente ) \r
  49     <B>private</B> \r
  50       aPosicion:    cVector;      <I><FONT COLOR="Navy">// Posicion del objeto volador en el espacio </FONT></I>\r
  51       aVelocidad:   tLongitud;    <I><FONT COLOR="Navy">// Velocidad del objeto volador (en modulo) </FONT></I>\r
  52       aPotencia:    tEnergia;     <I><FONT COLOR="Navy">// Potencia del objeto volador (la cantidad de daño que hace por impacto) </FONT></I>\r
  53       aEnergia:     tEnergia;     <I><FONT COLOR="Navy">// Energía del objeto volador (la cantidad de daño que soporta antes de ser destruido) </FONT></I>\r
  54       aDimension:   tLongitud;    <I><FONT COLOR="Navy">// La dimesión del objeto volador (es el radio de una esfera) </FONT></I>\r
  55       <I><FONT COLOR="Navy">// Agregado 30/10/00 </FONT></I>\r
  56       aCoordenadas: cCoordenadas; <I><FONT COLOR="Navy">// Sistema de coordenadas del objeto volador (para tener nocion de la orientación) </FONT></I>\r
  57                                   <I><FONT COLOR="Navy">//  El versor i es la direccion de la velocidad </FONT></I>\r
  58     <B>protected</B> \r
  59       <I><FONT COLOR="Navy">{** Método para establecer la energía}</FONT></I> \r
  60       <B>function</B> <A HREF="#cObjetoVolador.mSetEnergia">mSetEnergia</A>( ene: tEnergia ): cObjetoVolador; \r
  61       <I><FONT COLOR="Navy">{** Rota el objeto volador sobre el eje i \r
  62           (el sentido positivo es de j a k)}</FONT></I> \r
  63       <B>function</B> <A HREF="#cObjetoVolador.mRotarEnI">mRotarEnI</A>( dAngulo: tAngulo ): cObjetoVolador; \r
  64       <I><FONT COLOR="Navy">{** Rota el objeto volador sobre el eje j \r
  65           (el sentido positivo es de i a k)}</FONT></I> \r
  66       <B>function</B> <A HREF="#cObjetoVolador.mRotarEnJ">mRotarEnJ</A>( dAngulo: tAngulo ): cObjetoVolador; \r
  67       <I><FONT COLOR="Navy">{** Rota el objeto volador sobre el eje k \r
  68           (el sentido positivo es de i a j)}</FONT></I> \r
  69       <B>function</B> <A HREF="#cObjetoVolador.mRotarEnK">mRotarEnK</A>( dAngulo: tAngulo ): cObjetoVolador; \r
  70     <B>public</B> \r
  71       <I><FONT COLOR="Navy">{** Constructor}</FONT></I> \r
  72       <B>constructor</B> create( pos: cVector = <B>nil</B>; vel: cVector = <B>nil</B>; dim: tLongitud = 5; pot: tEnergia = 1; ene: tEnergia = 100 ); overload; \r
  73       <I><FONT COLOR="Navy">{** Constructor que copia los atributos de un Objeto volador existente}</FONT></I> \r
  74       <B>constructor</B> create( ov:  cObjetoVolador ); overload; \r
  75       <I><FONT COLOR="Navy">{$IFDEF DebugAlgoWars}</FONT></I> \r
  76       <I><FONT COLOR="Navy">{** Método heredado que devuelve un string con el estado del Objeto. Se utiliza para depurar \r
  77           y la información entregada depende del parámetro tDebugInfo.}</FONT></I> \r
  78       <B>function</B> <A HREF="#cObjetoVolador.mGetDebugInfo">mGetDebugInfo</A>( debugLevel: tDebugInfo = DI_MINI ): <B>string</B>; <B>override</B>; \r
  79       <I><FONT COLOR="Navy">{$ENDIF}</FONT></I> \r
  80       <I><FONT COLOR="Navy">{** Mueve el objeto volador basandose en su posicion, su velocidad y un intervalo de tiempo}</FONT></I> \r
  81       <B>procedure</B> <A HREF="#cObjetoVolador.mMover">mMover</A>( dT: tTiempo ); <B>virtual</B>; \r
  82       <I><FONT COLOR="Navy">{** Calcula la distancia a otro objeto volador}</FONT></I> \r
  83       <B>function</B> <A HREF="#cObjetoVolador.mGetDistancia">mGetDistancia</A>( ov: cObjetoVolador ): tLongitud; \r
  84       <I><FONT COLOR="Navy">{** Devuelve true si colisionaron los objetos voladores}</FONT></I> \r
  85       <B>function</B> <A HREF="#cObjetoVolador.mColisiono">mColisiono</A>( ov: cObjetoVolador ): boolean; \r
  86       <I><FONT COLOR="Navy">{** Obtiene la velocidad del objeto volador}</FONT></I> \r
  87       <B>function</B> <A HREF="#cObjetoVolador.mGetVelocidad">mGetVelocidad</A>: cVector; \r
  88       <I><FONT COLOR="Navy">{** Obtiene el modulo de la velocidad del objeto volador}</FONT></I> \r
  89       <B>function</B> <A HREF="#cObjetoVolador.mGetVelModulo">mGetVelModulo</A>: tLongitud; \r
  90       <I><FONT COLOR="Navy">{** Obtiene la Posicion del objeto volador}</FONT></I> \r
  91       <B>function</B> <A HREF="#cObjetoVolador.mGetPosicion">mGetPosicion</A>: cVector; \r
  92       <I><FONT COLOR="Navy">{** Obtiene la Potencia del objeto volador}</FONT></I> \r
  93       <B>function</B> <A HREF="#cObjetoVolador.mGetPotencia">mGetPotencia</A>: tEnergia; \r
  94       <I><FONT COLOR="Navy">{** Obtiene la Energia del objeto volador}</FONT></I> \r
  95       <B>function</B> <A HREF="#cObjetoVolador.mGetEnergia">mGetEnergia</A>: tEnergia; \r
  96       <I><FONT COLOR="Navy">{** Obtiene la Dimension del objeto volador}</FONT></I> \r
  97       <B>function</B> <A HREF="#cObjetoVolador.mGetDimension">mGetDimension</A>: tLongitud; \r
  98       <I><FONT COLOR="Navy">{** Obtiene el sistema de coordenadas de la nave}</FONT></I> \r
  99       <B>function</B> <A HREF="#cObjetoVolador.mGetCoordenadas">mGetCoordenadas</A>: cCoordenadas; \r
 100       <I><FONT COLOR="Navy">{** Obtiene el versor i del sistema de coordenadas de la nave}</FONT></I> \r
 101       <B>function</B> <A HREF="#cObjetoVolador.mGetI">mGetI</A>: cVector; \r
 102       <I><FONT COLOR="Navy">{** Obtiene el versor j del sistema de coordenadas de la nave}</FONT></I> \r
 103       <B>function</B> <A HREF="#cObjetoVolador.mGetJ">mGetJ</A>: cVector; \r
 104       <I><FONT COLOR="Navy">{** Obtiene el versor k del sistema de coordenadas de la nave}</FONT></I> \r
 105       <B>function</B> <A HREF="#cObjetoVolador.mGetK">mGetK</A>: cVector; \r
 106       <I><FONT COLOR="Navy">{** Método para establecer la posición}</FONT></I> \r
 107       <B>function</B> <A HREF="#cObjetoVolador.mSetPosicion">mSetPosicion</A>( posicion: cVector ): cObjetoVolador; \r
 108       <I><FONT COLOR="Navy">{** Método para establecer la velocidad}</FONT></I> \r
 109       <B>function</B> <A HREF="#cObjetoVolador.mSetVelocidad">mSetVelocidad</A>( velocidad: cVector ): cObjetoVolador; <B>virtual</B>; \r
 110       <I><FONT COLOR="Navy">{** Método para establecer el modulo de la velocidad}</FONT></I> \r
 111       <B>function</B> <A HREF="#cObjetoVolador.mSetVelModulo">mSetVelModulo</A>( velocidad: tLongitud ): cObjetoVolador; <B>virtual</B>; \r
 112       <I><FONT COLOR="Navy">{** Método para establecer la direccion de la velocidad}</FONT></I> \r
 113       <B>function</B> <A HREF="#cObjetoVolador.mSetVelDir">mSetVelDir</A>( velocidad: cVector ): cObjetoVolador; \r
 114       <I><FONT COLOR="Navy">{** Resta energia al objeto volador}</FONT></I> \r
 115       <B>function</B> <A HREF="#cObjetoVolador.mRestarEnergia">mRestarEnergia</A>( ene: tEnergia ): cObjetoVolador; \r
 116       <I><FONT COLOR="Navy">{** Método abstracto, se sobreescribira en las subclases porque van a ser \r
 117           dibujadas de forma diferente}</FONT></I> \r
 118       <B>function</B> <A HREF="#cObjetoVolador.mDibujar">mDibujar</A>: tObjetosVoladores; <B>virtual</B>; <B>abstract</B>; \r
 119       <I><FONT COLOR="Navy">{** Destructor}</FONT></I> \r
 120       <B>destructor</B> destroy; <B>override</B>; \r
 121       <I><FONT COLOR="Navy">// SERIALIZACION </FONT></I>\r
 122       <I><FONT COLOR="Navy">{** Devuelve una cadena de texto con el objeto serializado.}</FONT></I> \r
 123       <B>function</B> <A HREF="#cObjetoVolador.mSerializar">mSerializar</A>: <B>string</B>; <B>override</B>; \r
 124       <I><FONT COLOR="Navy">{** Recrea el objeto a partir de una cadena de texto con el objeto \r
 125           serializado.}</FONT></I> \r
 126       <B>procedure</B> <A HREF="#cObjetoVolador.mDesSerializar">mDesSerializar</A>( str: <B>string</B> ); <B>override</B>; \r
 127   <B>end</B>; \r
 128  \r
 129 <B>implementation</B> \r
 130  \r
 131 <B>uses</B> \r
 132   RegExpr, \r
 133   Sysutils; \r
 134  \r
 135 <I><FONT COLOR="Navy">{ cObjetoVolador }</FONT></I> \r
 136  \r
 137 <I><FONT COLOR="Navy">{** Constructor \r
 138     @param ov Objeto volador del cual extraer los datos para inicializar en actual}</FONT></I> \r
 139 <B>constructor</B> cObjetoVolador.create( ov: cObjetoVolador ); \r
 140 <B>var</B> \r
 141   vel: cVector; \r
 142 <B>begin</B> \r
 143   <I><FONT COLOR="Navy">// Crea el objeto basandose en los atributos del parametro </FONT></I>\r
 144   <B>inherited</B> create; \r
 145   aPosicion := ov.mGetPosicion; \r
 146   vel := ov.mGetVelocidad; \r
 147   aVelocidad := vel.mGetModulo; \r
 148   vel.free; \r
 149   aDimension := ov.mGetDimension; \r
 150   aPotencia  := ov.mGetPotencia; \r
 151   aEnergia   := ov.mGetEnergia; \r
 152   aCoordenadas := ov.mGetCoordenadas; \r
 153 <B>end</B>; \r
 154  \r
 155 <I><FONT COLOR="Navy">{** Constructor \r
 156     @param pos Posicion inicial \r
 157     @param vel Velocidad inicial \r
 158     @param dim Dimensión del objeto volador (radio, en metros) \r
 159     @param pot Potencia del objeto volador (cantidad de daño que hace por intervalode tiempo) \r
 160     @param ene Energía del objeto volador(cantidad de daño que soporta antes de ser destruido)}</FONT></I> \r
 161 <B>constructor</B> cObjetoVolador.create(pos: cVector = <B>nil</B>; vel: cVector = <B>nil</B>; \r
 162   dim: tLongitud = 5; pot: tEnergia = 1; ene: tEnergia = 100); \r
 163 <B>begin</B> \r
 164   <B>inherited</B> create; \r
 165   aDimension := dim; \r
 166   aPotencia  := pot; \r
 167   aEnergia   := ene; \r
 168   aCoordenadas := cCoordenadas.create; \r
 169   <I><FONT COLOR="Navy">// Si la posicion es nula crea una nueva </FONT></I>\r
 170   <B>if</B> pos = <B>nil</B> <B>then</B> \r
 171     aPosicion := cVector.create( 0, 0, 0 ) \r
 172   <B>else</B> \r
 173     aPosicion := cVector.create( pos ); \r
 174   <I><FONT COLOR="Navy">// Si la velocidad es nula crea una nueva </FONT></I>\r
 175   <B>if</B> vel = <B>nil</B> <B>then</B> \r
 176     aVelocidad := 0 \r
 177   <B>else</B> <B>begin</B> \r
 178     aVelocidad := vel.mGetModulo; \r
 179     aCoordenadas.mSetI( vel ); \r
 180   <B>end</B>; \r
 181 <B>end</B>; \r
 182  \r
 183 <I><FONT COLOR="Navy">{** Mueve el objeto volador basandose en su posicion, su velocidad y un intervalo de tiempo \r
 184     @param dT Intervalo de tiempo}</FONT></I> \r
 185 <B>procedure</B> <A NAME=cObjetoVolador.mMover>cObjetoVolador.mMover</A>( dT: tTiempo ); \r
 186 <B>var</B> \r
 187   v: cVector; \r
 188 <B>begin</B> \r
 189   v := cVector.create( mGetVelocidad ); \r
 190   aPosicion.mModificarCon( v, dT ); \r
 191   v.free; \r
 192 <B>end</B>; \r
 193  \r
 194 <I><FONT COLOR="Navy">{** Establece la velocidad del objeto volador \r
 195     @param velocidad Nuevo vector velocidad}</FONT></I> \r
 196 <B>function</B> <A NAME=cObjetoVolador.mSetVelocidad>cObjetoVolador.mSetVelocidad</A>( velocidad: cVector ): cObjetoVolador; \r
 197 <B>begin</B> \r
 198   aVelocidad := velocidad.mGetModulo; \r
 199   <I><FONT COLOR="Navy">// Agregado 30/10/00 para que mantenga las coordenadas </FONT></I>\r
 200   aCoordenadas.mSetI( velocidad ); \r
 201   result := self; \r
 202 <B>end</B>; \r
 203  \r
 204 <I><FONT COLOR="Navy">{** Obtiene la velocidad del objeto volador \r
 205     @return Vector velocidad}</FONT></I> \r
 206 <B>function</B> <A NAME=cObjetoVolador.mGetVelocidad>cObjetoVolador.mGetVelocidad</A>: cVector; \r
 207 <B>begin</B> \r
 208   result := aCoordenadas.mGetI.mMultiplicar( aVelocidad ); \r
 209 <B>end</B>; \r
 210  \r
 211 <I><FONT COLOR="Navy">{** Obtiene la posición del objeto volador \r
 212     @return Vector posición}</FONT></I> \r
 213 <B>function</B> <A NAME=cObjetoVolador.mGetPosicion>cObjetoVolador.mGetPosicion</A>: cVector; \r
 214 <B>begin</B> \r
 215   result := cVector.create( aPosicion ); \r
 216 <B>end</B>; \r
 217  \r
 218 <I><FONT COLOR="Navy">{** Obtiene la dimensión del objeto volador \r
 219     @return Dimensión (radio, en metros)}</FONT></I> \r
 220 <B>function</B> <A NAME=cObjetoVolador.mGetDimension>cObjetoVolador.mGetDimension</A>: tLongitud; \r
 221 <B>begin</B> \r
 222   result := aDimension; \r
 223 <B>end</B>; \r
 224  \r
 225 <I><FONT COLOR="Navy">{** Destructor}</FONT></I> \r
 226 <B>destructor</B> cObjetoVolador.destroy; \r
 227 <B>begin</B> \r
 228   <I><FONT COLOR="Navy">// Libera los atributo objeto </FONT></I>\r
 229   aPosicion.free; \r
 230   aCoordenadas.free; \r
 231   <B>inherited</B>; \r
 232 <B>end</B>; \r
 233  \r
 234 <I><FONT COLOR="Navy">{** Obtiene la potencia del objeto volador \r
 235     @return Potencia (cantidad de daño que realiza por intervalo de tiempo)}</FONT></I> \r
 236 <B>function</B> <A NAME=cObjetoVolador.mGetPotencia>cObjetoVolador.mGetPotencia</A>: tEnergia; \r
 237 <B>begin</B> \r
 238  result := aPotencia; \r
 239 <B>end</B>; \r
 240  \r
 241 <I><FONT COLOR="Navy">{** Obtiene la e del objeto volador \r
 242     @return Energía (cantidad de daño que soporta antes de ser destruido)}</FONT></I> \r
 243 <B>function</B> <A NAME=cObjetoVolador.mGetEnergia>cObjetoVolador.mGetEnergia</A>: tEnergia; \r
 244 <B>begin</B> \r
 245  result := aEnergia; \r
 246 <B>end</B>; \r
 247  \r
 248 <I><FONT COLOR="Navy">{$IFDEF DebugAlgoWars}</FONT></I> \r
 249 <I><FONT COLOR="Navy">{** Devuelve el estado del objeto basandose en la cantidad de datos requeridos. \r
 250     @return            Cadena de texto con el estado del Objeto. \r
 251     @param   debugLevel Cantidad de información requerida}</FONT></I> \r
 252 <B>function</B> <A NAME=cObjetoVolador.mGetDebugInfo>cObjetoVolador.mGetDebugInfo</A>( debugLevel: tDebugInfo = DI_MINI ): <B>string</B>; \r
 253 <B>begin</B> \r
 254   <I><FONT COLOR="Navy">// Construye la cadena dependiendo de la cantidad de informacion que se quiera obtener </FONT></I>\r
 255   result := 'Posición: ' + aPosicion.mGetDebugInfo( debugLevel ); \r
 256   <B>if</B> debugLevel > DI_MINI <B>then</B> \r
 257     result := result + #13 + #10 + \r
 258               'Energia: ' + FloatToStrF( aEnergia, ffNumber, 5, 5 ); \r
 259   <B>if</B> debugLevel > DI_NORMAL <B>then</B> \r
 260     result := result + ' | Potencia: ' + FloatToStrF( aPotencia, ffNumber, 5, 5 ) + \r
 261                        ' | Dimension: ' + FloatToStrF( aDimension, ffNumber, 5, 5 ) + #13 + #10 + \r
 262                        'Velocidad: ' + mGetVelocidad.mGetDebugInfo( debugLevel ) + #13 + #10 + \r
 263                        'Coordenadas: ' + #13 + #10 + aCoordenadas.mGetDebugInfo; \r
 264 <B>end</B>; \r
 265 <I><FONT COLOR="Navy">{$ENDIF}</FONT></I> \r
 266  \r
 267 <I><FONT COLOR="Navy">{** Resta energía al objeto volador \r
 268     @param ene Energía a restar}</FONT></I> \r
 269 <B>function</B> <A NAME=cObjetoVolador.mRestarEnergia>cObjetoVolador.mRestarEnergia</A>(ene: tEnergia): cObjetoVolador; \r
 270 <B>begin</B> \r
 271   aEnergia := aEnergia - ene; \r
 272   result := self; \r
 273 <B>end</B>; \r
 274  \r
 275 <I><FONT COLOR="Navy">{** Setea la energía del objeto volador a un valor arbitrario \r
 276     @param ene Nueva energía}</FONT></I> \r
 277 <B>function</B> <A NAME=cObjetoVolador.mSetEnergia>cObjetoVolador.mSetEnergia</A>(ene: tEnergia): cObjetoVolador; \r
 278 <B>begin</B> \r
 279   aEnergia := ene; \r
 280   result := self; \r
 281 <B>end</B>; \r
 282  \r
 283 <I><FONT COLOR="Navy">{** Calcula la distancia a otro objeto volador \r
 284     @return     Distancia al otro objeto volador \r
 285     @param   ov Objeto volador al que se calcula la distancia}</FONT></I> \r
 286 <B>function</B> <A NAME=cObjetoVolador.mGetDistancia>cObjetoVolador.mGetDistancia</A>(ov: cObjetoVolador): tLongitud; \r
 287 <B>var</B> \r
 288   v: cVector; <I><FONT COLOR="Navy">// Vector temporal </FONT></I>\r
 289 <B>begin</B> \r
 290   v := ov.mGetPosicion; <I><FONT COLOR="Navy">// obtiene la posicion de ov </FONT></I>\r
 291   result := v.mGetDistancia( aPosicion ); <I><FONT COLOR="Navy">// obtiene la distancia </FONT></I>\r
 292   v.free; <I><FONT COLOR="Navy">// Libera al vector temporal </FONT></I>\r
 293 <B>end</B>; \r
 294  \r
 295 <I><FONT COLOR="Navy">{** Devuelve true si colisionaron los objetos voladores \r
 296     @return     <i>true<i> si colisionaron, <i>false</i> si no lo hicieron \r
 297     @param   ov Objeto volador con el que se evalua si colisiono}</FONT></I> \r
 298 <B>function</B> <A NAME=cObjetoVolador.mColisiono>cObjetoVolador.mColisiono</A>(ov: cObjetoVolador): boolean; \r
 299 <B>begin</B> \r
 300   <I><FONT COLOR="Navy">// true si la distancia es menor a la suma de las dimensiones </FONT></I>\r
 301   result := ( mGetDistancia( ov ) <= ( aDimension + ov.mGetDimension ) ); \r
 302 <B>end</B>; \r
 303  \r
 304 <I><FONT COLOR="Navy">{** Obtiene el sistema de coordenadas de la nave \r
 305     @return Sistema de coordenadas de la nave}</FONT></I> \r
 306 <B>function</B> <A NAME=cObjetoVolador.mGetCoordenadas>cObjetoVolador.mGetCoordenadas</A>: cCoordenadas; \r
 307 <B>begin</B> \r
 308   result := cCoordenadas.create( aCoordenadas ); \r
 309 <B>end</B>; \r
 310  \r
 311 <I><FONT COLOR="Navy">{** Método para establecer el modulo de la velocidad \r
 312     @param velocidad Nuevo módulo de la velocidad}</FONT></I> \r
 313 <B>function</B> <A NAME=cObjetoVolador.mSetVelModulo>cObjetoVolador.mSetVelModulo</A>( velocidad: tLongitud ): cObjetoVolador; \r
 314 <B>begin</B> \r
 315   <B>if</B> velocidad > 0 <B>then</B> \r
 316     aVelocidad := velocidad \r
 317   <B>else</B> \r
 318     aVelocidad := 0; \r
 319   result := self; \r
 320 <B>end</B>; \r
 321  \r
 322 <I><FONT COLOR="Navy">{** Método para establecer la direccion de la velocidad \r
 323     @param velocidad Nueva dirección de la velocidad}</FONT></I> \r
 324 <B>function</B> <A NAME=cObjetoVolador.mSetVelDir>cObjetoVolador.mSetVelDir</A>( velocidad: cVector ): cObjetoVolador; \r
 325 <B>begin</B> \r
 326   aCoordenadas.mSetI( velocidad ); \r
 327   result := self; \r
 328 <B>end</B>; \r
 329  \r
 330 <I><FONT COLOR="Navy">{** Obtiene el modulo de la velocidad del objeto volador \r
 331     @return Módulo de la velocidad}</FONT></I> \r
 332 <B>function</B> <A NAME=cObjetoVolador.mGetVelModulo>cObjetoVolador.mGetVelModulo</A>: tLongitud; \r
 333 <B>begin</B> \r
 334   result := aVelocidad; \r
 335 <B>end</B>; \r
 336  \r
 337 <I><FONT COLOR="Navy">{** Obtiene el versor i del sistema de coordenadas de la nave \r
 338     @return Versor i, que representa la direccion en la que viaja el objeto}</FONT></I> \r
 339 <B>function</B> <A NAME=cObjetoVolador.mGetI>cObjetoVolador.mGetI</A>: cVector; \r
 340 <B>begin</B> \r
 341   result := aCoordenadas.mGetI; \r
 342 <B>end</B>; \r
 343  \r
 344 <I><FONT COLOR="Navy">{** Obtiene el versor j del sistema de coordenadas de la nave \r
 345     @return Versor j, que representa la direccion en la que está la izquierda del objeto}</FONT></I> \r
 346 <B>function</B> <A NAME=cObjetoVolador.mGetJ>cObjetoVolador.mGetJ</A>: cVector; \r
 347 <B>begin</B> \r
 348   result := aCoordenadas.mGetJ; \r
 349 <B>end</B>; \r
 350  \r
 351 <I><FONT COLOR="Navy">{** Obtiene el versor k del sistema de coordenadas de la nave \r
 352     @return Versor k, que representa la direccion en la que está el "techo" del objeto}</FONT></I> \r
 353 <B>function</B> <A NAME=cObjetoVolador.mGetK>cObjetoVolador.mGetK</A>: cVector; \r
 354 <B>begin</B> \r
 355   result := aCoordenadas.mGetK; \r
 356 <B>end</B>; \r
 357  \r
 358 <I><FONT COLOR="Navy">{** Rota el objeto volador sobre el eje i \r
 359     (el sentido positivo es de j a k)}</FONT></I> \r
 360 <B>function</B> <A NAME=cObjetoVolador.mRotarEnI>cObjetoVolador.mRotarEnI</A>( dAngulo: tAngulo ): cObjetoVolador; \r
 361 <B>begin</B> \r
 362   aCoordenadas.mRotarEnI( dAngulo ); \r
 363   result := self; \r
 364 <B>end</B>; \r
 365  \r
 366 <I><FONT COLOR="Navy">{** Rota el objeto volador sobre el eje j \r
 367     (el sentido positivo es de i a k)}</FONT></I> \r
 368 <B>function</B> <A NAME=cObjetoVolador.mRotarEnJ>cObjetoVolador.mRotarEnJ</A>( dAngulo: tAngulo ): cObjetoVolador; \r
 369 <B>begin</B> \r
 370   aCoordenadas.mRotarEnJ( dAngulo ); \r
 371   result := self; \r
 372 <B>end</B>; \r
 373  \r
 374 <I><FONT COLOR="Navy">{** Rota el objeto volador sobre el eje k \r
 375     (el sentido positivo es de i a j)}</FONT></I> \r
 376 <B>function</B> <A NAME=cObjetoVolador.mRotarEnK>cObjetoVolador.mRotarEnK</A>( dAngulo: tAngulo ): cObjetoVolador; \r
 377 <B>begin</B> \r
 378   aCoordenadas.mRotarEnK( dAngulo ); \r
 379   result := self; \r
 380 <B>end</B>; \r
 381  \r
 382 <I><FONT COLOR="Navy">{** Método para establecer la posición \r
 383     @param velocidad Nuevo vector posición}</FONT></I> \r
 384 <B>function</B> <A NAME=cObjetoVolador.mSetPosicion>cObjetoVolador.mSetPosicion</A>(posicion: cVector): cObjetoVolador; \r
 385 <B>begin</B> \r
 386   aPosicion := cVector.create( posicion ); \r
 387   result := self; \r
 388 <B>end</B>; \r
 389  \r
 390 <I><FONT COLOR="Navy">{** Recrea el objeto a partir de una cadena de texto con el objeto \r
 391     serializado. \r
 392     @param str Cadena de texto con el objeto serializado.}</FONT></I> \r
 393 <B>procedure</B> <A NAME=cObjetoVolador.mDesSerializar>cObjetoVolador.mDesSerializar</A>(str: <B>string</B>); \r
 394 <B>var</B> \r
 395   r: TRegExpr; \r
 396 <B>begin</B> \r
 397   <B>inherited</B> mDesSerializar( str ); <I><FONT COLOR="Navy">// SIEMPRE el ID debe ser el PRIMER atributo </FONT></I>\r
 398   r := TRegExpr.create; \r
 399   <I><FONT COLOR="Navy">// POSICION </FONT></I>\r
 400   <B>try</B> <I><FONT COLOR="Navy">// se fija si hay errores al extraer los datos </FONT></I>\r
 401     r.Expression := '<posicion>/s*(.+)/s*</posicion>'; <I><FONT COLOR="Navy">// contruye la expresion regular a buscar </FONT></I>\r
 402     <B>if</B> r.Exec ( str ) <B>then</B> <I><FONT COLOR="Navy">// Ejecuta la expresion. Si la encuentra... </FONT></I>\r
 403       <B>if</B> aPosicion <> <B>nil</B> <B>then</B> <I><FONT COLOR="Navy">// Si no es nulo </FONT></I>\r
 404         aPosicion.mDesSerializar( r.Match[1] ) <I><FONT COLOR="Navy">// Lo deserializa </FONT></I>\r
 405       <B>else</B> <I><FONT COLOR="Navy">// si es nulo </FONT></I>\r
 406         aPosicion := cVector.crearDeSerializado( r.Match[1] ) <I><FONT COLOR="Navy">// lo crea </FONT></I>\r
 407     <B>else</B> <I><FONT COLOR="Navy">// si no encontro la experesion... </FONT></I>\r
 408       <B>raise</B> ESerializacion.create( 'No se encontro la posicion' ); <I><FONT COLOR="Navy">// cae en una excepcion </FONT></I>\r
 409   <B>except</B> <I><FONT COLOR="Navy">// Si hubieron errores ... </FONT></I>\r
 410     on e: ESerializacion <B>do</B> <B>begin</B> <I><FONT COLOR="Navy">// Si fueron de serializacion... </FONT></I>\r
 411       r.Free; <I><FONT COLOR="Navy">// libera memoria </FONT></I>\r
 412       <B>raise</B> ESerializacion.create( ClassName + ': Error al deserializar la posicion: ' + e.<B>Message</B> ); <I><FONT COLOR="Navy">// cae en una excepcion </FONT></I>\r
 413     <B>end</B>; \r
 414     on e: ERegExpr <B>do</B> <B>begin</B> <I><FONT COLOR="Navy">// si fueron de expresiones regulares... </FONT></I>\r
 415       r.Free; <I><FONT COLOR="Navy">// libera memoria </FONT></I>\r
 416       <B>raise</B> ESerializacion.create( ClassName + ': Error al extraer la posicion utilizando expresiones regulares: ' + e.<B>Message</B> ); <I><FONT COLOR="Navy">// cae en una excepcion </FONT></I>\r
 417     <B>end</B>; \r
 418   <B>end</B>; \r
 419   <I><FONT COLOR="Navy">// VELOCIDAD </FONT></I>\r
 420   <B>try</B> <I><FONT COLOR="Navy">// se fija si hay errores al extraer los datos </FONT></I>\r
 421     r.Expression := '<velocidad>/s*([+/-]?/d+(/,/d+)?([eE][+/-]?/d+)?)/s*</velocidad>'; <I><FONT COLOR="Navy">// contruye la expresion regular a buscar </FONT></I>\r
 422     <B>if</B> r.Exec ( str ) <B>then</B> <I><FONT COLOR="Navy">// Ejecuta la expresion. Si la encuentra... </FONT></I>\r
 423       aVelocidad := StrToFloat( r.Match[1] ) \r
 424     <B>else</B> <I><FONT COLOR="Navy">// si no encontro la experesion... </FONT></I>\r
 425       <B>raise</B> ESerializacion.create( 'No se encontro la velocidad' ); <I><FONT COLOR="Navy">// cae en una excepcion </FONT></I>\r
 426   <B>except</B> <I><FONT COLOR="Navy">// Si hubieron errores ... </FONT></I>\r
 427     on e: ERegExpr <B>do</B> <B>begin</B> <I><FONT COLOR="Navy">// si fueron de expresiones regulares... </FONT></I>\r
 428       r.Free; <I><FONT COLOR="Navy">// libera memoria </FONT></I>\r
 429       <B>raise</B> ESerializacion.create( ClassName + ': Error al extraer la velocidad utilizando expresiones regulares: ' + e.<B>Message</B> ); <I><FONT COLOR="Navy">// cae en una excepcion </FONT></I>\r
 430     <B>end</B>; \r
 431   <B>end</B>; \r
 432   <I><FONT COLOR="Navy">// POTENCIA </FONT></I>\r
 433   <B>try</B> <I><FONT COLOR="Navy">// se fija si hay errores al extraer los datos </FONT></I>\r
 434     r.Expression := '<potencia>/s*([+/-]?/d+)/s*</potencia>'; <I><FONT COLOR="Navy">// contruye la expresion regular a buscar </FONT></I>\r
 435     <B>if</B> r.Exec ( str ) <B>then</B> <I><FONT COLOR="Navy">// Ejecuta la expresion. Si la encuentra... </FONT></I>\r
 436       aPotencia := StrToInt( r.Match[1] ) \r
 437     <B>else</B> <I><FONT COLOR="Navy">// si no encontro la experesion... </FONT></I>\r
 438       <B>raise</B> ESerializacion.create( 'No se encontro la potencia' ); <I><FONT COLOR="Navy">// cae en una excepcion </FONT></I>\r
 439   <B>except</B> <I><FONT COLOR="Navy">// Si hubieron errores ... </FONT></I>\r
 440     on e: ERegExpr <B>do</B> <B>begin</B> <I><FONT COLOR="Navy">// si fueron de expresiones regulares... </FONT></I>\r
 441       r.Free; <I><FONT COLOR="Navy">// libera memoria </FONT></I>\r
 442       <B>raise</B> ESerializacion.create( ClassName + ': Error al extraer la potencia utilizando expresiones regulares: ' + e.<B>Message</B> ); <I><FONT COLOR="Navy">// cae en una excepcion </FONT></I>\r
 443     <B>end</B>; \r
 444   <B>end</B>; \r
 445   <I><FONT COLOR="Navy">// ENERGIA </FONT></I>\r
 446   <B>try</B> <I><FONT COLOR="Navy">// se fija si hay errores al extraer los datos </FONT></I>\r
 447     r.Expression := '<energia>/s*([+/-]?/d+)/s*</energia>'; <I><FONT COLOR="Navy">// contruye la expresion regular a buscar </FONT></I>\r
 448     <B>if</B> r.Exec ( str ) <B>then</B> <I><FONT COLOR="Navy">// Ejecuta la expresion. Si la encuentra... </FONT></I>\r
 449       aEnergia := StrToInt( r.Match[1] ) \r
 450     <B>else</B> <I><FONT COLOR="Navy">// si no encontro la experesion... </FONT></I>\r
 451       <B>raise</B> ESerializacion.create( 'No se encontro la energia' ); <I><FONT COLOR="Navy">// cae en una excepcion </FONT></I>\r
 452   <B>except</B> <I><FONT COLOR="Navy">// Si hubieron errores ... </FONT></I>\r
 453     on e: ERegExpr <B>do</B> <B>begin</B> <I><FONT COLOR="Navy">// si fueron de expresiones regulares... </FONT></I>\r
 454       r.Free; <I><FONT COLOR="Navy">// libera memoria </FONT></I>\r
 455       <B>raise</B> ESerializacion.create( ClassName + ': Error al extraer la energia utilizando expresiones regulares: ' + e.<B>Message</B> ); <I><FONT COLOR="Navy">// cae en una excepcion </FONT></I>\r
 456     <B>end</B>; \r
 457   <B>end</B>; \r
 458   <I><FONT COLOR="Navy">// DIMENSION </FONT></I>\r
 459   <B>try</B> <I><FONT COLOR="Navy">// se fija si hay errores al extraer los datos </FONT></I>\r
 460     r.Expression := '<dimension>/s*([+/-]?/d+(/,/d+)?([eE][+/-]?/d+)?)/s*</dimension>'; <I><FONT COLOR="Navy">// contruye la expresion regular a buscar </FONT></I>\r
 461     <B>if</B> r.Exec ( str ) <B>then</B> <I><FONT COLOR="Navy">// Ejecuta la expresion. Si la encuentra... </FONT></I>\r
 462       aDimension := StrToFloat( r.Match[1] ) \r
 463     <B>else</B> <I><FONT COLOR="Navy">// si no encontro la experesion... </FONT></I>\r
 464       <B>raise</B> ESerializacion.create( 'No se encontro la dimension' ); <I><FONT COLOR="Navy">// cae en una excepcion </FONT></I>\r
 465   <B>except</B> <I><FONT COLOR="Navy">// Si hubieron errores ... </FONT></I>\r
 466     on e: ERegExpr <B>do</B> <B>begin</B> <I><FONT COLOR="Navy">// si fueron de expresiones regulares... </FONT></I>\r
 467       r.Free; <I><FONT COLOR="Navy">// libera memoria </FONT></I>\r
 468       <B>raise</B> ESerializacion.create( ClassName + ': Error al extraer la dimension utilizando expresiones regulares: ' + e.<B>Message</B> ); <I><FONT COLOR="Navy">// cae en una excepcion </FONT></I>\r
 469     <B>end</B>; \r
 470   <B>end</B>; \r
 471   <I><FONT COLOR="Navy">// COORDENADAS </FONT></I>\r
 472   <B>try</B> <I><FONT COLOR="Navy">// se fija si hay errores al extraer los datos </FONT></I>\r
 473     r.Expression := '<coordenadas>/s*(.+)/s*</coordenadas>'; <I><FONT COLOR="Navy">// contruye la expresion regular a buscar </FONT></I>\r
 474     <B>if</B> r.Exec ( str ) <B>then</B> <I><FONT COLOR="Navy">// Ejecuta la expresion. Si la encuentra... </FONT></I>\r
 475       <B>if</B> aCoordenadas <> <B>nil</B> <B>then</B> <I><FONT COLOR="Navy">// Si no es nulo </FONT></I>\r
 476         aCoordenadas.mDesSerializar( r.Match[1] ) <I><FONT COLOR="Navy">// Lo deserializa </FONT></I>\r
 477       <B>else</B> <I><FONT COLOR="Navy">// si es nulo </FONT></I>\r
 478         aCoordenadas := cCoordenadas.crearDeSerializado( r.Match[1] ) <I><FONT COLOR="Navy">// lo crea </FONT></I>\r
 479     <B>else</B> <I><FONT COLOR="Navy">// si no encontro la experesion... </FONT></I>\r
 480       <B>raise</B> ESerializacion.create( ClassName + ': No se pudieron extraer las coordenadas' ); <I><FONT COLOR="Navy">// cae en una excepcion </FONT></I>\r
 481   <B>except</B> <I><FONT COLOR="Navy">// Si hubieron errores ... </FONT></I>\r
 482     on e: ESerializacion <B>do</B> <B>begin</B> <I><FONT COLOR="Navy">// Si fueron de serializacion... </FONT></I>\r
 483       r.Free; <I><FONT COLOR="Navy">// libera memoria </FONT></I>\r
 484       <B>raise</B> ESerializacion.create( ClassName + ': Error al deserializar las coordenadas: ' + e.<B>Message</B> ); <I><FONT COLOR="Navy">// cae en una excepcion </FONT></I>\r
 485     <B>end</B>; \r
 486     on e: ERegExpr <B>do</B> <B>begin</B> <I><FONT COLOR="Navy">// si fueron de expresiones regulares... </FONT></I>\r
 487       r.Free; <I><FONT COLOR="Navy">// libera memoria </FONT></I>\r
 488       <B>raise</B> ESerializacion.create( ClassName + ': Error al extraer las coordenadas utilizando expresiones regulares: ' + e.<B>Message</B> ); <I><FONT COLOR="Navy">// cae en una excepcion </FONT></I>\r
 489     <B>end</B>; \r
 490   <B>end</B>; \r
 491   r.free; \r
 492 <B>end</B>; \r
 493  \r
 494 <I><FONT COLOR="Navy">{** Devuelve una cadena de texto con el objeto serializado. \r
 495     @return Cadena de texto con el objeto serializado.}</FONT></I> \r
 496 <B>function</B> <A NAME=cObjetoVolador.mSerializar>cObjetoVolador.mSerializar</A>: <B>string</B>; \r
 497 <B>begin</B> \r
 498   result := <B>inherited</B> mSerializar + \r
 499             '<posicion>' + aPosicion.mSerializar + '</posicion>' + \r
 500             '<velocidad>' + FloatToStrF( aVelocidad, ffGeneral, 18, 0 ) + '</velocidad>' + \r
 501             '<potencia>' + FloatToStrF( aPotencia, ffGeneral, 18, 0 ) + '</potencia>' + \r
 502             '<energia>' + FloatToStrF( aEnergia, ffGeneral, 18, 0 ) + '</energia>' + \r
 503             '<dimension>' + FloatToStrF( aDimension, ffGeneral, 18, 0 ) + '</dimension>' + \r
 504             '<coordenadas>' + aCoordenadas.mSerializar + '</coordenadas>'; \r
 505 <B>end</B>; \r
 506  \r
 507 <B>end</B>. \r
 508 </PRE>\r
 509 </BODY>\r
 510 </HTML>\r