ryzom/server/src/ai_share/ai_event.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17
  18
  19 #include "stdpch.h"
  20 #include "ai_event.h"
  21
  22 using namespace std;
  23 using namespace NLMISC;
  24
  25 NL_INSTANCE_COUNTER_IMPL(IAIEvent);
  26 NL_INSTANCE_COUNTER_IMPL(CAIStunEvent);
  27 NL_INSTANCE_COUNTER_IMPL(CAIStunEndEvent);
  28
  29 //------------------------------IMPORTANT----------------------------------
  30 // The EventType isn't read in the serial as it is used in the read process
  31 // to get the right event type (in the AI service)
  32 //-------------------------------------------------------------------------
  33
  34
  35
  36 //--------------------------------------------------------------
  37 //                                              CAIStunEvent::serial()
  38 //--------------------------------------------------------------
  39 void CAIStunEvent::serial(NLMISC::IStream &f)
  40 {
  41         if (f.isReading() )
  42         {
  43 //              CAIEventType type;
  44                 uint16 size;
  45 //              f.serial(type);
  46                 f.serial(size);
  47
  48                 if (/*type != CAIEventType("STUN") || */size != sizeof(CAIStunEvent))
  49                 {
  50                         CreatureId = NLMISC::CEntityId();
  51                         try
  52                         {
  53                                 // seek takes a param in bytes (8 bits)
  54                                 f.seek( size, NLMISC::IStream::current);
  55                         }
  56                         catch(const ESeekNotSupported &)
  57                         {
  58                                 uint8 tmp;
  59                                 for (uint i = 0 ; i < size ; ++i)
  60                                         f.serial(tmp);
  61                         }
  62                 }
  63                 else
  64                 {
  65                         f.serial(CreatureId);
  66                 }
  67         }
  68         else
  69         {
  70                 CAIEventType type("STUN");
  71                 uint16 size = sizeof(CAIStunEvent);
  72
  73                 f.serial(type);
  74                 f.serial(size);
  75                 f.serial(CreatureId);
  76         }
  77 } // CAIStunEvent::serial //
  78
  79
  80
  81 //--------------------------------------------------------------
  82 //                                              CAIAggroEvent::serial()
  83 //--------------------------------------------------------------
  84 void CAIAggroEvent::serial(NLMISC::IStream &f)
  85 {
  86         if (f.isReading() )
  87         {
  88 //              CAIEventType type;
  89                 uint16 size;
  90 //              f.serial(type);
  91                 f.serial(size);
  92
  93                 if (/*type != CAIEventType("AGGRO") || */size != sizeof(CAIAggroEvent))
  94                 {
  95                         CreatureId = NLMISC::CEntityId();
  96                         EntityId = NLMISC::CEntityId();
  97                         AggroModifier = 0;
  98                         try
  99                         {
 100                                 // seek takes a param in bytes (8 bits)
 101                                 f.seek( size, NLMISC::IStream::current);
 102                         }
 103                         catch(const ESeekNotSupported &)
 104                         {
 105                                 uint8 tmp;
 106                                 for (uint i = 0 ; i < size ; ++i)
 107                                         f.serial(tmp);
 108                         }
 109                 }
 110                 else
 111                 {
 112                         f.serial(CreatureId);
 113                         f.serial(EntityId);
 114                         f.serial(AggroModifier);
 115                 }
 116         }
 117         else
 118         {
 119                 CAIEventType type("AGGRO");
 120                 uint16 size = sizeof(CAIAggroEvent);
 121
 122                 f.serial(type);
 123                 f.serial(size);
 124                 f.serial(CreatureId);
 125                 f.serial(EntityId);
 126                 f.serial(AggroModifier);
 127         }
 128 } // CAIAggroEvent::serial //
 129
 130
 131
 132
 133 //--------------------------------------------------------------
 134 //                                              CAIStunEndEvent::serial()
 135 //--------------------------------------------------------------
 136 void CAIStunEndEvent::serial(NLMISC::IStream &f)
 137 {
 138         if (f.isReading() )
 139         {
 140         //      CAIEventType type;
 141                 uint16 size;
 142         //      f.serial(type);
 143                 f.serial(size);
 144
 145                 if (/*type != CAIEventType("STUN_END") ||*/ size != sizeof(CAIStunEndEvent))
 146                 {
 147                         CreatureId = NLMISC::CEntityId();
 148                         try
 149                         {
 150                                 // seek takes a param in bytes (8 bits)
 151                                 f.seek( size, NLMISC::IStream::current);
 152                         }
 153                         catch(const ESeekNotSupported &)
 154                         {
 155                                 uint8 tmp;
 156                                 for (uint i = 0 ; i < size ; ++i)
 157                                         f.serial(tmp);
 158                         }
 159                 }
 160                 else
 161                 {
 162                         f.serial(CreatureId);
 163                 }
 164         }
 165         else
 166         {
 167                 CAIEventType type("STUN_END");
 168                 uint16 size = sizeof(CAIStunEndEvent);
 169
 170                 f.serial(type);
 171                 f.serial(size);
 172                 f.serial(CreatureId);
 173         }
 174 } // CAIStunEndEvent::serial //
 175
 176
 177
 178
 179 //--------------------------------------------------------------
 180 //                                              CAISurvivalInstinctEvent::serial()
 181 //--------------------------------------------------------------
 182 void CAISurvivalInstinctEvent::serial(NLMISC::IStream &f)
 183 {
 184         if (f.isReading() )
 185         {
 186         //      CAIEventType type;
 187                 uint16 size;
 188         //      f.serial(type);
 189                 f.serial(size);
 190
 191                 if (/*type != CAIEventType("SURVIE") ||*/ size != sizeof(CAISurvivalInstinctEvent))
 192                 {
 193                         CreatureId = NLMISC::CEntityId();
 194                         EntityId = NLMISC::CEntityId();
 195                         Modifier = 0;
 196                         try
 197                         {
 198                                 // seek takes a param in bytes (8 bits)
 199                                 f.seek( size, NLMISC::IStream::current);
 200                         }
 201                         catch(const ESeekNotSupported &)
 202                         {
 203                                 uint8 tmp;
 204                                 for (uint i = 0 ; i < size ; ++i)
 205                                         f.serial(tmp);
 206                         }
 207                 }
 208                 else
 209                 {
 210                         f.serial(CreatureId);
 211                         f.serial(EntityId);
 212                         f.serial(Modifier);
 213                 }
 214         }
 215         else
 216         {
 217                 CAIEventType type("SURVIE");
 218                 uint16 size = sizeof(CAISurvivalInstinctEvent);
 219
 220                 f.serial(type);
 221                 f.serial(size);
 222                 f.serial(CreatureId);
 223                 f.serial(EntityId);
 224                 f.serial(Modifier);
 225
 226         }
 227 } // CAISurvivalInstinctEvent::serial //
 228
 229
 230
 231 //--------------------------------------------------------------
 232 //                                              CAIFearEvent::serial()
 233 //--------------------------------------------------------------
 234 void CAIFearEvent::serial(NLMISC::IStream &f)
 235 {
 236         if (f.isReading() )
 237         {
 238         //      CAIEventType type;
 239                 uint16 size;
 240         //      f.serial(type);
 241                 f.serial(size);
 242
 243                 if (/*type != CAIEventType("FEAR") ||*/ size != sizeof(CAIFearEvent))
 244                 {
 245                         CreatureId = NLMISC::CEntityId();
 246                         EntityId = NLMISC::CEntityId();
 247                         try
 248                         {
 249                                 // seek takes a param in bytes (8 bits)
 250                                 f.seek( size, NLMISC::IStream::current);
 251                         }
 252                         catch(const ESeekNotSupported &)
 253                         {
 254                                 uint8 tmp;
 255                                 for (uint i = 0 ; i < size ; ++i)
 256                                         f.serial(tmp);
 257                         }
 258                 }
 259                 else
 260                 {
 261                         f.serial(CreatureId);
 262                         f.serial(EntityId);
 263                 }
 264         }
 265         else
 266         {
 267                 CAIEventType type("FEAR");
 268                 uint16 size = sizeof(CAIFearEvent);
 269
 270                 f.serial(type);
 271                 f.serial(size);
 272                 f.serial(CreatureId);
 273                 f.serial(EntityId);
 274         }
 275 } // CAIFearEvent::serial //
 276
 277
 278 //--------------------------------------------------------------
 279 //                                              CAIFearEndEvent::serial()
 280 //--------------------------------------------------------------
 281 void CAIFearEndEvent::serial(NLMISC::IStream &f)
 282 {
 283         if (f.isReading() )
 284         {
 285                 //CAIEventType type;
 286                 uint16 size;
 287                 //f.serial(type);
 288                 f.serial(size);
 289
 290                 if (/*type != CAIEventType("FEAR_END") ||*/ size != sizeof(CAIFearEndEvent))
 291                 {
 292                         CreatureId = NLMISC::CEntityId();
 293                         EntityId = NLMISC::CEntityId();
 294                         try
 295                         {
 296                                 // seek takes a param in bytes (8 bits)
 297                                 f.seek( size, NLMISC::IStream::current);
 298                         }
 299                         catch(const ESeekNotSupported &)
 300                         {
 301                                 uint8 tmp;
 302                                 for (uint i = 0 ; i < size ; ++i)
 303                                         f.serial(tmp);
 304                         }
 305                 }
 306                 else
 307                 {
 308                         f.serial(CreatureId);
 309                         f.serial(EntityId);
 310                 }
 311         }
 312         else
 313         {
 314                 CAIEventType type("FEAR_END");
 315                 uint16 size = sizeof(CAIFearEndEvent);
 316
 317                 f.serial(type);
 318                 f.serial(size);
 319                 f.serial(CreatureId);
 320                 f.serial(EntityId);
 321         }
 322 } // CAIFearEndEvent::serial //
 323
 324
 325
 326 //--------------------------------------------------------------
 327 //                                              CAIHungerEvent::serial()
 328 //--------------------------------------------------------------
 329 void CAIHungerEvent::serial(NLMISC::IStream &f)
 330 {
 331         if (f.isReading() )
 332         {
 333                 //CAIEventType type;
 334                 uint16 size;
 335                 //f.serial(type);
 336                 f.serial(size);
 337
 338                 if (/*type != CAIEventType("HUNGER") ||*/ size != sizeof(CAIHungerEvent))
 339                 {
 340                         CreatureId = NLMISC::CEntityId();
 341                         Modifier = 0;
 342                         try
 343                         {
 344                                 // seek takes a param in bytes (8 bits)
 345                                 f.seek( size, NLMISC::IStream::current);
 346                         }
 347                         catch(const ESeekNotSupported &)
 348                         {
 349                                 uint8 tmp;
 350                                 for (uint i = 0 ; i < size ; ++i)
 351                                         f.serial(tmp);
 352                         }
 353                 }
 354                 else
 355                 {
 356                         f.serial(CreatureId);
 357                         f.serial(Modifier);
 358                 }
 359         }
 360         else
 361         {
 362                 CAIEventType type("HUNGER");
 363                 uint16 size = sizeof(CAIHungerEvent);
 364
 365                 f.serial(type);
 366                 f.serial(size);
 367                 f.serial(CreatureId);
 368                 f.serial(Modifier);
 369         }
 370 } // CAIHungerEvent::serial //
 371