1 {$INCLUDE "options.inc"}

     2 unit uCommandHandlers;

     3 

     4 interface

     5 

     6 procedure initModule;

     7 procedure freeModule;

     8 

     9 implementation

    10 uses uCommands, uTypes, uVariables, uIO, uDebug, uConsts, uScript, uUtils, SDLh, uRandom;

    11 

    12 procedure chGenCmd(var s: shortstring);

    13 begin

    14 case s[1] of

    15      'R': if ReadyTimeLeft > 1 then 

    16           begin

    17           ReadyTimeLeft:= 1;

    18           if not CurrentTeam^.ExtDriven then SendIPC('c'+s);

    19           end

    20     end

    21 end;

    22 

    23 procedure chQuit(var s: shortstring);

    24 const prevGState: TGameState = gsConfirm;

    25 begin

    26 s:= s; // avoid compiler hint

    27 if GameState <> gsConfirm then

    28         begin

    29         prevGState:= GameState;

    30         GameState:= gsConfirm

    31         end else

    32         GameState:= prevGState

    33 end;

    34 

    35 procedure chConfirm(var s: shortstring);

    36 begin

    37 s:= s; // avoid compiler hint

    38 if GameState = gsConfirm then

    39     begin

    40     SendIPC('Q');

    41     GameState:= gsExit

    42     end

    43 else

    44     ParseCommand('chat team', true);

    45 end;

    46 

    47 procedure chCheckProto(var s: shortstring);

    48 var i, c: LongInt;

    49 begin

    50 if isDeveloperMode then

    51 begin

    52 val(s, i, c);

    53 if (c <> 0) or (i = 0) then exit;

    54 TryDo(i <= cNetProtoVersion, 'Protocol version mismatch: engine is too old', true);

    55 TryDo(i >= cNetProtoVersion, 'Protocol version mismatch: engine is too new', true)

    56 end

    57 end;

    58 

    59 procedure chTeamLocal(var s: shortstring);

    60 begin

    61 s:= s; // avoid compiler hint

    62 if not isDeveloperMode then exit;

    63 if CurrentTeam = nil then OutError(errmsgIncorrectUse + ' "/rdriven"', true);

    64 CurrentTeam^.ExtDriven:= true

    65 end;

    66 

    67 procedure chGrave(var s: shortstring);

    68 begin

    69 if CurrentTeam = nil then OutError(errmsgIncorrectUse + ' "/grave"', true);

    70 if s[1]='"' then Delete(s, 1, 1);

    71 if s[byte(s[0])]='"' then Delete(s, byte(s[0]), 1);

    72 CurrentTeam^.GraveName:= s

    73 end;

    74 

    75 procedure chFort(var s: shortstring);

    76 begin

    77 if CurrentTeam = nil then OutError(errmsgIncorrectUse + ' "/fort"', true);

    78 if s[1]='"' then Delete(s, 1, 1);

    79 if s[byte(s[0])]='"' then Delete(s, byte(s[0]), 1);

    80 CurrentTeam^.FortName:= s

    81 end;

    82 

    83 procedure chFlag(var s: shortstring);

    84 begin

    85 if CurrentTeam = nil then OutError(errmsgIncorrectUse + ' "/flag"', true);

    86 if s[1]='"' then Delete(s, 1, 1);

    87 if s[byte(s[0])]='"' then Delete(s, byte(s[0]), 1);

    88 CurrentTeam^.flag:= s

    89 end;

    90 

    91 procedure chScript(var s: shortstring);

    92 begin

    93 if s[1]='"' then Delete(s, 1, 1);

    94 if s[byte(s[0])]='"' then Delete(s, byte(s[0]), 1);

    95 ScriptLoad(s)

    96 end;

    97 

    98 procedure chSetHat(var s: shortstring);

    99 begin

   100 if (not isDeveloperMode) or (CurrentTeam = nil) then exit;

   101 with CurrentTeam^ do

   102     begin

   103     if not CurrentHedgehog^.King then

   104     if (s = '') or

   105         (((GameFlags and gfKing) <> 0) and (s = 'crown')) or

   106         ((Length(s) > 39) and (Copy(s,1,8) = 'Reserved') and (Copy(s,9,32) <> PlayerHash)) then

   107         CurrentHedgehog^.Hat:= 'NoHat'

   108     else

   109         CurrentHedgehog^.Hat:= s

   110     end;

   111 end;

   112 

   113 procedure chCurU_p(var s: shortstring);

   114 begin

   115 s:= s; // avoid compiler hint

   116 CursorMovementY:= -1;

   117 end;

   118 

   119 procedure chCurU_m(var s: shortstring);

   120 begin

   121 s:= s; // avoid compiler hint

   122 CursorMovementY:= 0;

   123 end;

   124 

   125 procedure chCurD_p(var s: shortstring);

   126 begin

   127 s:= s; // avoid compiler hint

   128 CursorMovementY:= 1;

   129 end;

   130 

   131 procedure chCurD_m(var s: shortstring);

   132 begin

   133 s:= s; // avoid compiler hint

   134 CursorMovementY:= 0;

   135 end;

   136 

   137 procedure chCurL_p(var s: shortstring);

   138 begin

   139 s:= s; // avoid compiler hint

   140 CursorMovementX:= -1;

   141 end;

   142 

   143 procedure chCurL_m(var s: shortstring);

   144 begin

   145 s:= s; // avoid compiler hint

   146 CursorMovementX:= 0;

   147 end;

   148 

   149 procedure chCurR_p(var s: shortstring);

   150 begin

   151 s:= s; // avoid compiler hint

   152 CursorMovementX:= 1;

   153 end;

   154 

   155 procedure chCurR_m(var s: shortstring);

   156 begin

   157 s:= s; // avoid compiler hint

   158 CursorMovementX:= 0;

   159 end;

   160 

   161 procedure chLeft_p(var s: shortstring);

   162 begin

   163 s:= s; // avoid compiler hint

   164 if CheckNoTeamOrHH or isPaused then exit;

   165 if not CurrentTeam^.ExtDriven then SendIPC('L');

   166 bShowFinger:= false;

   167 with CurrentHedgehog^.Gear^ do

   168     Message:= Message or (gmLeft and InputMask);

   169     ScriptCall('onLeft');

   170 end;

   171 

   172 procedure chLeft_m(var s: shortstring);

   173 begin

   174 s:= s; // avoid compiler hint

   175 if CheckNoTeamOrHH then exit;

   176 if not CurrentTeam^.ExtDriven then SendIPC('l');

   177 with CurrentHedgehog^.Gear^ do

   178     Message:= Message and not (gmLeft and InputMask);

   179     ScriptCall('onLeftUp');

   180 end;

   181 

   182 procedure chRight_p(var s: shortstring);

   183 begin

   184 s:= s; // avoid compiler hint

   185 if CheckNoTeamOrHH or isPaused then exit;

   186 if not CurrentTeam^.ExtDriven then SendIPC('R');

   187 bShowFinger:= false;

   188 with CurrentHedgehog^.Gear^ do

   189     Message:= Message or (gmRight and InputMask);

   190     ScriptCall('onRight');

   191 end;

   192 

   193 procedure chRight_m(var s: shortstring);

   194 begin

   195 s:= s; // avoid compiler hint

   196 if CheckNoTeamOrHH then exit;

   197 if not CurrentTeam^.ExtDriven then SendIPC('r');

   198 with CurrentHedgehog^.Gear^ do

   199     Message:= Message and not (gmRight and InputMask);

   200     ScriptCall('onRightUp');

   201 end;

   202 

   203 procedure chUp_p(var s: shortstring);

   204 begin

   205 s:= s; // avoid compiler hint

   206 if CheckNoTeamOrHH or isPaused then exit;

   207 if not CurrentTeam^.ExtDriven then SendIPC('U');

   208 bShowFinger:= false;

   209 with CurrentHedgehog^.Gear^ do

   210     Message:= Message or (gmUp and InputMask);

   211     ScriptCall('onUp');

   212 end;

   213 

   214 procedure chUp_m(var s: shortstring);

   215 begin

   216 s:= s; // avoid compiler hint

   217 if CheckNoTeamOrHH then exit;

   218 if not CurrentTeam^.ExtDriven then SendIPC('u');

   219 with CurrentHedgehog^.Gear^ do

   220     Message:= Message and not (gmUp and InputMask);

   221     ScriptCall('onUpUp');

   222 end;

   223 

   224 procedure chDown_p(var s: shortstring);

   225 begin

   226 s:= s; // avoid compiler hint

   227 if CheckNoTeamOrHH or isPaused then exit;

   228 if not CurrentTeam^.ExtDriven then SendIPC('D');

   229 bShowFinger:= false;

   230 with CurrentHedgehog^.Gear^ do

   231     Message:= Message or (gmDown and InputMask);

   232     ScriptCall('onDown');

   233 end;

   234 

   235 procedure chDown_m(var s: shortstring);

   236 begin

   237 s:= s; // avoid compiler hint

   238 if CheckNoTeamOrHH then exit;

   239 if not CurrentTeam^.ExtDriven then SendIPC('d');

   240 with CurrentHedgehog^.Gear^ do

   241     Message:= Message and not (gmDown and InputMask);

   242     ScriptCall('onDownUp');

   243 end;

   244 

   245 procedure chPrecise_p(var s: shortstring);

   246 begin

   247 s:= s; // avoid compiler hint

   248 if CheckNoTeamOrHH or isPaused then exit;

   249 if not CurrentTeam^.ExtDriven then SendIPC('Z');

   250 bShowFinger:= false;

   251 with CurrentHedgehog^.Gear^ do

   252     Message:= Message or (gmPrecise and InputMask);

   253     ScriptCall('onPrecise');

   254 end;

   255 

   256 procedure chPrecise_m(var s: shortstring);

   257 begin

   258 s:= s; // avoid compiler hint

   259 if CheckNoTeamOrHH then exit;

   260 if not CurrentTeam^.ExtDriven then SendIPC('z');

   261 with CurrentHedgehog^.Gear^ do

   262     Message:= Message and not (gmPrecise and InputMask);

   263     ScriptCall('onPreciseUp');

   264 end;

   265 

   266 procedure chLJump(var s: shortstring);

   267 begin

   268 s:= s; // avoid compiler hint

   269 if CheckNoTeamOrHH or isPaused then exit;

   270 if not CurrentTeam^.ExtDriven then SendIPC('j');

   271 bShowFinger:= false;

   272 with CurrentHedgehog^.Gear^ do

   273     Message:= Message or (gmLJump and InputMask);

   274     ScriptCall('onLJump');

   275 end;

   276 

   277 procedure chHJump(var s: shortstring);

   278 begin

   279 s:= s; // avoid compiler hint

   280 if CheckNoTeamOrHH or isPaused then exit;

   281 if not CurrentTeam^.ExtDriven then SendIPC('J');

   282 bShowFinger:= false;

   283 with CurrentHedgehog^.Gear^ do

   284     Message:= Message or (gmHJump and InputMask);

   285     ScriptCall('onHJump');

   286 end;

   287 

   288 procedure chAttack_p(var s: shortstring);

   289 begin

   290 s:= s; // avoid compiler hint

   291 if CheckNoTeamOrHH or isPaused then exit;

   292 bShowFinger:= false;

   293 with CurrentHedgehog^.Gear^ do

   294     begin

   295     {$IFDEF DEBUGFILE}AddFileLog('/+attack: hedgehog''s Gear^.State = '+inttostr(State));{$ENDIF}

   296     if ((State and gstHHDriven) <> 0) then

   297         begin

   298         FollowGear:= CurrentHedgehog^.Gear;

   299         if not CurrentTeam^.ExtDriven then SendIPC('A');

   300         Message:= Message or (gmAttack and InputMask);

   301 	ScriptCall('onAttack');

   302         end

   303     end

   304 end;

   305 

   306 procedure chAttack_m(var s: shortstring);

   307 begin

   308 s:= s; // avoid compiler hint

   309 if CheckNoTeamOrHH then exit;

   310 with CurrentHedgehog^.Gear^ do

   311     begin

   312     if not CurrentTeam^.ExtDriven and

   313         ((Message and gmAttack) <> 0) then SendIPC('a');

   314     Message:= Message and not (gmAttack and InputMask);

   315     ScriptCall('onAttackUp');

   316     end

   317 end;

   318 

   319 procedure chSwitch(var s: shortstring);

   320 begin

   321 s:= s; // avoid compiler hint

   322 if CheckNoTeamOrHH or isPaused then exit;

   323 if not CurrentTeam^.ExtDriven then SendIPC('S');

   324 bShowFinger:= false;

   325 with CurrentHedgehog^.Gear^ do

   326     Message:= Message or (gmSwitch and InputMask);

   327     ScriptCall('onSwitch');

   328 end;

   329 

   330 procedure chNextTurn(var s: shortstring);

   331 begin

   332     s:= s; // avoid compiler hint

   333     TryDo(AllInactive, '/nextturn called when not all gears are inactive', true);

   334 

   335     if not CurrentTeam^.ExtDriven then SendIPC('N');

   336 {$IFDEF DEBUGFILE}

   337     AddFileLog('Doing SwitchHedgehog: time '+inttostr(GameTicks));

   338 {$ENDIF}

   339 end;

   340 

   341 procedure chTimer(var s: shortstring);

   342 begin

   343 if (s[0] <> #1) or (s[1] < '1') or (s[1] > '5') or CheckNoTeamOrHH then exit;

   344 

   345 if not CurrentTeam^.ExtDriven then SendIPC(s);

   346 bShowFinger:= false;

   347 with CurrentHedgehog^.Gear^ do

   348     begin

   349     Message:= Message or (gmTimer and InputMask);

   350     MsgParam:= byte(s[1]) - ord('0');

   351     ScriptCall('onTimer');

   352     end

   353 end;

   354 

   355 procedure chSlot(var s: shortstring);

   356 var slot: LongWord;

   357 begin

   358 if (s[0] <> #1) or CheckNoTeamOrHH then exit;

   359 slot:= byte(s[1]) - 49;

   360 if slot > cMaxSlotIndex then exit;

   361 if not CurrentTeam^.ExtDriven then SendIPC(char(byte(s[1]) + 79));

   362 bShowFinger:= false;

   363 with CurrentHedgehog^.Gear^ do

   364     begin

   365     Message:= Message or (gmSlot and InputMask);

   366     MsgParam:= slot; 

   367     ScriptCall('onSlot');

   368     end

   369 end;

   370 

   371 procedure chSetWeapon(var s: shortstring);

   372 begin

   373     if (s[0] <> #1) or CheckNoTeamOrHH then exit;

   374 

   375     if TAmmoType(s[1]) > High(TAmmoType) then exit;

   376 

   377     if not CurrentTeam^.ExtDriven then SendIPC('w' + s);

   378 

   379     with CurrentHedgehog^.Gear^ do

   380     begin

   381         Message:= Message or (gmWeapon and InputMask);

   382         MsgParam:= byte(s[1]);

   383 	ScriptCall('onSetWeapon');

   384     end;

   385 end;

   386 

   387 procedure chTaunt(var s: shortstring);

   388 begin

   389 if (s[0] <> #1) or CheckNoTeamOrHH then exit;

   390 

   391 if TWave(s[1]) > High(TWave) then exit;

   392 

   393 if not CurrentTeam^.ExtDriven then SendIPC('t' + s);

   394 

   395 with CurrentHedgehog^.Gear^ do

   396     begin

   397     Message:= Message or (gmAnimate and InputMask);

   398     MsgParam:= byte(s[1]) ; 

   399     ScriptCall('onTaunt');

   400     end

   401 end;

   402 

   403 procedure chPut(var s: shortstring);

   404 begin

   405     s:= s; // avoid compiler hint

   406     doPut(0, 0, false);

   407 end;

   408 

   409 procedure chCapture(var s: shortstring);

   410 begin

   411 s:= s; // avoid compiler hint

   412 flagMakeCapture:= true

   413 end;

   414 

   415 procedure chSetMap(var s: shortstring);

   416 begin

   417 if isDeveloperMode then

   418 begin

   419 Pathz[ptMapCurrent]:= Pathz[ptMaps] + '/' + s;

   420 InitStepsFlags:= InitStepsFlags or cifMap

   421 end

   422 end;

   423 

   424 procedure chSetTheme(var s: shortstring);

   425 begin

   426 if isDeveloperMode then

   427 begin

   428 Pathz[ptCurrTheme]:= Pathz[ptThemes] + '/' + s;

   429 Theme:= s;

   430 InitStepsFlags:= InitStepsFlags or cifTheme

   431 end

   432 end;

   433 

   434 procedure chSetSeed(var s: shortstring);

   435 begin

   436 if isDeveloperMode then

   437 begin

   438 SetRandomSeed(s);

   439 cSeed:= s;

   440 InitStepsFlags:= InitStepsFlags or cifRandomize

   441 end

   442 end;

   443 

   444 procedure chAmmoMenu(var s: shortstring);

   445 begin

   446 s:= s; // avoid compiler hint

   447 if CheckNoTeamOrHH then

   448     bShowAmmoMenu:= true

   449 else

   450     begin

   451     with CurrentTeam^ do

   452         with Hedgehogs[CurrHedgehog] do

   453             begin

   454             bSelected:= false;

   455 

   456             if bShowAmmoMenu then bShowAmmoMenu:= false

   457             else if ((Gear^.State and (gstAttacking or gstAttacked)) <> 0) or

   458                     ((MultiShootAttacks > 0) and ((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_NoRoundEnd) = 0)) or

   459                     ((Gear^.State and gstHHDriven) = 0) then else bShowAmmoMenu:= true

   460             end;

   461     end

   462 end;

   463 

   464 procedure chVol_p(var s: shortstring);

   465 begin

   466 s:= s; // avoid compiler hint

   467 inc(cVolumeDelta, 3)

   468 end;

   469 

   470 procedure chVol_m(var s: shortstring);

   471 begin

   472 s:= s; // avoid compiler hint

   473 dec(cVolumeDelta, 3)

   474 end;

   475 

   476 procedure chFindhh(var s: shortstring);

   477 begin

   478 s:= s; // avoid compiler hint

   479 if CheckNoTeamOrHH or isPaused then exit;

   480 bShowFinger:= true;

   481 FollowGear:= CurrentHedgehog^.Gear

   482 end;

   483 

   484 procedure chPause(var s: shortstring);

   485 begin

   486 s:= s; // avoid compiler hint

   487 if gameType <> gmtNet then

   488     isPaused:= not isPaused;

   489 SDL_ShowCursor(ord(isPaused))

   490 end;

   491 

   492 procedure chRotateMask(var s: shortstring);

   493 begin

   494 s:= s; // avoid compiler hint

   495 if ((GameFlags and gfInvulnerable) = 0) then cTagsMask:= cTagsMasks[cTagsMask] else cTagsMask:= cTagsMasksNoHealth[cTagsMask];

   496 end;

   497 

   498 procedure chSpeedup_p(var s: shortstring);

   499 begin

   500 s:= s; // avoid compiler hint

   501 isSpeed:= true

   502 end;

   503 

   504 procedure chSpeedup_m(var s: shortstring);

   505 begin

   506 s:= s; // avoid compiler hint

   507 isSpeed:= false

   508 end;

   509 

   510 procedure chZoomIn(var s: shortstring);

   511 begin

   512     s:= s; // avoid compiler hint

   513     if ZoomValue < cMinZoomLevel then

   514         ZoomValue:= ZoomValue + cZoomDelta;

   515 end;

   516 

   517 procedure chZoomOut(var s: shortstring);

   518 begin

   519     s:= s; // avoid compiler hint

   520     if ZoomValue > cMaxZoomLevel then

   521         ZoomValue:= ZoomValue - cZoomDelta;

   522 end;

   523 

   524 procedure chZoomReset(var s: shortstring);

   525 begin

   526     s:= s; // avoid compiler hint

   527     ZoomValue:= cDefaultZoomLevel;

   528 end;

   529 

   530 

   531 procedure initModule;

   532 begin

   533 //////// Begin top sorted by freq analysis not including chatmsg

   534     RegisterVariable('+right'  , vtCommand, @chRight_p      , false);

   535     RegisterVariable('-right'  , vtCommand, @chRight_m      , false);

   536     RegisterVariable('+up'     , vtCommand, @chUp_p         , false);

   537     RegisterVariable('-up'     , vtCommand, @chUp_m         , false);

   538     RegisterVariable('+left'   , vtCommand, @chLeft_p       , false);

   539     RegisterVariable('-left'   , vtCommand, @chLeft_m       , false);

   540     RegisterVariable('+attack' , vtCommand, @chAttack_p     , false);

   541     RegisterVariable('+down'   , vtCommand, @chDown_p       , false);

   542     RegisterVariable('-down'   , vtCommand, @chDown_m       , false);

   543     RegisterVariable('hjump'   , vtCommand, @chHJump        , false);

   544     RegisterVariable('ljump'   , vtCommand, @chLJump        , false);

   545     RegisterVariable('nextturn', vtCommand, @chNextTurn     , false);

   546     RegisterVariable('-attack' , vtCommand, @chAttack_m     , false);

   547     RegisterVariable('slot'    , vtCommand, @chSlot         , false);

   548     RegisterVariable('setweap' , vtCommand, @chSetWeapon    , false);

   549 //////// End top by freq analysis

   550     RegisterVariable('gencmd'  , vtCommand, @chGenCmd       , false);

   551     RegisterVariable('flag'    , vtCommand, @chFlag         , false);

   552     RegisterVariable('script'  , vtCommand, @chScript       , false);

   553     RegisterVariable('proto'   , vtCommand, @chCheckProto   , true );

   554     RegisterVariable('spectate', vtBoolean, @fastUntilLag   , false);

   555     RegisterVariable('capture' , vtCommand, @chCapture      , true );

   556     RegisterVariable('rotmask' , vtCommand, @chRotateMask   , true );

   557     RegisterVariable('rdriven' , vtCommand, @chTeamLocal    , false);

   558     RegisterVariable('map'     , vtCommand, @chSetMap       , false);

   559     RegisterVariable('theme'   , vtCommand, @chSetTheme     , false);

   560     RegisterVariable('seed'    , vtCommand, @chSetSeed      , false);

   561     RegisterVariable('template_filter', vtLongInt, @cTemplateFilter, false);

   562     RegisterVariable('mapgen'  , vtLongInt, @cMapGen        , false);

   563     RegisterVariable('maze_size',vtLongInt, @cMazeSize      , false);

   564     RegisterVariable('delay'   , vtLongInt, @cInactDelay    , false);

   565     RegisterVariable('ready'   , vtLongInt, @cReadyDelay    , false);

   566     RegisterVariable('casefreq', vtLongInt, @cCaseFactor    , false);

   567     RegisterVariable('healthprob', vtLongInt, @cHealthCaseProb, false);

   568     RegisterVariable('hcaseamount', vtLongInt, @cHealthCaseAmount, false);

   569     RegisterVariable('sd_turns', vtLongInt, @cSuddenDTurns  , false);

   570     RegisterVariable('waterrise', vtLongInt, @cWaterRise    , false);

   571     RegisterVariable('healthdec', vtLongInt, @cHealthDecrease, false);

   572     RegisterVariable('damagepct',vtLongInt, @cDamagePercent , false);

   573     RegisterVariable('ropepct' , vtLongInt, @cRopePercent   , false);

   574     RegisterVariable('minedudpct',vtLongInt,@cMineDudPercent, false);

   575     RegisterVariable('minesnum', vtLongInt, @cLandMines     , false);

   576     RegisterVariable('explosives',vtLongInt,@cExplosives    , false);

   577     RegisterVariable('gmflags' , vtLongInt, @GameFlags      , false);

   578     RegisterVariable('turntime', vtLongInt, @cHedgehogTurnTime, false);

   579     RegisterVariable('minestime',vtLongInt, @cMinesTime     , false);

   580     RegisterVariable('fort'    , vtCommand, @chFort         , false);

   581     RegisterVariable('grave'   , vtCommand, @chGrave        , false);

   582     RegisterVariable('hat'     , vtCommand, @chSetHat       , false);

   583     RegisterVariable('quit'    , vtCommand, @chQuit         , true );

   584     RegisterVariable('confirm' , vtCommand, @chConfirm      , true );

   585     RegisterVariable('+speedup', vtCommand, @chSpeedup_p    , true );

   586     RegisterVariable('-speedup', vtCommand, @chSpeedup_m    , true );

   587     RegisterVariable('zoomin'  , vtCommand, @chZoomIn       , true );

   588     RegisterVariable('zoomout' , vtCommand, @chZoomOut      , true );

   589     RegisterVariable('zoomreset',vtCommand, @chZoomReset    , true );

   590     RegisterVariable('ammomenu', vtCommand, @chAmmoMenu     , true);

   591     RegisterVariable('+precise', vtCommand, @chPrecise_p    , false);

   592     RegisterVariable('-precise', vtCommand, @chPrecise_m    , false);

   593     RegisterVariable('switch'  , vtCommand, @chSwitch       , false);

   594     RegisterVariable('timer'   , vtCommand, @chTimer        , false);

   595     RegisterVariable('taunt'   , vtCommand, @chTaunt        , false);

   596     RegisterVariable('put'     , vtCommand, @chPut          , false);

   597     RegisterVariable('+volup'  , vtCommand, @chVol_p        , true );

   598     RegisterVariable('-volup'  , vtCommand, @chVol_m        , true );

   599     RegisterVariable('+voldown', vtCommand, @chVol_m        , true );

   600     RegisterVariable('-voldown', vtCommand, @chVol_p        , true );

   601     RegisterVariable('findhh'  , vtCommand, @chFindhh       , true );

   602     RegisterVariable('pause'   , vtCommand, @chPause        , true );

   603     RegisterVariable('+cur_u'  , vtCommand, @chCurU_p       , true );

   604     RegisterVariable('-cur_u'  , vtCommand, @chCurU_m       , true );

   605     RegisterVariable('+cur_d'  , vtCommand, @chCurD_p       , true );

   606     RegisterVariable('-cur_d'  , vtCommand, @chCurD_m       , true );

   607     RegisterVariable('+cur_l'  , vtCommand, @chCurL_p       , true );

   608     RegisterVariable('-cur_l'  , vtCommand, @chCurL_m       , true );

   609     RegisterVariable('+cur_r'  , vtCommand, @chCurR_p       , true );

   610     RegisterVariable('-cur_r'  , vtCommand, @chCurR_m       , true );

   611 end;

   612 

   613 procedure freeModule;

   614 begin

   615 end;

   616 

   617 end.