web/public_php/ring/ring_session_manager_itf.php

   1 <?php
   2         require_once('welcome_service_itf.php');
   3 ?>
   4 <?php
   5         /////////////////////////////////////////////////////////////////
   6         // WARNING : this is a generated file, don't change it !
   7         /////////////////////////////////////////////////////////////////
   8
   9         $arrayCounter = 0;
  10         $RSMGR_TSessionPartStatus_EnumValues[$arrayCounter++] = "sps_play_subscribed";
  11         $RSMGR_TSessionPartStatus_EnumValues[$arrayCounter++] = "sps_play_invited";
  12         $RSMGR_TSessionPartStatus_EnumValues[$arrayCounter++] = "sps_edit_invited";
  13         $RSMGR_TSessionPartStatus_EnumValues[$arrayCounter++] = "sps_anim_invited";
  14         $RSMGR_TSessionPartStatus_EnumValues[$arrayCounter++] = "sps_playing";
  15         $RSMGR_TSessionPartStatus_EnumValues[$arrayCounter++] = "sps_editing";
  16         $RSMGR_TSessionPartStatus_EnumValues[$arrayCounter++] = "sps_animating";
  17         $RSMGR_TSessionPartStatus_EnumValues[$arrayCounter] = "invalid";
  18         $RSMGR_TSessionPartStatus_InvalidValue = $arrayCounter;
  19
  20         class RSMGR_TSessionPartStatus
  21         {
  22                 var $Value;
  23
  24                 function __construct()
  25                 {
  26                         global $RSMGR_TSessionPartStatus_InvalidValue;
  27                         $this->Value = $RSMGR_TSessionPartStatus_InvalidValue;
  28                 }
  29
  30                 function toString()
  31                 {
  32                         global $RSMGR_TSessionPartStatus_EnumValues;
  33                         return $RSMGR_TSessionPartStatus_EnumValues[$this->Value];
  34                 }
  35
  36                 function fromString($strValue)
  37                 {
  38                         global $RSMGR_TSessionPartStatus_EnumValues;
  39                         foreach ($RSMGR_TSessionPartStatus_EnumValues as $k => $v)
  40                         {
  41                                 if ($strValue === $v)
  42                                 {
  43                                         $this->Value = $k;
  44                                         return;
  45                                 }
  46                         }
  47
  48                         $this->Value = $RSMGR_TSessionPartStatus_InvalidValue;
  49                 }
  50
  51                 function toInt()
  52                 {
  53                         return $this->Value;
  54                 }
  55
  56                 function fromInt($intValue)
  57                 {
  58                         global $RSMGR_TSessionPartStatus_InvalidValue;
  59                         global $RSMGR_TSessionPartStatus_EnumValues;
  60                         if (array_key_exists($intValue, $RSMGR_TSessionPartStatus_EnumValues))
  61                                 $this->Value = $intValue;
  62                         else
  63                                 $this->Value = $RSMGR_TSessionPartStatus_InvalidValue;
  64                 }
  65         }
  66 ?>
  67 <?php
  68         /////////////////////////////////////////////////////////////////
  69         // WARNING : this is a generated file, don't change it !
  70         /////////////////////////////////////////////////////////////////
  71
  72         $arrayCounter = 0;
  73         $RSMGR_TSessionType_EnumValues[$arrayCounter++] = "st_edit";
  74         $RSMGR_TSessionType_EnumValues[$arrayCounter++] = "st_anim";
  75         $RSMGR_TSessionType_EnumValues[$arrayCounter++] = "st_outland";
  76         $RSMGR_TSessionType_EnumValues[$arrayCounter++] = "st_mainland";
  77         $RSMGR_TSessionType_EnumValues[$arrayCounter] = "invalid";
  78         $RSMGR_TSessionType_InvalidValue = $arrayCounter;
  79
  80         class RSMGR_TSessionType
  81         {
  82                 var $Value;
  83
  84                 function __construct()
  85                 {
  86                         global $RSMGR_TSessionType_InvalidValue;
  87                         $this->Value = $RSMGR_TSessionType_InvalidValue;
  88                 }
  89
  90                 function toString()
  91                 {
  92                         global $RSMGR_TSessionType_EnumValues;
  93                         return $RSMGR_TSessionType_EnumValues[$this->Value];
  94                 }
  95
  96                 function fromString($strValue)
  97                 {
  98                         global $RSMGR_TSessionType_EnumValues;
  99                         foreach ($RSMGR_TSessionType_EnumValues as $k => $v)
 100                         {
 101                                 if ($strValue === $v)
 102                                 {
 103                                         $this->Value = $k;
 104                                         return;
 105                                 }
 106                         }
 107
 108                         $this->Value = $RSMGR_TSessionType_InvalidValue;
 109                 }
 110
 111                 function toInt()
 112                 {
 113                         return $this->Value;
 114                 }
 115
 116                 function fromInt($intValue)
 117                 {
 118                         global $RSMGR_TSessionType_InvalidValue;
 119                         global $RSMGR_TSessionType_EnumValues;
 120                         if (array_key_exists($intValue, $RSMGR_TSessionType_EnumValues))
 121                                 $this->Value = $intValue;
 122                         else
 123                                 $this->Value = $RSMGR_TSessionType_InvalidValue;
 124                 }
 125         }
 126 ?>
 127 <?php
 128         /////////////////////////////////////////////////////////////////
 129         // WARNING : this is a generated file, don't change it !
 130         /////////////////////////////////////////////////////////////////
 131
 132         $arrayCounter = 0;
 133         $RSMGR_TSessionOrientation_EnumValues[$arrayCounter++] = "so_newbie_training";
 134         $RSMGR_TSessionOrientation_EnumValues[$arrayCounter++] = "so_story_telling";
 135         $RSMGR_TSessionOrientation_EnumValues[$arrayCounter++] = "so_mistery";
 136         $RSMGR_TSessionOrientation_EnumValues[$arrayCounter++] = "so_hack_slash";
 137         $RSMGR_TSessionOrientation_EnumValues[$arrayCounter++] = "so_guild_training";
 138         $RSMGR_TSessionOrientation_EnumValues[$arrayCounter++] = "so_other";
 139         $RSMGR_TSessionOrientation_EnumValues[$arrayCounter] = "invalid";
 140         $RSMGR_TSessionOrientation_InvalidValue = $arrayCounter;
 141
 142         class RSMGR_TSessionOrientation
 143         {
 144                 var $Value;
 145
 146                 function __construct()
 147                 {
 148                         global $RSMGR_TSessionOrientation_InvalidValue;
 149                         $this->Value = $RSMGR_TSessionOrientation_InvalidValue;
 150                 }
 151
 152                 function toString()
 153                 {
 154                         global $RSMGR_TSessionOrientation_EnumValues;
 155                         return $RSMGR_TSessionOrientation_EnumValues[$this->Value];
 156                 }
 157
 158                 function fromString($strValue)
 159                 {
 160                         global $RSMGR_TSessionOrientation_EnumValues;
 161                         foreach ($RSMGR_TSessionOrientation_EnumValues as $k => $v)
 162                         {
 163                                 if ($strValue === $v)
 164                                 {
 165                                         $this->Value = $k;
 166                                         return;
 167                                 }
 168                         }
 169
 170                         $this->Value = $RSMGR_TSessionOrientation_InvalidValue;
 171                 }
 172
 173                 function toInt()
 174                 {
 175                         return $this->Value;
 176                 }
 177
 178                 function fromInt($intValue)
 179                 {
 180                         global $RSMGR_TSessionOrientation_InvalidValue;
 181                         global $RSMGR_TSessionOrientation_EnumValues;
 182                         if (array_key_exists($intValue, $RSMGR_TSessionOrientation_EnumValues))
 183                                 $this->Value = $intValue;
 184                         else
 185                                 $this->Value = $RSMGR_TSessionOrientation_InvalidValue;
 186                 }
 187         }
 188 ?>
 189 <?php
 190         /////////////////////////////////////////////////////////////////
 191         // WARNING : this is a generated file, don't change it !
 192         /////////////////////////////////////////////////////////////////
 193
 194         $arrayCounter = 0;
 195         $RSMGR_TSessionState_EnumValues[$arrayCounter++] = "ss_planned";
 196         $RSMGR_TSessionState_EnumValues[$arrayCounter++] = "ss_open";
 197         $RSMGR_TSessionState_EnumValues[$arrayCounter++] = "ss_locked";
 198         $RSMGR_TSessionState_EnumValues[$arrayCounter++] = "ss_closed";
 199         $RSMGR_TSessionState_EnumValues[$arrayCounter] = "invalid";
 200         $RSMGR_TSessionState_InvalidValue = $arrayCounter;
 201
 202         class RSMGR_TSessionState
 203         {
 204                 var $Value;
 205
 206                 function __construct()
 207                 {
 208                         global $RSMGR_TSessionState_InvalidValue;
 209                         $this->Value = $RSMGR_TSessionState_InvalidValue;
 210                 }
 211
 212                 function toString()
 213                 {
 214                         global $RSMGR_TSessionState_EnumValues;
 215                         return $RSMGR_TSessionState_EnumValues[$this->Value];
 216                 }
 217
 218                 function fromString($strValue)
 219                 {
 220                         global $RSMGR_TSessionState_EnumValues;
 221                         foreach ($RSMGR_TSessionState_EnumValues as $k => $v)
 222                         {
 223                                 if ($strValue === $v)
 224                                 {
 225                                         $this->Value = $k;
 226                                         return;
 227                                 }
 228                         }
 229
 230                         $this->Value = $RSMGR_TSessionState_InvalidValue;
 231                 }
 232
 233                 function toInt()
 234                 {
 235                         return $this->Value;
 236                 }
 237
 238                 function fromInt($intValue)
 239                 {
 240                         global $RSMGR_TSessionState_InvalidValue;
 241                         global $RSMGR_TSessionState_EnumValues;
 242                         if (array_key_exists($intValue, $RSMGR_TSessionState_EnumValues))
 243                                 $this->Value = $intValue;
 244                         else
 245                                 $this->Value = $RSMGR_TSessionState_InvalidValue;
 246                 }
 247         }
 248 ?>
 249 <?php
 250         /////////////////////////////////////////////////////////////////
 251         // WARNING : this is a generated file, don't change it !
 252         /////////////////////////////////////////////////////////////////
 253
 254         $arrayCounter = 0;
 255         $RSMGR_TAnimMode_EnumValues[$arrayCounter++] = "am_dm";
 256         $RSMGR_TAnimMode_EnumValues[$arrayCounter++] = "am_autonomous";
 257         $RSMGR_TAnimMode_EnumValues[$arrayCounter] = "invalid";
 258         $RSMGR_TAnimMode_InvalidValue = $arrayCounter;
 259
 260         class RSMGR_TAnimMode
 261         {
 262                 var $Value;
 263
 264                 function __construct()
 265                 {
 266                         global $RSMGR_TAnimMode_InvalidValue;
 267                         $this->Value = $RSMGR_TAnimMode_InvalidValue;
 268                 }
 269
 270                 function toString()
 271                 {
 272                         global $RSMGR_TAnimMode_EnumValues;
 273                         return $RSMGR_TAnimMode_EnumValues[$this->Value];
 274                 }
 275
 276                 function fromString($strValue)
 277                 {
 278                         global $RSMGR_TAnimMode_EnumValues;
 279                         foreach ($RSMGR_TAnimMode_EnumValues as $k => $v)
 280                         {
 281                                 if ($strValue === $v)
 282                                 {
 283                                         $this->Value = $k;
 284                                         return;
 285                                 }
 286                         }
 287
 288                         $this->Value = $RSMGR_TAnimMode_InvalidValue;
 289                 }
 290
 291                 function toInt()
 292                 {
 293                         return $this->Value;
 294                 }
 295
 296                 function fromInt($intValue)
 297                 {
 298                         global $RSMGR_TAnimMode_InvalidValue;
 299                         global $RSMGR_TAnimMode_EnumValues;
 300                         if (array_key_exists($intValue, $RSMGR_TAnimMode_EnumValues))
 301                                 $this->Value = $intValue;
 302                         else
 303                                 $this->Value = $RSMGR_TAnimMode_InvalidValue;
 304                 }
 305         }
 306 ?>
 307 <?php
 308         /////////////////////////////////////////////////////////////////
 309         // WARNING : this is a generated file, don't change it !
 310         /////////////////////////////////////////////////////////////////
 311
 312         $arrayCounter = 0;
 313         $RSMGR_TAccessType_EnumValues[$arrayCounter++] = "at_public";
 314         $RSMGR_TAccessType_EnumValues[$arrayCounter++] = "at_private";
 315         $RSMGR_TAccessType_EnumValues[$arrayCounter] = "invalid";
 316         $RSMGR_TAccessType_InvalidValue = $arrayCounter;
 317
 318         class RSMGR_TAccessType
 319         {
 320                 var $Value;
 321
 322                 function __construct()
 323                 {
 324                         global $RSMGR_TAccessType_InvalidValue;
 325                         $this->Value = $RSMGR_TAccessType_InvalidValue;
 326                 }
 327
 328                 function toString()
 329                 {
 330                         global $RSMGR_TAccessType_EnumValues;
 331                         return $RSMGR_TAccessType_EnumValues[$this->Value];
 332                 }
 333
 334                 function fromString($strValue)
 335                 {
 336                         global $RSMGR_TAccessType_EnumValues;
 337                         foreach ($RSMGR_TAccessType_EnumValues as $k => $v)
 338                         {
 339                                 if ($strValue === $v)
 340                                 {
 341                                         $this->Value = $k;
 342                                         return;
 343                                 }
 344                         }
 345
 346                         $this->Value = $RSMGR_TAccessType_InvalidValue;
 347                 }
 348
 349                 function toInt()
 350                 {
 351                         return $this->Value;
 352                 }
 353
 354                 function fromInt($intValue)
 355                 {
 356                         global $RSMGR_TAccessType_InvalidValue;
 357                         global $RSMGR_TAccessType_EnumValues;
 358                         if (array_key_exists($intValue, $RSMGR_TAccessType_EnumValues))
 359                                 $this->Value = $intValue;
 360                         else
 361                                 $this->Value = $RSMGR_TAccessType_InvalidValue;
 362                 }
 363         }
 364 ?>
 365 <?php
 366         /////////////////////////////////////////////////////////////////
 367         // WARNING : this is a generated file, don't change it !
 368         /////////////////////////////////////////////////////////////////
 369
 370         $arrayCounter = 0;
 371         $RSMGR_TRuleType_EnumValues[$arrayCounter++] = "rt_strict";
 372         $RSMGR_TRuleType_EnumValues[$arrayCounter++] = "rt_liberal";
 373         $RSMGR_TRuleType_EnumValues[$arrayCounter] = "invalid";
 374         $RSMGR_TRuleType_InvalidValue = $arrayCounter;
 375
 376         class RSMGR_TRuleType
 377         {
 378                 var $Value;
 379
 380                 function __construct()
 381                 {
 382                         global $RSMGR_TRuleType_InvalidValue;
 383                         $this->Value = $RSMGR_TRuleType_InvalidValue;
 384                 }
 385
 386                 function toString()
 387                 {
 388                         global $RSMGR_TRuleType_EnumValues;
 389                         return $RSMGR_TRuleType_EnumValues[$this->Value];
 390                 }
 391
 392                 function fromString($strValue)
 393                 {
 394                         global $RSMGR_TRuleType_EnumValues;
 395                         foreach ($RSMGR_TRuleType_EnumValues as $k => $v)
 396                         {
 397                                 if ($strValue === $v)
 398                                 {
 399                                         $this->Value = $k;
 400                                         return;
 401                                 }
 402                         }
 403
 404                         $this->Value = $RSMGR_TRuleType_InvalidValue;
 405                 }
 406
 407                 function toInt()
 408                 {
 409                         return $this->Value;
 410                 }
 411
 412                 function fromInt($intValue)
 413                 {
 414                         global $RSMGR_TRuleType_InvalidValue;
 415                         global $RSMGR_TRuleType_EnumValues;
 416                         if (array_key_exists($intValue, $RSMGR_TRuleType_EnumValues))
 417                                 $this->Value = $intValue;
 418                         else
 419                                 $this->Value = $RSMGR_TRuleType_InvalidValue;
 420                 }
 421         }
 422 ?>
 423 <?php
 424         /////////////////////////////////////////////////////////////////
 425         // WARNING : this is a generated file, don't change it !
 426         /////////////////////////////////////////////////////////////////
 427
 428         $arrayCounter = 0;
 429         $RSMGR_TLevelFilter_EnumValues[$arrayCounter++] = "lf_a";
 430         $RSMGR_TLevelFilter_EnumValues[$arrayCounter++] = "lf_b";
 431         $RSMGR_TLevelFilter_EnumValues[$arrayCounter++] = "lf_c";
 432         $RSMGR_TLevelFilter_EnumValues[$arrayCounter++] = "lf_d";
 433         $RSMGR_TLevelFilter_EnumValues[$arrayCounter++] = "lf_e";
 434         $RSMGR_TLevelFilter_EnumValues[$arrayCounter++] = "lf_f";
 435         $RSMGR_TLevelFilter_EnumValues[$arrayCounter] = "invalid";
 436         $RSMGR_TLevelFilter_InvalidValue = $arrayCounter;
 437
 438         class RSMGR_TLevelFilter
 439         {
 440                 var $Value;
 441
 442                 function __construct()
 443                 {
 444                         global $RSMGR_TLevelFilter_InvalidValue;
 445                         $this->Value = $RSMGR_TLevelFilter_InvalidValue;
 446                 }
 447
 448                 function toString()
 449                 {
 450                         global $RSMGR_TLevelFilter_EnumValues;
 451                         return $RSMGR_TLevelFilter_EnumValues[$this->Value];
 452                 }
 453
 454                 function fromString($strValue)
 455                 {
 456                         global $RSMGR_TLevelFilter_EnumValues;
 457                         foreach ($RSMGR_TLevelFilter_EnumValues as $k => $v)
 458                         {
 459                                 if ($strValue === $v)
 460                                 {
 461                                         $this->Value = $k;
 462                                         return;
 463                                 }
 464                         }
 465
 466                         $this->Value = $RSMGR_TLevelFilter_InvalidValue;
 467                 }
 468
 469                 function toInt()
 470                 {
 471                         return $this->Value;
 472                 }
 473
 474                 function fromInt($intValue)
 475                 {
 476                         global $RSMGR_TLevelFilter_InvalidValue;
 477                         global $RSMGR_TLevelFilter_EnumValues;
 478                         if (array_key_exists($intValue, $RSMGR_TLevelFilter_EnumValues))
 479                                 $this->Value = $intValue;
 480                         else
 481                                 $this->Value = $RSMGR_TLevelFilter_InvalidValue;
 482                 }
 483         }
 484 ?>
 485 <?php
 486         /////////////////////////////////////////////////////////////////
 487         // WARNING : this is a generated file, don't change it !
 488         /////////////////////////////////////////////////////////////////
 489
 490         $arrayCounter = 0;
 491         $RSMGR_TEstimatedDuration_EnumValues[$arrayCounter++] = "et_short";
 492         $RSMGR_TEstimatedDuration_EnumValues[$arrayCounter++] = "et_medium";
 493         $RSMGR_TEstimatedDuration_EnumValues[$arrayCounter++] = "et_long";
 494         $RSMGR_TEstimatedDuration_EnumValues[$arrayCounter] = "invalid";
 495         $RSMGR_TEstimatedDuration_InvalidValue = $arrayCounter;
 496
 497         class RSMGR_TEstimatedDuration
 498         {
 499                 var $Value;
 500
 501                 function __construct()
 502                 {
 503                         global $RSMGR_TEstimatedDuration_InvalidValue;
 504                         $this->Value = $RSMGR_TEstimatedDuration_InvalidValue;
 505                 }
 506
 507                 function toString()
 508                 {
 509                         global $RSMGR_TEstimatedDuration_EnumValues;
 510                         return $RSMGR_TEstimatedDuration_EnumValues[$this->Value];
 511                 }
 512
 513                 function fromString($strValue)
 514                 {
 515                         global $RSMGR_TEstimatedDuration_EnumValues;
 516                         foreach ($RSMGR_TEstimatedDuration_EnumValues as $k => $v)
 517                         {
 518                                 if ($strValue === $v)
 519                                 {
 520                                         $this->Value = $k;
 521                                         return;
 522                                 }
 523                         }
 524
 525                         $this->Value = $RSMGR_TEstimatedDuration_InvalidValue;
 526                 }
 527
 528                 function toInt()
 529                 {
 530                         return $this->Value;
 531                 }
 532
 533                 function fromInt($intValue)
 534                 {
 535                         global $RSMGR_TEstimatedDuration_InvalidValue;
 536                         global $RSMGR_TEstimatedDuration_EnumValues;
 537                         if (array_key_exists($intValue, $RSMGR_TEstimatedDuration_EnumValues))
 538                                 $this->Value = $intValue;
 539                         else
 540                                 $this->Value = $RSMGR_TEstimatedDuration_InvalidValue;
 541                 }
 542         }
 543 ?>
 544 <?php
 545         /////////////////////////////////////////////////////////////////
 546         // WARNING : this is a generated file, don't change it !
 547         /////////////////////////////////////////////////////////////////
 548
 549         $arrayCounter = 0;
 550         $RSMGR_TRaceFilter_EnumValues[$arrayCounter++] = "rf_fyros";
 551         $RSMGR_TRaceFilter_EnumValues[$arrayCounter++] = "rf_matis";
 552         $RSMGR_TRaceFilter_EnumValues[$arrayCounter++] = "rf_tryker";
 553         $RSMGR_TRaceFilter_EnumValues[$arrayCounter++] = "rf_zorai";
 554         $RSMGR_TRaceFilter_EnumValues[$arrayCounter] = "invalid";
 555         $RSMGR_TRaceFilter_InvalidValue = $arrayCounter;
 556
 557         class RSMGR_TRaceFilter
 558         {
 559                 var $Value;
 560
 561                 function __construct()
 562                 {
 563                         global $RSMGR_TRaceFilter_InvalidValue;
 564                         $this->Value = $RSMGR_TRaceFilter_InvalidValue;
 565                 }
 566
 567                 function toString()
 568                 {
 569                         global $RSMGR_TRaceFilter_EnumValues;
 570                         return $RSMGR_TRaceFilter_EnumValues[$this->Value];
 571                 }
 572
 573                 function fromString($strValue)
 574                 {
 575                         global $RSMGR_TRaceFilter_EnumValues;
 576                         foreach ($RSMGR_TRaceFilter_EnumValues as $k => $v)
 577                         {
 578                                 if ($strValue === $v)
 579                                 {
 580                                         $this->Value = $k;
 581                                         return;
 582                                 }
 583                         }
 584
 585                         $this->Value = $RSMGR_TRaceFilter_InvalidValue;
 586                 }
 587
 588                 function toInt()
 589                 {
 590                         return $this->Value;
 591                 }
 592
 593                 function fromInt($intValue)
 594                 {
 595                         global $RSMGR_TRaceFilter_InvalidValue;
 596                         global $RSMGR_TRaceFilter_EnumValues;
 597                         if (array_key_exists($intValue, $RSMGR_TRaceFilter_EnumValues))
 598                                 $this->Value = $intValue;
 599                         else
 600                                 $this->Value = $RSMGR_TRaceFilter_InvalidValue;
 601                 }
 602         }
 603 ?>
 604 <?php
 605         /////////////////////////////////////////////////////////////////
 606         // WARNING : this is a generated file, don't change it !
 607         /////////////////////////////////////////////////////////////////
 608
 609         $arrayCounter = 0;
 610         $RSMGR_TReligionFilter_EnumValues[$arrayCounter++] = "rf_kami";
 611         $RSMGR_TReligionFilter_EnumValues[$arrayCounter++] = "rf_karavan";
 612         $RSMGR_TReligionFilter_EnumValues[$arrayCounter++] = "rf_neutral";
 613         $RSMGR_TReligionFilter_EnumValues[$arrayCounter] = "invalid";
 614         $RSMGR_TReligionFilter_InvalidValue = $arrayCounter;
 615
 616         class RSMGR_TReligionFilter
 617         {
 618                 var $Value;
 619
 620                 function __construct()
 621                 {
 622                         global $RSMGR_TReligionFilter_InvalidValue;
 623                         $this->Value = $RSMGR_TReligionFilter_InvalidValue;
 624                 }
 625
 626                 function toString()
 627                 {
 628                         global $RSMGR_TReligionFilter_EnumValues;
 629                         return $RSMGR_TReligionFilter_EnumValues[$this->Value];
 630                 }
 631
 632                 function fromString($strValue)
 633                 {
 634                         global $RSMGR_TReligionFilter_EnumValues;
 635                         foreach ($RSMGR_TReligionFilter_EnumValues as $k => $v)
 636                         {
 637                                 if ($strValue === $v)
 638                                 {
 639                                         $this->Value = $k;
 640                                         return;
 641                                 }
 642                         }
 643
 644                         $this->Value = $RSMGR_TReligionFilter_InvalidValue;
 645                 }
 646
 647                 function toInt()
 648                 {
 649                         return $this->Value;
 650                 }
 651
 652                 function fromInt($intValue)
 653                 {
 654                         global $RSMGR_TReligionFilter_InvalidValue;
 655                         global $RSMGR_TReligionFilter_EnumValues;
 656                         if (array_key_exists($intValue, $RSMGR_TReligionFilter_EnumValues))
 657                                 $this->Value = $intValue;
 658                         else
 659                                 $this->Value = $RSMGR_TReligionFilter_InvalidValue;
 660                 }
 661         }
 662 ?>
 663 <?php
 664         /////////////////////////////////////////////////////////////////
 665         // WARNING : this is a generated file, don't change it !
 666         /////////////////////////////////////////////////////////////////
 667
 668         $arrayCounter = 0;
 669         $RSMGR_TGuildFilter_EnumValues[$arrayCounter++] = "gf_only_my_guild";
 670         $RSMGR_TGuildFilter_EnumValues[$arrayCounter++] = "gf_any_player";
 671         $RSMGR_TGuildFilter_EnumValues[$arrayCounter] = "invalid";
 672         $RSMGR_TGuildFilter_InvalidValue = $arrayCounter;
 673
 674         class RSMGR_TGuildFilter
 675         {
 676                 var $Value;
 677
 678                 function __construct()
 679                 {
 680                         global $RSMGR_TGuildFilter_InvalidValue;
 681                         $this->Value = $RSMGR_TGuildFilter_InvalidValue;
 682                 }
 683
 684                 function toString()
 685                 {
 686                         global $RSMGR_TGuildFilter_EnumValues;
 687                         return $RSMGR_TGuildFilter_EnumValues[$this->Value];
 688                 }
 689
 690                 function fromString($strValue)
 691                 {
 692                         global $RSMGR_TGuildFilter_EnumValues;
 693                         foreach ($RSMGR_TGuildFilter_EnumValues as $k => $v)
 694                         {
 695                                 if ($strValue === $v)
 696                                 {
 697                                         $this->Value = $k;
 698                                         return;
 699                                 }
 700                         }
 701
 702                         $this->Value = $RSMGR_TGuildFilter_InvalidValue;
 703                 }
 704
 705                 function toInt()
 706                 {
 707                         return $this->Value;
 708                 }
 709
 710                 function fromInt($intValue)
 711                 {
 712                         global $RSMGR_TGuildFilter_InvalidValue;
 713                         global $RSMGR_TGuildFilter_EnumValues;
 714                         if (array_key_exists($intValue, $RSMGR_TGuildFilter_EnumValues))
 715                                 $this->Value = $intValue;
 716                         else
 717                                 $this->Value = $RSMGR_TGuildFilter_InvalidValue;
 718                 }
 719         }
 720 ?>
 721 <?php
 722         /////////////////////////////////////////////////////////////////
 723         // WARNING : this is a generated file, don't change it !
 724         /////////////////////////////////////////////////////////////////
 725
 726         $arrayCounter = 0;
 727         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard00";
 728         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard01";
 729         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard02";
 730         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard03";
 731         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard04";
 732         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard05";
 733         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard06";
 734         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard07";
 735         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard08";
 736         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard09";
 737         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard10";
 738         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard11";
 739         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard12";
 740         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard13";
 741         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard14";
 742         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard15";
 743         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard16";
 744         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard17";
 745         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard18";
 746         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard19";
 747         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard20";
 748         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard21";
 749         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard22";
 750         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard23";
 751         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard24";
 752         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard25";
 753         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard26";
 754         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard27";
 755         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard28";
 756         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard29";
 757         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard30";
 758         $RSMGR_TShardFilter_EnumValues[$arrayCounter++] = "sf_shard31";
 759         $RSMGR_TShardFilter_EnumValues[$arrayCounter] = "invalid";
 760         $RSMGR_TShardFilter_InvalidValue = $arrayCounter;
 761
 762         class RSMGR_TShardFilter
 763         {
 764                 var $Value;
 765
 766                 function __construct()
 767                 {
 768                         global $RSMGR_TShardFilter_InvalidValue;
 769                         $this->Value = $RSMGR_TShardFilter_InvalidValue;
 770                 }
 771
 772                 function toString()
 773                 {
 774                         global $RSMGR_TShardFilter_EnumValues;
 775                         return $RSMGR_TShardFilter_EnumValues[$this->Value];
 776                 }
 777
 778                 function fromString($strValue)
 779                 {
 780                         global $RSMGR_TShardFilter_EnumValues;
 781                         foreach ($RSMGR_TShardFilter_EnumValues as $k => $v)
 782                         {
 783                                 if ($strValue === $v)
 784                                 {
 785                                         $this->Value = $k;
 786                                         return;
 787                                 }
 788                         }
 789
 790                         $this->Value = $RSMGR_TShardFilter_InvalidValue;
 791                 }
 792
 793                 function toInt()
 794                 {
 795                         return $this->Value;
 796                 }
 797
 798                 function fromInt($intValue)
 799                 {
 800                         global $RSMGR_TShardFilter_InvalidValue;
 801                         global $RSMGR_TShardFilter_EnumValues;
 802                         if (array_key_exists($intValue, $RSMGR_TShardFilter_EnumValues))
 803                                 $this->Value = $intValue;
 804                         else
 805                                 $this->Value = $RSMGR_TShardFilter_InvalidValue;
 806                 }
 807         }
 808 ?>
 809 <?php
 810         /////////////////////////////////////////////////////////////////
 811         // WARNING : this is a generated file, don't change it !
 812         /////////////////////////////////////////////////////////////////
 813
 814         $arrayCounter = 0;
 815         $RSMGR_TSessionEvent_EnumValues[$arrayCounter++] = "se_char_enter";
 816         $RSMGR_TSessionEvent_EnumValues[$arrayCounter++] = "se_char_leave";
 817         $RSMGR_TSessionEvent_EnumValues[$arrayCounter++] = "se_session_closing";
 818         $RSMGR_TSessionEvent_EnumValues[$arrayCounter] = "invalid";
 819         $RSMGR_TSessionEvent_InvalidValue = $arrayCounter;
 820
 821         class RSMGR_TSessionEvent
 822         {
 823                 var $Value;
 824
 825                 function __construct()
 826                 {
 827                         global $RSMGR_TSessionEvent_InvalidValue;
 828                         $this->Value = $RSMGR_TSessionEvent_InvalidValue;
 829                 }
 830
 831                 function toString()
 832                 {
 833                         global $RSMGR_TSessionEvent_EnumValues;
 834                         return $RSMGR_TSessionEvent_EnumValues[$this->Value];
 835                 }
 836
 837                 function fromString($strValue)
 838                 {
 839                         global $RSMGR_TSessionEvent_EnumValues;
 840                         foreach ($RSMGR_TSessionEvent_EnumValues as $k => $v)
 841                         {
 842                                 if ($strValue === $v)
 843                                 {
 844                                         $this->Value = $k;
 845                                         return;
 846                                 }
 847                         }
 848
 849                         $this->Value = $RSMGR_TSessionEvent_InvalidValue;
 850                 }
 851
 852                 function toInt()
 853                 {
 854                         return $this->Value;
 855                 }
 856
 857                 function fromInt($intValue)
 858                 {
 859                         global $RSMGR_TSessionEvent_InvalidValue;
 860                         global $RSMGR_TSessionEvent_EnumValues;
 861                         if (array_key_exists($intValue, $RSMGR_TSessionEvent_EnumValues))
 862                                 $this->Value = $intValue;
 863                         else
 864                                 $this->Value = $RSMGR_TSessionEvent_InvalidValue;
 865                 }
 866         }
 867 ?>
 868 <?php
 869         /////////////////////////////////////////////////////////////////
 870         // WARNING : this is a generated file, don't change it !
 871         /////////////////////////////////////////////////////////////////
 872
 873         require_once('../tools/nel_message.php');
 874
 875         class CRingSessionManagerWeb extends CCallbackClient
 876         {
 877
 878                 function scheduleSession($charId, $sessionType, $sessionTitle, $sessionDesc, $sessionLevel, $ruleType, $estimatedDuration, $subscriptionSlot, $animMode, $raceFilter, $religionFilter, $guildFilter, $shardFilter, $levelFilter, $language, $orientation, $subscriptionClosed, $autoInvite)
 879                 {
 880                         $msg = new CMessage;
 881                         $msg->setName("SSS");
 882
 883
 884                         $msg->serialUint32($charId);
 885                                 $msg->serialEnum($sessionType);
 886                                 $msg->serialString($sessionTitle);
 887                                 $msg->serialString($sessionDesc);
 888                                 $msg->serialEnum($sessionLevel);
 889                                 $msg->serialEnum($ruleType);
 890                                 $msg->serialEnum($estimatedDuration);
 891                                 $msg->serialUint32($subscriptionSlot);
 892                                 $msg->serialEnum($animMode);
 893                                 $msg->serialEnum($raceFilter);
 894                                 $msg->serialEnum($religionFilter);
 895                                 $msg->serialEnum($guildFilter);
 896                                 $msg->serialEnum($shardFilter);
 897                                 $msg->serialEnum($levelFilter);
 898                                 $msg->serialString($language);
 899                                 $msg->serialEnum($orientation);
 900                                 $msg->serialUint32($subscriptionClosed);
 901                                 $msg->serialUint32($autoInvite);
 902
 903                         return parent::sendMessage($msg);
 904
 905
 906                 }
 907
 908                 function setSessionStartParams($charId, $sessionId, $initialIslandLocation, $initialEntryPointLocation, $initialSeason)
 909                 {
 910                         $msg = new CMessage;
 911                         $msg->setName("SSSP");
 912
 913
 914                         $msg->serialUint32($charId);
 915                                 $msg->serialUint32($sessionId);
 916                                 $msg->serialUint32($initialIslandLocation);
 917                                 $msg->serialUint32($initialEntryPointLocation);
 918                                 $msg->serialUint32($initialSeason);
 919
 920                         return parent::sendMessage($msg);
 921
 922
 923                 }
 924
 925                 function getSessionInfo($charId, $sessionId)
 926                 {
 927                         $msg = new CMessage;
 928                         $msg->setName("GSI");
 929
 930
 931                         $msg->serialUint32($charId);
 932                                 $msg->serialUint32($sessionId);
 933
 934                         return parent::sendMessage($msg);
 935
 936
 937                 }
 938
 939                 function updateSessionInfo($charId, $sessionId, $sessionTitle, $plannedDate, $sessionDesc, $sessionLevel, $estimatedDuration, $subscriptionSlot, $raceFilter, $religionFilter, $guildFilter, $shardFilter, $levelFilter, $subscriptionClosed, $autoInvite, $language, $orientation)
 940                 {
 941                         $msg = new CMessage;
 942                         $msg->setName("USS");
 943
 944
 945                         $msg->serialUint32($charId);
 946                                 $msg->serialUint32($sessionId);
 947                                 $msg->serialString($sessionTitle);
 948                                 $msg->serialUint32($plannedDate);
 949                                 $msg->serialString($sessionDesc);
 950                                 $msg->serialEnum($sessionLevel);
 951                                 $msg->serialEnum($estimatedDuration);
 952                                 $msg->serialUint32($subscriptionSlot);
 953                                 $msg->serialEnum($raceFilter);
 954                                 $msg->serialEnum($religionFilter);
 955                                 $msg->serialEnum($guildFilter);
 956                                 $msg->serialEnum($shardFilter);
 957                                 $msg->serialEnum($levelFilter);
 958                                 $msg->serialUint32($subscriptionClosed);
 959                                 $msg->serialUint32($autoInvite);
 960                                 $msg->serialString($language);
 961                                 $msg->serialEnum($orientation);
 962
 963                         return parent::sendMessage($msg);
 964
 965
 966                 }
 967
 968                 function cancelSession($charId, $sessionId)
 969                 {
 970                         $msg = new CMessage;
 971                         $msg->setName("CANSS");
 972
 973
 974                         $msg->serialUint32($charId);
 975                                 $msg->serialUint32($sessionId);
 976
 977                         return parent::sendMessage($msg);
 978
 979
 980                 }
 981
 982                 function startSession($charId, $sessionId)
 983                 {
 984                         $msg = new CMessage;
 985                         $msg->setName("STSS");
 986
 987
 988                         $msg->serialUint32($charId);
 989                                 $msg->serialUint32($sessionId);
 990
 991                         return parent::sendMessage($msg);
 992
 993
 994                 }
 995
 996                 function closeSession($charId, $sessionId)
 997                 {
 998                         $msg = new CMessage;
 999                         $msg->setName("CLSS");
1000
1001
1002                         $msg->serialUint32($charId);
1003                                 $msg->serialUint32($sessionId);
1004
1005                         return parent::sendMessage($msg);
1006
1007
1008                 }
1009
1010                 function closeEditSession($charId)
1011                 {
1012                         $msg = new CMessage;
1013                         $msg->setName("CLESS");
1014
1015
1016                         $msg->serialUint32($charId);
1017
1018                         return parent::sendMessage($msg);
1019
1020
1021                 }
1022
1023                 function addFriendCharacter($userId, $friendCharId)
1024                 {
1025                         $msg = new CMessage;
1026                         $msg->setName("AFC");
1027
1028
1029                         $msg->serialUint32($userId);
1030                                 $msg->serialUint32($friendCharId);
1031
1032                         return parent::sendMessage($msg);
1033
1034
1035                 }
1036
1037                 function removeFriendCharacter($userId, $friendCharId)
1038                 {
1039                         $msg = new CMessage;
1040                         $msg->setName("RFC");
1041
1042
1043                         $msg->serialUint32($userId);
1044                                 $msg->serialUint32($friendCharId);
1045
1046                         return parent::sendMessage($msg);
1047
1048
1049                 }
1050
1051                 function addBannedCharacter($userId, $bannedCharId)
1052                 {
1053                         $msg = new CMessage;
1054                         $msg->setName("ABC");
1055
1056
1057                         $msg->serialUint32($userId);
1058                                 $msg->serialUint32($bannedCharId);
1059
1060                         return parent::sendMessage($msg);
1061
1062
1063                 }
1064
1065                 function removeBannedCharacter($userId, $bannedCharId)
1066                 {
1067                         $msg = new CMessage;
1068                         $msg->setName("RBC");
1069
1070
1071                         $msg->serialUint32($userId);
1072                                 $msg->serialUint32($bannedCharId);
1073
1074                         return parent::sendMessage($msg);
1075
1076
1077                 }
1078
1079                 function addFriendDMCharacter($userId, $friendDMCharId)
1080                 {
1081                         $msg = new CMessage;
1082                         $msg->setName("AFDC");
1083
1084
1085                         $msg->serialUint32($userId);
1086                                 $msg->serialUint32($friendDMCharId);
1087
1088                         return parent::sendMessage($msg);
1089
1090
1091                 }
1092
1093                 function removeFriendDMCharacter($userId, $friendDMCharId)
1094                 {
1095                         $msg = new CMessage;
1096                         $msg->setName("RFDC");
1097
1098
1099                         $msg->serialUint32($userId);
1100                                 $msg->serialUint32($friendDMCharId);
1101
1102                         return parent::sendMessage($msg);
1103
1104
1105                 }
1106
1107                 function setKnownCharacterComments($userId, $charId, $relation, $comments)
1108                 {
1109                         $msg = new CMessage;
1110                         $msg->setName("SKCC");
1111
1112
1113                         $msg->serialUint32($userId);
1114                                 $msg->serialUint32($charId);
1115                                 $msg->serialString($relation);
1116                                 $msg->serialString($comments);
1117
1118                         return parent::sendMessage($msg);
1119
1120
1121                 }
1122
1123                 function inviteCharacter($ownerCharId, $sessionId, $invitedCharId, $charRole)
1124                 {
1125                         $msg = new CMessage;
1126                         $msg->setName("IC");
1127
1128
1129                         $msg->serialUint32($ownerCharId);
1130                                 $msg->serialUint32($sessionId);
1131                                 $msg->serialUint32($invitedCharId);
1132                                 $msg->serialEnum($charRole);
1133
1134                         return parent::sendMessage($msg);
1135
1136
1137                 }
1138
1139                 function removeInvitedCharacter($ownerCharId, $sessionId, $removedCharId)
1140                 {
1141                         $msg = new CMessage;
1142                         $msg->setName("RIC");
1143
1144
1145                         $msg->serialUint32($ownerCharId);
1146                                 $msg->serialUint32($sessionId);
1147                                 $msg->serialUint32($removedCharId);
1148
1149                         return parent::sendMessage($msg);
1150
1151
1152                 }
1153
1154                 function subscribeSession($charId, $sessionId)
1155                 {
1156                         $msg = new CMessage;
1157                         $msg->setName("SBS");
1158
1159
1160                         $msg->serialUint32($charId);
1161                                 $msg->serialUint32($sessionId);
1162
1163                         return parent::sendMessage($msg);
1164
1165
1166                 }
1167
1168                 function unsubscribeSession($charId, $sessionId)
1169                 {
1170                         $msg = new CMessage;
1171                         $msg->setName("USBS");
1172
1173
1174                         $msg->serialUint32($charId);
1175                                 $msg->serialUint32($sessionId);
1176
1177                         return parent::sendMessage($msg);
1178
1179
1180                 }
1181
1182                 function joinSession($charId, $sessionId, $clientApplication)
1183                 {
1184                         $msg = new CMessage;
1185                         $msg->setName("JSS");
1186
1187
1188                         $msg->serialUint32($charId);
1189                                 $msg->serialUint32($sessionId);
1190                                 $msg->serialString($clientApplication);
1191
1192                         return parent::sendMessage($msg);
1193
1194
1195                 }
1196
1197                 function joinMainland($charId, $clientApplication)
1198                 {
1199                         $msg = new CMessage;
1200                         $msg->setName("JML");
1201
1202
1203                         $msg->serialUint32($charId);
1204                                 $msg->serialString($clientApplication);
1205
1206                         return parent::sendMessage($msg);
1207
1208
1209                 }
1210
1211                 function joinEditSession($charId, $clientApplication)
1212                 {
1213                         $msg = new CMessage;
1214                         $msg->setName("JES");
1215
1216
1217                         $msg->serialUint32($charId);
1218                                 $msg->serialString($clientApplication);
1219
1220                         return parent::sendMessage($msg);
1221
1222
1223                 }
1224
1225                 function hibernateEditSession($charId)
1226                 {
1227                         $msg = new CMessage;
1228                         $msg->setName("HES");
1229
1230
1231                         $msg->serialUint32($charId);
1232
1233                         return parent::sendMessage($msg);
1234
1235
1236                 }
1237
1238                 function getShards($charId)
1239                 {
1240                         $msg = new CMessage;
1241                         $msg->setName("GSH");
1242
1243
1244                         $msg->serialUint32($charId);
1245
1246                         return parent::sendMessage($msg);
1247
1248
1249                 }
1250
1251                 function kickCharacter($ownerCharId, $sessionId, $kickedCharId)
1252                 {
1253                         $msg = new CMessage;
1254                         $msg->setName("KC");
1255
1256
1257                         $msg->serialUint32($ownerCharId);
1258                                 $msg->serialUint32($sessionId);
1259                                 $msg->serialUint32($kickedCharId);
1260
1261                         return parent::sendMessage($msg);
1262
1263
1264                 }
1265
1266                 function unkickCharacter($ownerCharId, $sessionId, $unkickedCharId)
1267                 {
1268                         $msg = new CMessage;
1269                         $msg->setName("UKC");
1270
1271
1272                         $msg->serialUint32($ownerCharId);
1273                                 $msg->serialUint32($sessionId);
1274                                 $msg->serialUint32($unkickedCharId);
1275
1276                         return parent::sendMessage($msg);
1277
1278
1279                 }
1280
1281                 function inviteGuild($charId, $sessionId, $guildId)
1282                 {
1283                         $msg = new CMessage;
1284                         $msg->setName("IG");
1285
1286
1287                         $msg->serialUint32($charId);
1288                                 $msg->serialUint32($sessionId);
1289                                 $msg->serialUint32($guildId);
1290
1291                         return parent::sendMessage($msg);
1292
1293
1294                 }
1295
1296                 function removeInvitedGuild($charId, $sessionId, $guildId)
1297                 {
1298                         $msg = new CMessage;
1299                         $msg->setName("RIG");
1300
1301
1302                         $msg->serialUint32($charId);
1303                                 $msg->serialUint32($sessionId);
1304                                 $msg->serialUint32($guildId);
1305
1306                         return parent::sendMessage($msg);
1307
1308
1309                 }
1310
1311                 function setScenarioInfo($charId, $sessionId, $title, $numPlayer, $playType)
1312                 {
1313                         $msg = new CMessage;
1314                         $msg->setName("SSCI");
1315
1316
1317                         $msg->serialUint32($charId);
1318                                 $msg->serialUint32($sessionId);
1319                                 $msg->serialString($title);
1320                                 $msg->serialUint32($numPlayer);
1321                                 $msg->serialString($playType);
1322
1323                         return parent::sendMessage($msg);
1324
1325
1326                 }
1327
1328                 function addJournalEntry($charId, $sessionId, $entryType, $text)
1329                 {
1330                         $msg = new CMessage;
1331                         $msg->setName("AJE");
1332
1333
1334                         $msg->serialUint32($charId);
1335                                 $msg->serialUint32($sessionId);
1336                                 $msg->serialString($entryType);
1337                                 $msg->serialString($text);
1338
1339                         return parent::sendMessage($msg);
1340
1341
1342                 }
1343
1344                 function setPlayerRating($charId, $sessionId, $rateFun, $rateDifficulty, $rateAccessibility, $rateOriginality, $rateDirection)
1345                 {
1346                         $msg = new CMessage;
1347                         $msg->setName("SPR");
1348
1349
1350                         $msg->serialUint32($charId);
1351                                 $msg->serialUint32($sessionId);
1352                                 $msg->serialUint32($rateFun);
1353                                 $msg->serialUint32($rateDifficulty);
1354                                 $msg->serialUint32($rateAccessibility);
1355                                 $msg->serialUint32($rateOriginality);
1356                                 $msg->serialUint32($rateDirection);
1357
1358                         return parent::sendMessage($msg);
1359
1360
1361                 }
1362
1363
1364                 function waitCallback()
1365                 {
1366                         $message = parent::waitMessage();
1367
1368                         if ($message == false)
1369                                 return false;
1370
1371                         switch($message->MsgName)
1372                         {
1373                         case "RET":
1374                                 $this->invokeResult_skel($message);
1375                                 break;
1376                         case "SSSR":
1377                                 $this->scheduleSessionResult_skel($message);
1378                                 break;
1379                         case "SIR":
1380                                 $this->sessionInfoResult_skel($message);
1381                                 break;
1382                         case "JSSR":
1383                                 $this->joinSessionResult_skel($message);
1384                                 break;
1385                         case "JSSRE":
1386                                 $this->joinSessionResultExt_skel($message);
1387                                 break;
1388                         case "GSHR":
1389                                 $this->getShardsResult_skel($message);
1390                                 break;
1391                         default:
1392                                 return false;
1393                         }
1394
1395                         return true;
1396                 }
1397
1398
1399                 function invokeResult_skel(&$message)
1400                 {
1401                         $message->serialUint32($userId);
1402                                 $message->serialUint32($resultCode);
1403                                 $message->serialString($resultString);
1404
1405                         $this->invokeResult($userId, $resultCode, $resultString);
1406                 }
1407
1408                 function scheduleSessionResult_skel(&$message)
1409                 {
1410                         $message->serialUint32($charId);
1411                                 $message->serialUint32($sessionId);
1412                                 $message->serialUInt8($result);
1413                                 $message->serialString($resultString);
1414
1415                         $this->scheduleSessionResult($charId, $sessionId, $result, $resultString);
1416                 }
1417
1418                 function sessionInfoResult_skel(&$message)
1419                 {
1420                         $message->serialUint32($charId);
1421                                 $message->serialUint32($sessionId);
1422
1423                         $raceFilter = new RSMGR_TRaceFilter;
1424         $message->serialEnum($raceFilter);
1425
1426                         $religionFilter = new RSMGR_TReligionFilter;
1427         $message->serialEnum($religionFilter);
1428
1429                         $guildFilter = new RSMGR_TGuildFilter;
1430         $message->serialEnum($guildFilter);
1431
1432                         $shardFilter = new RSMGR_TShardFilter;
1433         $message->serialEnum($shardFilter);
1434
1435                         $levelFilter = new RSMGR_TLevelFilter;
1436         $message->serialEnum($levelFilter);
1437                                 $message->serialUint32($subscriptionClosed);
1438                                 $message->serialUint32($autoInvite);
1439                                 $message->serialString($language);
1440
1441                         $orientation = new RSMGR_TSessionOrientation;
1442         $message->serialEnum($orientation);
1443                                 $message->serialString($description);
1444
1445                         $this->sessionInfoResult($charId, $sessionId, $raceFilter, $religionFilter, $guildFilter, $shardFilter, $levelFilter, $subscriptionClosed, $autoInvite, $language, $orientation, $description);
1446                 }
1447
1448                 function joinSessionResult_skel(&$message)
1449                 {
1450                         $message->serialUint32($userId);
1451                                 $message->serialUint32($sessionId);
1452                                 $message->serialUint32($result);
1453                                 $message->serialString($shardAddr);
1454
1455                         $participantStatus = new RSMGR_TSessionPartStatus;
1456         $message->serialEnum($participantStatus);
1457
1458                         $this->joinSessionResult($userId, $sessionId, $result, $shardAddr, $participantStatus);
1459                 }
1460
1461                 function joinSessionResultExt_skel(&$message)
1462                 {
1463                         $message->serialUint32($userId);
1464                                 $message->serialUint32($sessionId);
1465                                 $message->serialUint32($result);
1466                                 $message->serialString($shardAddr);
1467
1468                         $participantStatus = new RSMGR_TSessionPartStatus;
1469         $message->serialEnum($participantStatus);
1470                                 $message->serialUint32($securityCheckForFastDisconnection);
1471
1472                         $this->joinSessionResultExt($userId, $sessionId, $result, $shardAddr, $participantStatus, $securityCheckForFastDisconnection);
1473                 }
1474
1475                 function getShardsResult_skel(&$message)
1476                 {
1477                         $message->serialUint32($userId);
1478                                 $message->serialString($result);
1479
1480                         $this->getShardsResult($userId, $result);
1481                 }
1482
1483
1484                 /////////////////////////////////////////////////////////////////
1485                 // Copy paste this part of code in your derived class
1486                 //      and implement code to ract to incoming message
1487                 /////////////////////////////////////////////////////////////////
1488                 // Generic response to invoke.
1489                 // result contains 0 if no error, more than 0 in case of error
1490
1491                 function invokeResult($userId, $resultCode, $resultString)
1492                 {
1493                 }
1494
1495                 // result is : 0 : session have been created fine
1496                 //             1 : invalid session type
1497                 //             2 : invalid level
1498                 //             3 : unknown character
1499                 //             4 : not used
1500                 //             5 : invalid access type
1501                 //             6 : invalid rule type
1502                 //             7 : invalid duration
1503                 //             8 : invalid user
1504                 //             9 : free trial account can't create anim session
1505                 //             10 : user is ban from ring anim session
1506
1507                 function scheduleSessionResult($charId, $sessionId, $result, $resultString)
1508                 {
1509                 }
1510
1511                 // session info result (anim)
1512
1513                 function sessionInfoResult($charId, $sessionId, $raceFilter, $religionFilter, $guildFilter, $shardFilter, $levelFilter, $subscriptionClosed, $autoInvite, $language, $orientation, $description)
1514                 {
1515                 }
1516
1517                 // Return the result of the session joining attempt
1518                 // If join is ok, the shardAddr contain <ip:port> of the
1519                 // Front end that waits for the player to come in and the.
1520                 // participation mode for the character (editor, animator or player).
1521                 // If ok, the web must return a page with a lua script.
1522                 // that trigger the action handler 'on_connect_to_shard' :
1523                 // <lua>runAH(nul, "on_connect_to_shard", "cookie=cookieValue|fsAddr=shardAddr|mode=participantStatus");<lua>
1524                 // result : 0 : ok the client can join the session
1525                 //          1 : char not found
1526                 //          2 : session not found
1527                 //          3 : no session participant for this character (not used for a mainland shard)
1528                 //          4 : can't find session server (not used for a mainland shard)
1529                 //          5 : shard hosting session is not reachable
1530                 //          6 : nel user info not found
1531                 //          7 : ring user not found
1532                 //          8 : welcome service rejected connection request
1533                 //          9 : session service shutdown (not used for a mainland shard)
1534                 //         10 : no mainland shard found (joinMainland only)
1535                 //         11 : internal error
1536                 //         12 : failed to request for access permission
1537                 //         13 : can't find access permission for user and domain
1538                 //         14 : Welcome service is closed for you
1539                 //         15 : Session is not open
1540                 //         16 : User banned from ring
1541                 //         17 : Newcomer flag missmatch
1542                 //         18 : Can't find session log to validate session access
1543                 //         19 : Can't find scenario info to validate session access
1544                 //         20 : Scenario is not allowed to free trial players
1545
1546                 function joinSessionResult($userId, $sessionId, $result, $shardAddr, $participantStatus)
1547                 {
1548                 }
1549
1550                 // See joinSessionResult.
1551                 // Adds a security code.
1552
1553                 function joinSessionResultExt($userId, $sessionId, $result, $shardAddr, $participantStatus, $securityCheckForFastDisconnection)
1554                 {
1555                 }
1556
1557                 // Return the list of online shards on which the user is allowed to connect,
1558                 // and their current dynamic attributes. Other attributes (e.g. names)
1559                 // can be queried from the database. Offline shards are the ones in the database
1560                 // of the same domain but not listed in the result.
1561                 // Then the client will have to call joinShard to connect on an online shard.
1562
1563                 function getShardsResult($userId, $result)
1564                 {
1565                 }
1566
1567         }
1568 ?>
1569 <?php
1570         /////////////////////////////////////////////////////////////////
1571         // WARNING : this is a generated file, don't change it !
1572         /////////////////////////////////////////////////////////////////
1573
1574         require_once('../tools/nel_message.php');
1575
1576         class CSessionBrowserServerWeb extends CCallbackClient
1577         {
1578
1579                 function authenticate($userId, $cookie)
1580                 {
1581                         $msg = new CMessage;
1582                         $msg->setName("AUTH");
1583
1584
1585                         $msg->serialUint32($userId);
1586                                 $msg->serialUint32($cookie);
1587
1588                         return parent::sendMessage($msg);
1589
1590
1591                 }
1592
1593                 function getSessionList($charId)
1594                 {
1595                         $msg = new CMessage;
1596                         $msg->setName("GSL");
1597
1598
1599                         $msg->serialUint32($charId);
1600
1601                         return parent::sendMessage($msg);
1602
1603
1604                 }
1605
1606                 function getCharList($charId, $sessionId)
1607                 {
1608                         $msg = new CMessage;
1609                         $msg->setName("GCL");
1610
1611
1612                         $msg->serialUint32($charId);
1613                                 $msg->serialUint32($sessionId);
1614
1615                         return parent::sendMessage($msg);
1616
1617
1618                 }
1619
1620                 function inviteCharacterByName($charId, $invitedCharName)
1621                 {
1622                         $msg = new CMessage;
1623                         $msg->setName("ICBN");
1624
1625
1626                         $msg->serialUint32($charId);
1627                                 $msg->serialUint32($invitedCharName);
1628
1629                         return parent::sendMessage($msg);
1630
1631
1632                 }
1633
1634                 function getMyRatings($charId, $sessionId)
1635                 {
1636                         $msg = new CMessage;
1637                         $msg->setName("GMSR");
1638
1639
1640                         $msg->serialUint32($charId);
1641                                 $msg->serialUint32($sessionId);
1642
1643                         return parent::sendMessage($msg);
1644
1645
1646                 }
1647
1648                 function getSessionAverageScores($sessionId)
1649                 {
1650                         $msg = new CMessage;
1651                         $msg->setName("GSAS");
1652
1653
1654                         $msg->serialUint32($sessionId);
1655
1656                         return parent::sendMessage($msg);
1657
1658
1659                 }
1660
1661                 function getScenarioAverageScores($md5)
1662                 {
1663                         $msg = new CMessage;
1664                         $msg->setName("GSCAS");
1665
1666
1667                         $msg->serialUint32($md5);
1668
1669                         return parent::sendMessage($msg);
1670
1671
1672                 }
1673
1674                 function getRingRatings($charId)
1675                 {
1676                         $msg = new CMessage;
1677                         $msg->setName("GRR");
1678
1679
1680                         $msg->serialUint32($charId);
1681
1682                         return parent::sendMessage($msg);
1683
1684
1685                 }
1686
1687                 function getRingPoints($charId)
1688                 {
1689                         $msg = new CMessage;
1690                         $msg->setName("GRP");
1691
1692
1693                         $msg->serialUint32($charId);
1694
1695                         return parent::sendMessage($msg);
1696
1697
1698                 }
1699
1700                 function forwardToDss($charId, $msg)
1701                 {
1702                         $msg = new CMessage;
1703                         $msg->setName("DSS_FW");
1704
1705
1706                         $msg->serialUint32($charId);
1707                                 $msg->serialUint32($msg);
1708
1709                         return parent::sendMessage($msg);
1710
1711
1712                 }
1713
1714
1715                 function waitCallback()
1716                 {
1717                         $message = parent::waitMessage();
1718
1719                         if ($message == false)
1720                                 return false;
1721
1722                         switch($message->MsgName)
1723                         {
1724                         case "SL":
1725                                 $this->sessionList_skel($message);
1726                                 break;
1727                         case "CL":
1728                                 $this->charList_skel($message);
1729                                 break;
1730                         case "PR":
1731                                 $this->playerRatings_skel($message);
1732                                 break;
1733                         case "SAS":
1734                                 $this->sessionAverageScores_skel($message);
1735                                 break;
1736                         case "SCAS":
1737                                 $this->scenarioAverageScores_skel($message);
1738                                 break;
1739                         case "RR":
1740                                 $this->ringRatings_skel($message);
1741                                 break;
1742                         case "RP":
1743                                 $this->ringPoints_skel($message);
1744                                 break;
1745                         default:
1746                                 return false;
1747                         }
1748
1749                         return true;
1750                 }
1751
1752
1753                 function sessionList_skel(&$message)
1754                 {
1755                         $message->serialUint32($charId);
1756                                 $message->serialUint32($sessions);
1757
1758                         $this->sessionList($charId, $sessions);
1759                 }
1760
1761                 function charList_skel(&$message)
1762                 {
1763                         $message->serialUint32($charId);
1764                                 $message->serialUint32($sessionId);
1765                                 $message->serialUint32($characters);
1766
1767                         $this->charList($charId, $sessionId, $characters);
1768                 }
1769
1770                 function playerRatings_skel(&$message)
1771                 {
1772                         $message->serialUint32($charId);
1773                                 $message->serialUint32($scenarioRated);
1774                                 $message->serialUint32($rateFun);
1775                                 $message->serialUint32($rateDifficulty);
1776                                 $message->serialUint32($rateAccessibility);
1777                                 $message->serialUint32($rateOriginality);
1778                                 $message->serialUint32($rateDirection);
1779
1780                         $this->playerRatings($charId, $scenarioRated, $rateFun, $rateDifficulty, $rateAccessibility, $rateOriginality, $rateDirection);
1781                 }
1782
1783                 function sessionAverageScores_skel(&$message)
1784                 {
1785                         $message->serialUint32($scenarioRated);
1786                                 $message->serialUint32($rateFun);
1787                                 $message->serialUint32($rateDifficulty);
1788                                 $message->serialUint32($rateAccessibility);
1789                                 $message->serialUint32($rateOriginality);
1790                                 $message->serialUint32($rateDirection);
1791                                 $message->serialUint32($rrpTotal);
1792
1793                         $this->sessionAverageScores($scenarioRated, $rateFun, $rateDifficulty, $rateAccessibility, $rateOriginality, $rateDirection, $rrpTotal);
1794                 }
1795
1796                 function scenarioAverageScores_skel(&$message)
1797                 {
1798                         $message->serialUint32($scenarioRated);
1799                                 $message->serialUint32($rateFun);
1800                                 $message->serialUint32($rateDifficulty);
1801                                 $message->serialUint32($rateAccessibility);
1802                                 $message->serialUint32($rateOriginality);
1803                                 $message->serialUint32($rateDirection);
1804                                 $message->serialUint32($rrpTotal);
1805
1806                         $this->scenarioAverageScores($scenarioRated, $rateFun, $rateDifficulty, $rateAccessibility, $rateOriginality, $rateDirection, $rrpTotal);
1807                 }
1808
1809                 function ringRatings_skel(&$message)
1810                 {
1811                         $message->serialUint32($charId);
1812                                 $message->serialUint32($authorRating);
1813                                 $message->serialUint32($AMRating);
1814                                 $message->serialUint32($masterlessRating);
1815
1816                         $this->ringRatings($charId, $authorRating, $AMRating, $masterlessRating);
1817                 }
1818
1819                 function ringPoints_skel(&$message)
1820                 {
1821                         $message->serialUint32($charId);
1822                                 $message->serialUint32($ringPoints);
1823                                 $message->serialUint32($maxRingPoints);
1824
1825                         $this->ringPoints($charId, $ringPoints, $maxRingPoints);
1826                 }
1827
1828
1829                 /////////////////////////////////////////////////////////////////
1830                 // Copy paste this part of code in your derived class
1831                 //      and implement code to ract to incoming message
1832                 /////////////////////////////////////////////////////////////////
1833                 // Return the list of available session
1834
1835                 function sessionList($charId, $sessions)
1836                 {
1837                 }
1838
1839                 // Return the list of player characters in the session
1840
1841                 function charList($charId, $sessionId, $characters)
1842                 {
1843                 }
1844
1845                 // Return current player rating of the current session scenario
1846
1847                 function playerRatings($charId, $scenarioRated, $rateFun, $rateDifficulty, $rateAccessibility, $rateOriginality, $rateDirection)
1848                 {
1849                 }
1850
1851                 // Return average scores of a session
1852
1853                 function sessionAverageScores($scenarioRated, $rateFun, $rateDifficulty, $rateAccessibility, $rateOriginality, $rateDirection, $rrpTotal)
1854                 {
1855                 }
1856
1857                 // Return average scores of a scenario
1858
1859                 function scenarioAverageScores($scenarioRated, $rateFun, $rateDifficulty, $rateAccessibility, $rateOriginality, $rateDirection, $rrpTotal)
1860                 {
1861                 }
1862
1863                 // Return the author rating, the AM rating and the Masterless rating
1864
1865                 function ringRatings($charId, $authorRating, $AMRating, $masterlessRating)
1866                 {
1867                 }
1868
1869                 // Return the ring points of the character
1870
1871                 function ringPoints($charId, $ringPoints, $maxRingPoints)
1872                 {
1873                 }
1874
1875         }
1876 ?>