src/modelo/ov/naves/Nave.pas

   1 {** Contiene una clase abstracta con elementos comunes a todas las naves.<br>\r
   2     <i>Cambios:</i>\r
   3     <PRE>\r
   4     27/11/00: Se agrega toda la parte del manejo de disparos, agregándose los métodos mPuedeDispararLaser,\r
   5               mPuedeDispararMisil, mPuedeDispararMisDir y mDisparar, además de varios atributos para manejar\r
   6               los retardos de las armas. El método mDisparar se hace virtual ya que puede ser modificado por\r
   7               las subclases para que cambie su mecanismo de disparos.\r
   8     29/11/00: Se agregan métodos para obtener la cantidad de armamento que le queda a la nave para poder ser\r
   9               mostrados (mGetMisiles y mGetMisilesDirigidos)\r
  10     01/12/00: Se modifican levemente los metodos mPuedeDispararXxxx para que permitan disparar si el puntero\r
  11               al Objeto Volador objetivo es nil.\r
  12               Se Agregan los métodos mRetardarLaser, mRetardarMisil, mRetardarMisDir que resetea el contador\r
  13               del retardo, mActualizarRetardos que resta el dT a los retardos, y mCrearLaserDisparado,\r
  14               mCrearMisilDisparado y mCrearMisDirDisparado que crea el arma correspondiente (actualizando\r
  15               retardos y todo lo que sea necesario) para que las subclases puedan escribir su propio mDisparar.\r
  16               Se cambia el orden de los argumentos de mDisparar para aprovechar los argumentos por defecto.\r
  17     08/12/00: Se sobreescribieron los métodos para establecer la velocidad y su módulo para evitar que se\r
  18               sobrepase el límite de la velocidad máxima.\r
  19     </PRE>}\r
  20 unit Nave;\r
  21 \r
  22 interface\r
  23 \r
  24 uses\r
  25   ObjetoVolador,\r
  26   Tipos,\r
  27   Vectores,\r
  28   Armas;\r
  29 \r
  30 type\r
  31   {** Clase abstracta con elementos comunes a todas las naves.}\r
  32   cNave = class( cObjetoVolador )\r
  33     private\r
  34       aMisiles:           tMaxMisil;         // Cantidad de misilies comunes\r
  35       aMisilesDirigidos:  tMaxMisilDirigido; // Cantidad de misiles dirigidos\r
  36       aVelMaxima:         tLongitud;        // Velocidad máxima de la nave\r
  37       aRetardoLaser:      tTiempo;          // Ratardo del arma antes de poder volver a disparar\r
  38       aRetardoMisil:      tTiempo;          // Ratardo del arma antes de poder volver a disparar\r
  39       aRetardoMisDir:     tTiempo;          // Ratardo del arma antes de poder volver a disparar\r
  40       aRetardoLaserCont:  tTiempo;          // Ratardo del arma antes de poder volver a disparar (contador)\r
  41       aRetardoMisilCont:  tTiempo;          // Ratardo del arma antes de poder volver a disparar (contador)\r
  42       aRetardoMisDirCont: tTiempo;          // Ratardo del arma antes de poder volver a disparar (contador)\r
  43     protected\r
  44       {** Setea la velocidad máxima}\r
  45       function mSetVelMax( velMax: tLongitud ): cNave;\r
  46       {** Resta un misil}\r
  47       function mRestarMisil: cNave;\r
  48       {** Resta un misil dirigido}\r
  49       function mRestarMisilDirigido: cNave;\r
  50       {** Devuelve true si todavía tiene misiles}\r
  51       function mTieneMisil: boolean;\r
  52       {** Devuelve true si todavía tiene misiles dirigidos}\r
  53       function mTieneMisilDirigido: boolean;\r
  54       {** Resetea el contador del retardo del láser}\r
  55       procedure mRetardarLaser;\r
  56       {** Resetea el contador del retardo del misil}\r
  57       procedure mRetardarMisil;\r
  58       {** Resetea el contador del retardo del misil dirigido}\r
  59       procedure mRetardarMisDir;\r
  60       {** Actualiza los retardadores}\r
  61       procedure mActualizarRetardadores( dT: tTiempo );\r
  62       {** Crea un laser (actualizando retardos y todo lo que sea necesario)}\r
  63       function mCrearLaserDisparado: cLaser;\r
  64       {** Crea un misil (actualizando retardos y todo lo que sea necesario)}\r
  65       function mCrearMisilDisparado: cMisil;\r
  66       {** Crea un misil dirigido (actualizando retardos y todo lo que sea necesario)}\r
  67       function mCrearMisDirDisparado( ov : cObjetoVolador ): cMisilDirigido;\r
  68     public\r
  69       {** Constructor}\r
  70       constructor create( pos: cVector = nil; vel: cVector = nil; dim: tLongitud = 5;\r
  71                           pot: tEnergia = 1; ene: tEnergia = 100; misiles: tMaxMisil = 0;\r
  72                           misilesDirigidos: tMaxMisilDirigido = 0; velMax: tLongitud = 0.2;\r
  73                           retardoLaser:   tTiempo = 1000;  {1 segundo}\r
  74                           retardoMisil:  tTiempo = 60000; {1 minuto}\r
  75                           retardoMisDir: tTiempo = 180000 {3 minutos}); overload;\r
  76       {** Hace que se dispare un arma (todavía no está implementado), devolviendo la nueva\r
  77           municion disparada}\r
  78       function mDisparar( dT: tTiempo; ov : cObjetoVolador = nil ): cArma; virtual;\r
  79       {** Obtiene la cantidad de Misiles que le quedan a la nave}\r
  80       function mGetMisiles: tMaxMisil;\r
  81       {** Obtiene la cantidad de Misiles Dirigidos que le quedan a la nave}\r
  82       function mGetMisilesDirigidos: tMaxMisilDirigido;\r
  83       {** Obtiene la velocidad máxima}\r
  84       function mGetVelMax: tLongitud;\r
  85       {** Método para establecer la velocidad}\r
  86       function mSetVelocidad( velocidad: cVector ): cObjetoVolador; override;\r
  87       {** Método para establecer el modulo de la velocidad}\r
  88       function mSetVelModulo( velocidad: tLongitud ): cObjetoVolador; override;\r
  89       {** Chequea que el enemigo este a distancia, que tenga municiones, etc.}\r
  90       function mPuedeDispararLaser( ov : cObjetoVolador ): boolean;\r
  91       {** Chequea que el enemigo este a distancia, que tenga municiones, etc.}\r
  92       function mPuedeDispararMisil( ov : cObjetoVolador ): boolean;\r
  93       {** Chequea que el enemigo este a distancia, que tenga municiones, etc.}\r
  94       function mPuedeDispararMisDir( ov : cObjetoVolador ): boolean;\r
  95       {$IFDEF DebugAlgoWars}\r
  96       {** Método heredado que devuelve un string con el estado del Objeto. Se utiliza para depurar\r
  97           y la información entregada depende del parámetro tDebugInfo.}\r
  98       function mGetDebugInfo( debugLevel: tDebugInfo = DI_MINI ): string; override;\r
  99       {$ENDIF}\r
 100       // SERIALIZACION\r
 101       {** Devuelve una cadena de texto con el objeto serializado.}\r
 102       function mSerializar: string; override;\r
 103       {** Recrea el objeto a partir de una cadena de texto con el objeto\r
 104           serializado.}\r
 105       procedure mDesSerializar( str: string ); override;\r
 106   end;\r
 107 \r
 108 implementation\r
 109 \r
 110 uses\r
 111   RegExpr,\r
 112   ObjetoPersistente,\r
 113   Sysutils;\r
 114 \r
 115 { cNave }\r
 116 \r
 117 {** Constructor\r
 118     @param pos              Posicion inicial\r
 119     @param vel              Velocidad inicial\r
 120     @param dim              Dimensión (radio, en metros)\r
 121     @param pot              Potencia (cantidad de daño que hace por intervalode tiempo)\r
 122     @param ene              Energía (cantidad de daño que soporta antes de ser destruido)\r
 123     @param misiles          Cantidad de misiles comunes\r
 124     @param misilesDirigidos Cantidad de misiles dirigidos\r
 125     @param velMax           Velocidad máxima que puede alcanzar (modulo)\r
 126     @param retardoLaser     Ratardo del arma antes de poder volver a disparar\r
 127     @param retardoMisil     Ratardo del arma antes de poder volver a disparar\r
 128     @param retardoMisDir    Ratardo del arma antes de poder volver a disparar}\r
 129 constructor cNave.create(pos, vel: cVector; dim: tLongitud; pot,\r
 130   ene: tEnergia; misiles: tMaxMisil; misilesDirigidos: tMaxMisilDirigido;\r
 131   velMax: tLongitud; retardoLaser: tTiempo; retardoMisil: tTiempo;\r
 132   retardoMisDir: tTiempo);\r
 133 begin\r
 134   if vel <> nil then\r
 135     if vel.mGetModulo > velMax then\r
 136       vel.mSetModulo( velMax );\r
 137   inherited create( pos, vel, dim, pot, ene );\r
 138   aMisiles := misiles;\r
 139   aMisilesDirigidos := misilesDirigidos;\r
 140   aVelMaxima := velMax;\r
 141   aRetardoLaser  := retardoLaser;\r
 142   aRetardoMisil  := retardoMisil;\r
 143   aRetardoMisDir := retardoMisDir;\r
 144   aRetardoLaserCont  := 0; // lista para disparar\r
 145   aRetardoMisilCont  := 0; // lista para disparar\r
 146   aRetardoMisDirCont := 0; // lista para disparar\r
 147 end;\r
 148 \r
 149 {$IFDEF DebugAlgoWars}\r
 150 {** Devuelve el estado del objeto basandose en la cantidad de datos requeridos.\r
 151     @return            Cadena de texto con el estado del Objeto.\r
 152     @param   debugLevel Cantidad de información requerida}\r
 153 function cNave.mGetDebugInfo(debugLevel: tDebugInfo): string;\r
 154 begin\r
 155   result := inherited mGetDebugInfo( debugLevel );\r
 156   if debugLevel > DI_MINI then\r
 157     result := result + ' | Misiles: ' + IntToStr( aMisiles ) +\r
 158               ' | Misiles Dirigidos: ' + IntToStr( aMisilesDirigidos );\r
 159 end;\r
 160 {$ENDIF}\r
 161 \r
 162 {** Devuelve la velocidad máxima\r
 163     @return Velocidad máxima (modulo)}\r
 164 function cNave.mGetVelMax: tLongitud;\r
 165 begin\r
 166   result := aVelMaxima;\r
 167 end;\r
 168 \r
 169 {** Resta un misil}\r
 170 function cNave.mRestarMisil: cNave;\r
 171 begin\r
 172   aMisiles := aMisiles - 1;\r
 173   result := self;\r
 174 end;\r
 175 \r
 176 {** Resta un misil dirigido}\r
 177 function cNave.mRestarMisilDirigido: cNave;\r
 178 begin\r
 179   aMisilesDirigidos := aMisilesDirigidos - 1;\r
 180   result := self;\r
 181 end;\r
 182 \r
 183 {** Setea la velocidad máxima\r
 184     @param velMax Nueva velocidad máxima (modulo)}\r
 185 function cNave.mSetVelMax(velMax: tLongitud): cNave;\r
 186 begin\r
 187   aVelMaxima := velMax;\r
 188   result := self;\r
 189 end;\r
 190 \r
 191 {** Chequea si todavía tiene misiles\r
 192     @return <i>true</i> si tiene misiles, <i>false</i> si no}\r
 193 function cNave.mTieneMisil: boolean;\r
 194 begin\r
 195   result := ( aMisiles > 0 ); // Devuelve true si aMisiles es mayor que cero\r
 196 end;\r
 197 \r
 198 {** Chequea si todavía tiene misiles dirigidos\r
 199     @return <i>true</i> si tiene misiles dirigidos, <i>false</i> si no}\r
 200 function cNave.mTieneMisilDirigido: boolean;\r
 201 begin\r
 202   result := ( aMisilesDirigidos > 0 ); // Devuelve true si aMisilesDirigidos es mayor que cero\r
 203 end;\r
 204 \r
 205 {** Chequea que el enemigo este a distancia, que tenga municiones, etc.\r
 206     @param  np Nave Propia a la que quiere disparar\r
 207     @return <i>True</i> si está todo ok, <i>False</i> si no.}\r
 208 function cNave.mPuedeDispararLaser( ov : cObjetoVolador ): boolean;\r
 209 begin\r
 210   result := false;\r
 211   if aRetardoLaserCont <= 0 then // Primero se fija que ya esté recargada el arma\r
 212     // 1200 es el alcance del laser.\r
 213     if ov <> nil then begin // Si el ov es nil puede disparar, ni no lo es, chequea la distancia\r
 214       if mGetDistancia( ov ) < 1200 then// Si la distancia a la np es menor que el alcance\r
 215         result := true;\r
 216     end else\r
 217       result := true;\r
 218 end;\r
 219 \r
 220 {** Chequea que el enemigo este a distancia, que tenga municiones, etc.\r
 221     @param  np Nave Propia a la que quiere disparar\r
 222     @return <i>True</i> si está todo ok, <i>False</i> si no.}\r
 223 function cNave.mPuedeDispararMisil( ov : cObjetoVolador ): boolean;\r
 224 begin\r
 225   result := false;\r
 226   // Primero se fija que ya esté recargada el arma y que todavia tenga municiones\r
 227   if mTieneMisil and ( aRetardoMisilCont <= 0 ) then\r
 228     // 1500 es el alcance del misil.\r
 229     if ov <> nil then begin // Si el ov es nil puede disparar, ni no lo es, chequea la distancia\r
 230       if mGetDistancia( ov ) < 1500 then// Si la distancia a la np es menor que el alcance\r
 231         result := true;\r
 232     end else\r
 233       result := true;\r
 234 end;\r
 235 \r
 236 {** Chequea que el enemigo este a distancia, que tenga municiones, etc.\r
 237     @param  np Nave Propia a la que quiere disparar\r
 238     @return <i>True</i> si está todo ok, <i>False</i> si no.}\r
 239 function cNave.mPuedeDispararMisDir( ov : cObjetoVolador ): boolean;\r
 240 begin\r
 241   result := false;\r
 242   // Primero se fija que ya esté recargada el arma y que todavia tenga municiones\r
 243   if mTieneMisilDirigido and ( aRetardoMisDirCont <= 0 ) then\r
 244     // 2000 es el alcance del misil dirigido.\r
 245     if ov <> nil then begin // Si el ov es nil puede disparar, ni no lo es, chequea la distancia\r
 246       if mGetDistancia( ov ) < 2000 then// Si la distancia a la np es menor que el alcance\r
 247         result := true;\r
 248     end else\r
 249       result := true;\r
 250 end;\r
 251 \r
 252 {** Hace que se dispare un arma\r
 253     @param  ov Objetivo del disparo\r
 254     @param  dT Intervalo de tiempo\r
 255     @return Arma disparada (o <i>nil</i> si no se puede disparar ningún arma)}\r
 256 function cNave.mDisparar( dT: tTiempo; ov : cObjetoVolador ): cArma;\r
 257 begin\r
 258   result := nil; // devuelve nil por defecto\r
 259   mActualizarRetardadores( dT );\r
 260   if mPuedeDispararMisDir( ov ) then\r
 261     result := mCrearMisDirDisparado( ov )\r
 262   else if mPuedeDispararMisil( ov ) then\r
 263     result := mCrearMisilDisparado\r
 264   else if mPuedeDispararLaser( ov ) then\r
 265     result := mCrearLaserDisparado;\r
 266 end;\r
 267 \r
 268 {** Obtiene la cantidad de Misiles que le quedan a la nave\r
 269     return Cantidad de misiles que le quedan a la nave}\r
 270 function cNave.mGetMisiles: tMaxMisil;\r
 271 begin\r
 272   result := aMisiles;\r
 273 end;\r
 274 \r
 275 {** Obtiene la cantidad de Misiles que le quedan a la nave\r
 276     return Cantidad de misiles dirigidos que le quedan a la nave}\r
 277 function cNave.mGetMisilesDirigidos: tMaxMisilDirigido;\r
 278 begin\r
 279   result := aMisilesDirigidos;\r
 280 end;\r
 281 \r
 282 {** Resetea el contador del retardo del láser}\r
 283 procedure cNave.mRetardarLaser;\r
 284 begin\r
 285   aRetardoLaserCont := aRetardoLaser;\r
 286 end;\r
 287 \r
 288 {** Resetea el contador del retardo del misil dirigido}\r
 289 procedure cNave.mRetardarMisDir;\r
 290 begin\r
 291   aRetardoMisDirCont := aRetardoMisDir;\r
 292 end;\r
 293 \r
 294 {** Resetea el contador del retardo del misil}\r
 295 procedure cNave.mRetardarMisil;\r
 296 begin\r
 297   aRetardoMisilCont := aRetardoMisil;\r
 298 end;\r
 299 \r
 300 {** Actualiza los retardadores\r
 301     @param dT Intervalo de tiempo a restarles}\r
 302 procedure cNave.mActualizarRetardadores(dT: tTiempo);\r
 303 begin\r
 304   if aRetardoMisDirCont > 0 then\r
 305     aRetardoMisDirCont := aRetardoMisDirCont - dT;\r
 306   if aRetardoMisilCont > 0 then\r
 307     aRetardoMisilCont := aRetardoMisilCont - dT;\r
 308   if aRetardoLaserCont > 0 then\r
 309     aRetardoLaserCont := aRetardoLaserCont - dT;\r
 310 end;\r
 311 \r
 312 {** Crea un láser (actualizando retardos)\r
 313     @return Nuevo láser}\r
 314 function cNave.mCrearLaserDisparado: cLaser;\r
 315 var\r
 316   pos,\r
 317   vel,\r
 318   vec: cVector;\r
 319 begin\r
 320     mRetardarLaser; // Resetea el retardo\r
 321     // Se calcula la posicion a partir de la posicion de la nave propia y sumandole el 150% de\r
 322     // su tamaño en la direccion de i (para que no colisione con quien dispara).\r
 323     vec := mGetI.mMultiplicar( mGetDimension * 1.5 );\r
 324     pos := mGetPosicion.mSumar( vec );\r
 325     // vec tambien me va a servir como la dirección de la velocidad porque tiene la direccion de i\r
 326     vel := vec;\r
 327     // devuelve el arma disparada\r
 328     result := cLaser.create( pos, vel );\r
 329     // Libera memoria\r
 330     pos.free;\r
 331     vec.free;\r
 332 end;\r
 333 \r
 334 {** Crea un misil dirigido (actualizando retardos y restando un misil dirigido)\r
 335     @param  ov Objetivo del misil dirigido\r
 336     @return Nuevo misil dirigido}\r
 337 function cNave.mCrearMisDirDisparado( ov : cObjetoVolador ): cMisilDirigido;\r
 338 var\r
 339   pos,\r
 340   vec: cVector;\r
 341 begin\r
 342     mRestarMisilDirigido;\r
 343     mRetardarMisDir; // Resetea el retardo\r
 344     // Se calcula la posicion a partir de la posicion de la nave propia y sumandole el 150% de\r
 345     // su tamaño en la direccion de i (para que no colisione con quien dispara)\r
 346     vec := mGetI.mMultiplicar( mGetDimension * 1.5 );\r
 347     pos := mGetPosicion.mSumar( vec );\r
 348     // devuelve el arma disparada\r
 349     result := cMisilDirigido.create( ov, pos );\r
 350     // Libera memoria\r
 351     pos.free;\r
 352     vec.free;\r
 353 end;\r
 354 \r
 355 {** Crea un misil dirigido (actualizando retardos y restando un misil)\r
 356     @return Nuevo misil}\r
 357 function cNave.mCrearMisilDisparado: cMisil;\r
 358 var\r
 359   pos,\r
 360   vel,\r
 361   vec: cVector;\r
 362 begin\r
 363     mRestarMisil;   // Resta un misil\r
 364     mRetardarMisil; // Resetea el retardo\r
 365     // Se calcula la posicion a partir de la posicion de la nave propia y sumandole el 150% de\r
 366     // su tamaño en la direccion de i (para que no colisione con quien dispara)\r
 367     vec := mGetI.mMultiplicar( mGetDimension * 1.5 );\r
 368     pos := mGetPosicion.mSumar( vec );\r
 369     // vec tambien me va a servir como la dirección de la velocidad porque tiene la direccion de i\r
 370     vel := vec;\r
 371     // devuelve el arma disparada\r
 372     result := cMisil.create( pos, vel );\r
 373     // Libera memoria\r
 374     pos.free;\r
 375     vec.free\r
 376 end;\r
 377 \r
 378 {** Recrea el objeto a partir de una cadena de texto con el objeto\r
 379     serializado.\r
 380     @param str Cadena de texto con el objeto serializado.}\r
 381 procedure cNave.mDesSerializar(str: string);\r
 382 var\r
 383   r: TRegExpr;\r
 384 begin\r
 385   inherited mDesSerializar( str ); // SIEMPRE el ID debe ser el PRIMER atributo\r
 386   r := TRegExpr.create;\r
 387   // MISILES\r
 388   try // se fija si hay errores al extraer los datos\r
 389     r.Expression := '<misiles>\s*(\d+)\s*</misiles>'; // contruye la expresion regular a buscar\r
 390     if r.Exec ( str ) then // Ejecuta la expresion. Si la encuentra...\r
 391       aMisiles := StrToInt( r.Match[1] )\r
 392     else // si no encontro la experesion...\r
 393       raise ESerializacion.create( 'No se encontro la cantidad de misiles' ); // cae en una excepcion\r
 394   except // Si hubieron errores ...\r
 395     on e: ERegExpr do begin // si fueron de expresiones regulares...\r
 396       r.Free; // libera memoria\r
 397       raise ESerializacion.create( ClassName + ': Error al extraer la cantidad de misiles utilizando expresiones regulares: ' + e.Message ); // cae en una excepcion\r
 398     end;\r
 399   end;\r
 400   // MISILESDIRIGIDOS\r
 401   try // se fija si hay errores al extraer los datos\r
 402     r.Expression := '<misilesdirigidos>\s*(\d+)\s*</misilesdirigidos>'; // contruye la expresion regular a buscar\r
 403     if r.Exec ( str ) then // Ejecuta la expresion. Si la encuentra...\r
 404       aMisilesDirigidos := StrToInt( r.Match[1] )\r
 405     else // si no encontro la experesion...\r
 406       raise ESerializacion.create( 'No se encontro la cantidad de misiles dirigidos' ); // cae en una excepcion\r
 407   except // Si hubieron errores ...\r
 408     on e: ERegExpr do begin // si fueron de expresiones regulares...\r
 409       r.Free; // libera memoria\r
 410       raise ESerializacion.create( ClassName + ': Error al extraer la cantidad de misiles dirigidos utilizando expresiones regulares: ' + e.Message ); // cae en una excepcion\r
 411     end;\r
 412   end;\r
 413   // VELMAXIMA\r
 414   try // se fija si hay errores al extraer los datos\r
 415     r.Expression := '<velmaxima>\s*([+\-]?\d+(\,\d+)?([eE][+\-]?\d+)?)\s*</velmaxima>'; // contruye la expresion regular a buscar\r
 416     if r.Exec ( str ) then // Ejecuta la expresion. Si la encuentra...\r
 417       aVelMaxima := StrToFloat( r.Match[1] )\r
 418     else // si no encontro la experesion...\r
 419       raise ESerializacion.create( 'No se encontro la velocidad maxima' ); // cae en una excepcion\r
 420   except // Si hubieron errores ...\r
 421     on e: ERegExpr do begin // si fueron de expresiones regulares...\r
 422       r.Free; // libera memoria\r
 423       raise ESerializacion.create( ClassName + ': Error al extraer la velocidad maxima utilizando expresiones regulares: ' + e.Message ); // cae en una excepcion\r
 424     end;\r
 425   end;\r
 426   // RETARDOLASER\r
 427   try // se fija si hay errores al extraer los datos\r
 428     r.Expression := '<retardolaser>\s*([+\-]?\d+(\,\d+)?([eE][+\-]?\d+)?)\s*</retardolaser>'; // contruye la expresion regular a buscar\r
 429     if r.Exec ( str ) then // Ejecuta la expresion. Si la encuentra...\r
 430       aRetardoLaser := StrToFloat( r.Match[1] )\r
 431     else // si no encontro la experesion...\r
 432       raise ESerializacion.create( 'No se encontro el retardo del laser' ); // cae en una excepcion\r
 433   except // Si hubieron errores ...\r
 434     on e: ERegExpr do begin // si fueron de expresiones regulares...\r
 435       r.Free; // libera memoria\r
 436       raise ESerializacion.create( ClassName + ': Error al extraer el retardo del laser utilizando expresiones regulares: ' + e.Message ); // cae en una excepcion\r
 437     end;\r
 438   end;\r
 439   // RETARDOMISIL\r
 440   try // se fija si hay errores al extraer los datos\r
 441     r.Expression := '<retardomisil>\s*([+\-]?\d+(\,\d+)?([eE][+\-]?\d+)?)\s*</retardomisil>'; // contruye la expresion regular a buscar\r
 442     if r.Exec ( str ) then // Ejecuta la expresion. Si la encuentra...\r
 443       aRetardoMisil := StrToFloat( r.Match[1] )\r
 444     else // si no encontro la experesion...\r
 445       raise ESerializacion.create( 'No se encontro el retardo del misil' ); // cae en una excepcion\r
 446   except // Si hubieron errores ...\r
 447     on e: ERegExpr do begin // si fueron de expresiones regulares...\r
 448       r.Free; // libera memoria\r
 449       raise ESerializacion.create( ClassName + ': Error al extraer el retardo del misil utilizando expresiones regulares: ' + e.Message ); // cae en una excepcion\r
 450     end;\r
 451   end;\r
 452   // RETARDOMISDIR\r
 453   try // se fija si hay errores al extraer los datos\r
 454     r.Expression := '<retardomisdir>\s*([+\-]?\d+(\,\d+)?([eE][+\-]?\d+)?)\s*</retardomisdir>'; // contruye la expresion regular a buscar\r
 455     if r.Exec ( str ) then // Ejecuta la expresion. Si la encuentra...\r
 456       aRetardoMisDir := StrToFloat( r.Match[1] )\r
 457     else // si no encontro la experesion...\r
 458       raise ESerializacion.create( 'No se encontro el retardo del misil dirigido' ); // cae en una excepcion\r
 459   except // Si hubieron errores ...\r
 460     on e: ERegExpr do begin // si fueron de expresiones regulares...\r
 461       r.Free; // libera memoria\r
 462       raise ESerializacion.create( ClassName + ': Error al extraer el retardo del misil dirigido utilizando expresiones regulares: ' + e.Message ); // cae en una excepcion\r
 463     end;\r
 464   end;\r
 465   // RETARDOLASERCONT\r
 466   try // se fija si hay errores al extraer los datos\r
 467     r.Expression := '<retardolasercont>\s*([+\-]?\d+(\,\d+)?([eE][+\-]?\d+)?)\s*</retardolasercont>'; // contruye la expresion regular a buscar\r
 468     if r.Exec ( str ) then // Ejecuta la expresion. Si la encuentra...\r
 469       aRetardoLaserCont := StrToFloat( r.Match[1] )\r
 470     else // si no encontro la experesion...\r
 471       raise ESerializacion.create( 'No se encontro el contador del retardo del laser' ); // cae en una excepcion\r
 472   except // Si hubieron errores ...\r
 473     on e: ERegExpr do begin // si fueron de expresiones regulares...\r
 474       r.Free; // libera memoria\r
 475       raise ESerializacion.create( ClassName + ': Error al extraer el contador del retardo del laser utilizando expresiones regulares: ' + e.Message ); // cae en una excepcion\r
 476     end;\r
 477   end;\r
 478   // RETARDOMISIL\r
 479   try // se fija si hay errores al extraer los datos\r
 480     r.Expression := '<retardomisilcont>\s*([+\-]?\d+(\,\d+)?([eE][+\-]?\d+)?)\s*</retardomisilcont>'; // contruye la expresion regular a buscar\r
 481     if r.Exec ( str ) then // Ejecuta la expresion. Si la encuentra...\r
 482       aRetardoMisilCont := StrToFloat( r.Match[1] )\r
 483     else // si no encontro la experesion...\r
 484       raise ESerializacion.create( 'No se encontro el contador del retardo del misil' ); // cae en una excepcion\r
 485   except // Si hubieron errores ...\r
 486     on e: ERegExpr do begin // si fueron de expresiones regulares...\r
 487       r.Free; // libera memoria\r
 488       raise ESerializacion.create( ClassName + ': Error al extraer el contador del retardo del misil utilizando expresiones regulares: ' + e.Message ); // cae en una excepcion\r
 489     end;\r
 490   end;\r
 491   // RETARDOMISDIR\r
 492   try // se fija si hay errores al extraer los datos\r
 493     r.Expression := '<retardomisdircont>\s*([+\-]?\d+(\,\d+)?([eE][+\-]?\d+)?)\s*</retardomisdircont>'; // contruye la expresion regular a buscar\r
 494     if r.Exec ( str ) then // Ejecuta la expresion. Si la encuentra...\r
 495       aRetardoMisDirCont := StrToFloat( r.Match[1] )\r
 496     else // si no encontro la experesion...\r
 497       raise ESerializacion.create( 'No se encontro el contador del retardo del misil dirigido' ); // cae en una excepcion\r
 498   except // Si hubieron errores ...\r
 499     on e: ERegExpr do begin // si fueron de expresiones regulares...\r
 500       r.Free; // libera memoria\r
 501       raise ESerializacion.create( ClassName + ': Error al extraer el contador del retardo del misil dirigido utilizando expresiones regulares: ' + e.Message ); // cae en una excepcion\r
 502     end;\r
 503   end;\r
 504   r.free;\r
 505 end;\r
 506 \r
 507 {** Devuelve una cadena de texto con el objeto serializado.\r
 508     @return Cadena de texto con el objeto serializado.}\r
 509 function cNave.mSerializar: string;\r
 510 begin\r
 511   result := inherited mSerializar +\r
 512             '<misiles>' + IntToStr( aMisiles ) + '</misiles>' +\r
 513             '<misilesdirigidos>' + IntToStr( aMisilesDirigidos ) + '</misilesdirigidos>' +\r
 514             '<velmaxima>' + FloatToStrF( aVelMaxima, ffGeneral, 18, 0 ) + '</velmaxima>' +\r
 515             '<retardolaser>' + FloatToStrF( aRetardoLaser, ffGeneral, 18, 0 ) + '</retardolaser>' +\r
 516             '<retardomisil>' + FloatToStrF( aRetardoMisil, ffGeneral, 18, 0 ) + '</retardomisil>' +\r
 517             '<retardomisdir>' + FloatToStrF( aRetardoMisDir, ffGeneral, 18, 0 ) + '</retardomisdir>' +\r
 518             '<retardolasercont>' + FloatToStrF( aRetardoLaserCont, ffGeneral, 18, 0 ) + '</retardolasercont>' +\r
 519             '<retardomisilcont>' + FloatToStrF( aRetardoMisilCont, ffGeneral, 18, 0 ) + '</retardomisilcont>' +\r
 520             '<retardomisdircont>' + FloatToStrF( aRetardoMisDirCont, ffGeneral, 18, 0 ) + '</retardomisdircont>';\r
 521 end;\r
 522 \r
 523 {** Método para establecer la velocidad}\r
 524 function cNave.mSetVelModulo(velocidad: tLongitud): cObjetoVolador;\r
 525 begin\r
 526   if velocidad > aVelMaxima then\r
 527     velocidad := aVelMaxima;\r
 528   result := inherited mSetVelModulo( velocidad );\r
 529 end;\r
 530 \r
 531 {** Método para establecer el modulo de la velocidad}\r
 532 function cNave.mSetVelocidad(velocidad: cVector): cObjetoVolador;\r
 533 begin\r
 534   if velocidad.mGetModulo > aVelMaxima then begin // Si sobrepasa el limite ...\r
 535     mSetVelModulo( aVelMaxima ); // Se le asigna el modulo como limite\r
 536     mSetVelDir( velocidad );     // Se le asigna la direccion\r
 537     result := self;\r
 538   end else // Si no sobrepasa el limite ...\r
 539     result := inherited mSetVelocidad( velocidad ); // Se asigna la nueva vel\r
 540 end;\r
 541 \r
 542 end.\r