caosVM_creatures.cpp

   1 /*
   2  *  caosVM_creatures.cpp
   3  *  openc2e
   4  *
   5  *  Created by Alyssa Milburn on Tue Jun 01 2004.
   6  *  Copyright (c) 2004 Alyssa Milburn. All rights reserved.
   7  *
   8  *  This library is free software; you can redistribute it and/or
   9  *  modify it under the terms of the GNU Lesser General Public
  10  *  License as published by the Free Software Foundation; either
  11  *  version 2 of the License, or (at your option) any later version.
  12  *
  13  *  This library is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  *  Lesser General Public License for more details.
  17  *
  18  */
  19
  20 #include "caosVM.h"
  21 #include <iostream>
  22 #include "openc2e.h"
  23 #include "World.h"
  24 #include "Engine.h"
  25 #include "SkeletalCreature.h"
  26 #include "Creature.h"
  27 using std::cerr;
  28
  29 CreatureAgent *caosVM::getTargCreatureAgent() {
  30         valid_agent(targ);
  31         CreatureAgent *c = dynamic_cast<CreatureAgent *>(targ.get());
  32         caos_assert(c);
  33         return c;
  34 }
  35
  36 Creature *caosVM::getTargCreature() {
  37         return getTargCreatureAgent()->getCreature();
  38 }
  39
  40 oldCreature *getoldCreature(Agent *a) {
  41         if (!a) return 0;
  42         CreatureAgent *b = dynamic_cast<CreatureAgent *>(a);
  43         if (!b) return 0;
  44         oldCreature *c = dynamic_cast<oldCreature *>(b->getCreature());
  45         return c;
  46 }
  47
  48 c2eCreature *getc2eCreature(Agent *a) {
  49         if (!a) return 0;
  50         CreatureAgent *b = dynamic_cast<CreatureAgent *>(a);
  51         if (!b) return 0;
  52         c2eCreature *c = dynamic_cast<c2eCreature *>(b->getCreature());
  53         return c;
  54 }
  55
  56 /**
  57  STM# SHOU (command) stimulusno (integer)
  58  %status stub
  59  %pragma variants c1 c2
  60  %cost c1,c2 0
  61 */
  62 void caosVM::c_STM_SHOU() {
  63         VM_PARAM_INTEGER(stimulusno)
  64
  65         // TODO
  66 }
  67
  68 /**
  69  STM# SIGN (command) stimulusno (integer)
  70  %status stub
  71  %pragma variants c1 c2
  72  %cost c1,c2 0
  73 */
  74 void caosVM::c_STM_SIGN() {
  75         VM_PARAM_INTEGER(stimulusno)
  76
  77         // TODO
  78 }
  79
  80 /**
  81  STM# TACT (command) stimulusno (integer)
  82  %status stub
  83  %pragma variants c1 c2
  84  %cost c1,c2 0
  85 */
  86 void caosVM::c_STM_TACT() {
  87         VM_PARAM_INTEGER(stimulusno)
  88
  89         // TODO
  90 }
  91
  92 /**
  93  STM# WRIT (command) object (agent) stimulusno (integer)
  94  %status stub
  95  %pragma variants c1 c2
  96  %cost c1,c2 0
  97 */
  98 void caosVM::c_STM_WRIT() {
  99         VM_PARAM_INTEGER(stimulusno)
 100         VM_PARAM_VALIDAGENT(object)
 101
 102         // TODO
 103 }
 104
 105 /**
 106  STIM SHOU (command) stimulus (integer) strength (float)
 107  %status stub
 108
 109  Send a stimulus of the given type to all Creatures who can hear OWNR.
 110 */
 111 void caosVM::c_STIM_SHOU() {
 112         VM_VERIFY_SIZE(3)
 113         VM_PARAM_FLOAT(strength)
 114         VM_PARAM_INTEGER(stimulus)
 115
 116         // TODO
 117 }
 118
 119 /**
 120  STIM SIGN (command) stimulus (integer) strength (float)
 121  %status stub
 122
 123  Sends a stimulus of the given type to all Creatures who can see OWNR.
 124 */
 125 void caosVM::c_STIM_SIGN() {
 126         VM_VERIFY_SIZE(3)
 127         VM_PARAM_FLOAT(strength)
 128         VM_PARAM_INTEGER(stimulus)
 129
 130         // TODO
 131 }
 132
 133 /**
 134  STIM TACT (command) stimulus (integer) strength (float)
 135  %status stub
 136
 137  Sends a stimulus of the given type to all Creatures who are touching OWNR.
 138 */
 139 void caosVM::c_STIM_TACT() {
 140         VM_VERIFY_SIZE(3)
 141         VM_PARAM_FLOAT(strength)
 142         VM_PARAM_INTEGER(stimulus)
 143
 144         // TODO
 145 }
 146
 147 /**
 148  STIM WRIT (command) creature (agent) stimulus (integer) strength (float)
 149  %status maybe
 150
 151  Sends a stimulus of the given type to specific Creature.
 152 */
 153 void caosVM::c_STIM_WRIT() {
 154         VM_VERIFY_SIZE(3)
 155         VM_PARAM_FLOAT(strength)
 156         VM_PARAM_INTEGER(stimulus)
 157         VM_PARAM_VALIDAGENT(creature)
 158
 159         c2eCreature *c = getc2eCreature(creature.get());
 160         if (!c) return; // ignored on non-creatures
 161
 162         // TODO: ownr?
 163         c->handleStimulus(stimulus, strength);
 164 }
 165
 166 /**
 167  STIM SHOU (command) significance (integer) input (integer) intensity (integer) features (integer) chem0 (integer) amount0 (integer) chem1 (integer) amount1 (integer) chem2 (integer) amount2 (integer) chem3 (integer) amount3 (integer)
 168  %status stub
 169  %pragma implementation caosVM::c_STIM_SHOU_c2
 170  %pragma variants c1 c2
 171  %cost c1,c2 0
 172 */
 173 void caosVM::c_STIM_SHOU_c2() {
 174         VM_PARAM_INTEGER(amount3)
 175         VM_PARAM_INTEGER(chem3)
 176         VM_PARAM_INTEGER(amount2)
 177         VM_PARAM_INTEGER(chem2)
 178         VM_PARAM_INTEGER(amount1)
 179         VM_PARAM_INTEGER(chem1)
 180         VM_PARAM_INTEGER(amount0)
 181         VM_PARAM_INTEGER(chem0)
 182         VM_PARAM_INTEGER(features)
 183         VM_PARAM_INTEGER(intensity)
 184         VM_PARAM_INTEGER(input)
 185         VM_PARAM_INTEGER(significance)
 186
 187         // TODO
 188 }
 189
 190 /**
 191  STIM SIGN (command) significance (integer) input (integer) intensity (integer) features (integer) chem0 (integer) amount0 (integer) chem1 (integer) amount1 (integer) chem2 (integer) amount2 (integer) chem3 (integer) amount3 (integer)
 192  %status stub
 193  %pragma implementation caosVM::c_STIM_SIGN_c2
 194  %pragma variants c1 c2
 195  %cost c1,c2 0
 196 */
 197 void caosVM::c_STIM_SIGN_c2() {
 198         VM_PARAM_INTEGER(amount3)
 199         VM_PARAM_INTEGER(chem3)
 200         VM_PARAM_INTEGER(amount2)
 201         VM_PARAM_INTEGER(chem2)
 202         VM_PARAM_INTEGER(amount1)
 203         VM_PARAM_INTEGER(chem1)
 204         VM_PARAM_INTEGER(amount0)
 205         VM_PARAM_INTEGER(chem0)
 206         VM_PARAM_INTEGER(features)
 207         VM_PARAM_INTEGER(intensity)
 208         VM_PARAM_INTEGER(input)
 209         VM_PARAM_INTEGER(significance)
 210
 211         // TODO
 212 }
 213
 214 /**
 215  STIM TACT (command) significance (integer) input (integer) intensity (integer) features (integer) chem0 (integer) amount0 (integer) chem1 (integer) amount1 (integer) chem2 (integer) amount2 (integer) chem3 (integer) amount3 (integer)
 216  %status stub
 217  %pragma implementation caosVM::c_STIM_TACT_c2
 218  %pragma variants c1 c2
 219  %cost c1,c2 0
 220 */
 221 void caosVM::c_STIM_TACT_c2() {
 222         VM_PARAM_INTEGER(amount3)
 223         VM_PARAM_INTEGER(chem3)
 224         VM_PARAM_INTEGER(amount2)
 225         VM_PARAM_INTEGER(chem2)
 226         VM_PARAM_INTEGER(amount1)
 227         VM_PARAM_INTEGER(chem1)
 228         VM_PARAM_INTEGER(amount0)
 229         VM_PARAM_INTEGER(chem0)
 230         VM_PARAM_INTEGER(features)
 231         VM_PARAM_INTEGER(intensity)
 232         VM_PARAM_INTEGER(input)
 233         VM_PARAM_INTEGER(significance)
 234
 235         // TODO
 236 }
 237
 238 /**
 239  STIM WRIT (command) creature (agent) significance (integer) input (integer) intensity (integer) features (integer) chem0 (integer) amount0 (integer) chem1 (integer) amount1 (integer) chem2 (integer) amount2 (integer) chem3 (integer) amount3 (integer)
 240  %status stub
 241  %pragma implementation caosVM::c_STIM_WRIT_c2
 242  %pragma variants c1 c2
 243  %cost c1,c2 0
 244 */
 245 void caosVM::c_STIM_WRIT_c2() {
 246         VM_PARAM_INTEGER(amount3)
 247         VM_PARAM_INTEGER(chem3)
 248         VM_PARAM_INTEGER(amount2)
 249         VM_PARAM_INTEGER(chem2)
 250         VM_PARAM_INTEGER(amount1)
 251         VM_PARAM_INTEGER(chem1)
 252         VM_PARAM_INTEGER(amount0)
 253         VM_PARAM_INTEGER(chem0)
 254         VM_PARAM_INTEGER(features)
 255         VM_PARAM_INTEGER(intensity)
 256         VM_PARAM_INTEGER(input)
 257         VM_PARAM_INTEGER(significance)
 258         VM_PARAM_AGENT(creature)
 259
 260         // TODO
 261         //oldCreature *c = getoldCreature(creature.get());
 262         //if (!c) return; // ignored on non-creatures
 263
 264         // TODO
 265 }
 266
 267 /**
 268  STIM FROM (command) significance (integer) input (integer) intensity (integer) features (integer) chem0 (integer) amount0 (integer) chem1 (integer) amount1 (integer) chem2 (integer) amount2 (integer) chem3 (integer) amount3 (integer)
 269  %status stub
 270  %pragma implementation caosVM::c_STIM_FROM_c1
 271  %pragma variants c1
 272  %cost c1,c2 0
 273 */
 274 void caosVM::c_STIM_FROM_c1() {
 275         VM_PARAM_INTEGER(amount3)
 276         VM_PARAM_INTEGER(chem3)
 277         VM_PARAM_INTEGER(amount2)
 278         VM_PARAM_INTEGER(chem2)
 279         VM_PARAM_INTEGER(amount1)
 280         VM_PARAM_INTEGER(chem1)
 281         VM_PARAM_INTEGER(amount0)
 282         VM_PARAM_INTEGER(chem0)
 283         VM_PARAM_INTEGER(features)
 284         VM_PARAM_INTEGER(intensity)
 285         VM_PARAM_INTEGER(input)
 286         VM_PARAM_INTEGER(significance)
 287
 288         valid_agent(from.getAgent());
 289         // TODO
 290 }
 291
 292 /**
 293  SWAY SHOU (command) drive (integer) adjust (float) drive (integer) adjust (float) drive (integer) adjust (float) drive (integer) adjust (float)
 294  %status stub
 295
 296  Adjusts these four drives in all Creatures who can hear OWNR.
 297 */
 298 void caosVM::c_SWAY_SHOU() {
 299         VM_VERIFY_SIZE(8)
 300         VM_PARAM_FLOAT(adjust4)
 301         VM_PARAM_INTEGER(drive4)
 302         VM_PARAM_FLOAT(adjust3)
 303         VM_PARAM_INTEGER(drive3)
 304         VM_PARAM_FLOAT(adjust2)
 305         VM_PARAM_INTEGER(drive2)
 306         VM_PARAM_FLOAT(adjust1)
 307         VM_PARAM_INTEGER(drive1)
 308
 309         valid_agent(owner);
 310         //TODO
 311 }
 312
 313 /**
 314  SWAY SIGN (command) drive (integer) adjust (float) drive (integer) adjust (float) drive (integer) adjust (float) drive (integer) adjust (float)
 315  %status stub
 316
 317  Adjusts these four drives in all Creatures who can see OWNR.
 318 */
 319 void caosVM::c_SWAY_SIGN() {
 320         VM_VERIFY_SIZE(8)
 321         VM_PARAM_FLOAT(adjust4)
 322         VM_PARAM_INTEGER(drive4)
 323         VM_PARAM_FLOAT(adjust3)
 324         VM_PARAM_INTEGER(drive3)
 325         VM_PARAM_FLOAT(adjust2)
 326         VM_PARAM_INTEGER(drive2)
 327         VM_PARAM_FLOAT(adjust1)
 328         VM_PARAM_INTEGER(drive1)
 329
 330         valid_agent(owner);
 331         //TODO
 332 }
 333
 334 /**
 335  SWAY TACT (command) drive (integer) adjust (float) drive (integer) adjust (float) drive (integer) adjust (float) drive (integer) adjust (float)
 336  %status stub
 337
 338  Adjusts these four drives in all Creatures who are touching OWNR.
 339 */
 340 void caosVM::c_SWAY_TACT() {
 341         VM_VERIFY_SIZE(8)
 342         VM_PARAM_FLOAT(adjust4)
 343         VM_PARAM_INTEGER(drive4)
 344         VM_PARAM_FLOAT(adjust3)
 345         VM_PARAM_INTEGER(drive3)
 346         VM_PARAM_FLOAT(adjust2)
 347         VM_PARAM_INTEGER(drive2)
 348         VM_PARAM_FLOAT(adjust1)
 349         VM_PARAM_INTEGER(drive1)
 350
 351         valid_agent(owner);
 352         //TODO
 353 }
 354
 355 /**
 356  SWAY WRIT (command) creature (agent) drive (integer) adjust (float) drive (integer) adjust (float) drive (integer) adjust (float) drive (integer) adjust (float)
 357  %status stub
 358
 359  Adjusts these four drives in the specified creature.
 360 */
 361 void caosVM::c_SWAY_WRIT() {
 362         VM_VERIFY_SIZE(8)
 363         VM_PARAM_FLOAT(adjust4)
 364         VM_PARAM_INTEGER(drive4)
 365         VM_PARAM_FLOAT(adjust3)
 366         VM_PARAM_INTEGER(drive3)
 367         VM_PARAM_FLOAT(adjust2)
 368         VM_PARAM_INTEGER(drive2)
 369         VM_PARAM_FLOAT(adjust1)
 370         VM_PARAM_INTEGER(drive1)
 371         VM_PARAM_VALIDAGENT(creature)
 372
 373         valid_agent(owner);
 374         //TODO
 375 }
 376
 377 /**
 378  NOHH (command)
 379  %status stub
 380
 381  Tells the target Creature to stop holding hands with the pointer.
 382 */
 383 void caosVM::c_NOHH() {
 384         VM_VERIFY_SIZE(0)
 385
 386         if (!targ) return; // DS agent help, at least, does 'targ hhld nohh'
 387
 388         Creature *c = getTargCreature();
 389         // TODO
 390 }
 391
 392 /**
 393  ZOMB (command) zombie (integer)
 394  %status maybe
 395
 396  Turns zombification of the target Creature on and off.  Set to 1 to disconnect the brain and
 397  motor of the target Creature, and 0 to undo.
 398 */
 399 void caosVM::c_ZOMB() {
 400         VM_VERIFY_SIZE(1)
 401         VM_PARAM_INTEGER(zombie)
 402
 403         Creature *c = getTargCreature();
 404
 405         c->setZombie(zombie);
 406 }
 407
 408 /**
 409  ZOMB (integer)
 410  %status maybe
 411
 412  Returns 1 if target Creature is zombified, or 0 if otherwise.
 413 */
 414 void caosVM::v_ZOMB() {
 415         Creature *c = getTargCreature();
 416         result.setInt(c->isZombie());
 417 }
 418
 419 /**
 420  DIRN (command) direction (integer)
 421  %status maybe
 422
 423  Changes the target Creature to face a different direction.
 424 */
 425 void caosVM::c_DIRN() {
 426         VM_VERIFY_SIZE(1)
 427         VM_PARAM_INTEGER(direction)
 428
 429         caos_assert(direction >= 0 && direction <= 3);
 430
 431         CreatureAgent *c = getTargCreatureAgent();
 432         c->setDirection(direction);
 433 }
 434
 435 /**
 436  DIRN (integer)
 437  %status maybe
 438  %pragma variants c2 cv c3
 439
 440  Returns the direction the target Creatures is facing.
 441 */
 442 void caosVM::v_DIRN() {
 443         CreatureAgent *c = getTargCreatureAgent();
 444
 445         result.setInt(c->getDirection());
 446 }
 447
 448 /**
 449  HHLD (agent)
 450  %status stub
 451
 452  Returns Creatures that are holding hands with pointer, or NULL if none.
 453 */
 454 void caosVM::v_HHLD() {
 455         VM_VERIFY_SIZE(0)
 456
 457         result.setAgent(0); // TODO
 458 }
 459
 460 /**
 461  MVFT (command) x (float) y (float)
 462  %status maybe
 463
 464  Move the target Creature's foot (along with the rest of the Creature, obviously) to the given
 465  coordinates.  You should use this rather than MVTO for Creatures.
 466 */
 467 void caosVM::c_MVFT() {
 468         VM_VERIFY_SIZE(2)
 469         VM_PARAM_FLOAT(y)
 470         VM_PARAM_FLOAT(x)
 471
 472         caos_assert(targ);
 473         SkeletalCreature *c = dynamic_cast<SkeletalCreature *>(targ.get());
 474         caos_assert(c);
 475
 476         // TODO: this should be nicer
 477         float downfootxoffset = c->attachmentX(c->isLeftFootDown() ? 11 : 12, 0);
 478         float downfootyoffset = c->attachmentY(c->isLeftFootDown() ? 11 : 12, 0);
 479
 480         targ->moveTo(x - downfootxoffset, y - downfootyoffset);
 481 }
 482
 483 /**
 484  CREA (integer) agent (agent)
 485  %status done
 486
 487  Determines whether the given agent is a creature or not (0 or 1).
 488 */
 489 void caosVM::v_CREA() {
 490         VM_VERIFY_SIZE(1)
 491         VM_PARAM_AGENT(agent)
 492
 493         CreatureAgent *c = dynamic_cast<CreatureAgent *>(agent.get());
 494         if (c) result.setInt(1);
 495         else result.setInt(0);
 496 }
 497
 498 /**
 499  VOCB (command)
 500  %status stub
 501
 502  Makes the target Creature learn all vocabulary words immediately.
 503 */
 504 void caosVM::c_VOCB() {
 505         VM_VERIFY_SIZE(0)
 506
 507         Creature *c = getTargCreature();
 508
 509         // TODO
 510 }
 511
 512 /**
 513  DEAD (command)
 514  %status maybe
 515
 516  Kill the target Creature biologically.
 517 */
 518 void caosVM::c_DEAD() {
 519         Creature *c = getTargCreature();
 520
 521         c->die();
 522 }
 523
 524 /**
 525  DEAD (integer)
 526  %status maybe
 527  %pragma variants c1 c2 cv c3
 528
 529  Determines whether the target Creature is dead (0 or 1).
 530 */
 531 void caosVM::v_DEAD() {
 532         Creature *c = getTargCreature();
 533
 534         result.setInt(!c->isAlive());
 535 }
 536
 537 /**
 538  NORN (command) creature (agent)
 539  %status maybe
 540
 541  Sets the target Creature to the given one.
 542 */
 543 void caosVM::c_NORN() {
 544         VM_PARAM_AGENT(creature)
 545
 546         world.selectCreature(creature);
 547 }
 548
 549 /**
 550  NORN (agent)
 551  %status maybe
 552  %pragma variants cv c3
 553
 554  Returns the target Creature.
 555 */
 556 /**
 557  NORN (variable)
 558  %status maybe
 559  %pragma variants c1 c2
 560
 561  Returns the target Creature.
 562 */
 563 CAOS_LVALUE(NORN, (void)0,
 564                 caosVar(world.selectedcreature),
 565                 world.selectCreature(newvalue.getAgent())
 566         )
 567
 568 #include "AgentHelpers.h"
 569
 570 /**
 571  URGE SHOU (command) noun_stim (float) verb_id (integer) verb_stim (float)
 572  %status stub
 573
 574  Urges all Creatures who can hear OWNR to perform the given action on OWNR.
 575  The two stimuli parameters can range from -1.0 (discourage) to 1.0 (encourage).
 576 */
 577 void caosVM::c_URGE_SHOU() {
 578         VM_PARAM_FLOAT(verb_stim)
 579         VM_PARAM_INTEGER(verb_id)
 580         VM_PARAM_FLOAT(noun_stim)
 581
 582         valid_agent(owner);
 583
 584         // TODO
 585 }
 586
 587 /**
 588  URGE SIGN (command) noun_stim (float) verb_id (integer) verb_stim (float)
 589  %status maybe
 590
 591  Urges all Creatures who can see OWNR to perform the given action on OWNR.
 592  The two stimuli parameters can range from -1.0 (discourage) to 1.0 (encourage).
 593 */
 594 void caosVM::c_URGE_SIGN() {
 595         VM_PARAM_FLOAT(verb_stim)
 596         VM_PARAM_INTEGER(verb_id)
 597         VM_PARAM_FLOAT(noun_stim)
 598
 599         valid_agent(owner);
 600
 601         // TODO: sanitise stim params (bind to -1.0/1.0)
 602         c2eStim stim;
 603         stim.noun_id = owner->category;
 604         if (stim.noun_id == -1) return; // TODO: correct?
 605         stim.noun_amount = noun_stim;
 606         stim.verb_id = verb_id;
 607         stim.verb_amount = verb_stim;
 608
 609         std::vector<boost::shared_ptr<Agent> > agents = getVisibleList(owner, 0, 0, 0);
 610         for (std::vector<boost::shared_ptr<Agent> >::iterator i = agents.begin(); i != agents.end(); i++) {
 611                 boost::shared_ptr<Agent> a = *i; // guaranteed to be valid from getVisibleList
 612
 613                 CreatureAgent *ca = dynamic_cast<CreatureAgent *>(a.get());
 614                 if (!ca) continue;
 615                 c2eCreature *c = dynamic_cast<c2eCreature *>(ca->getCreature());
 616                 if (!c) continue;
 617
 618                 c->handleStimulus(stim);
 619         }
 620 }
 621
 622 /**
 623  URGE TACT (command) noun_stim (float) verb_id (integer) verb_stim (float)
 624  %status stub
 625
 626  Urges all Creatures who are touching OWNR to perform the given action on OWNR.
 627  The two stimuli parameters can range from -1.0 (discourage) to 1.0 (encourage).
 628 */
 629 void caosVM::c_URGE_TACT() {
 630         VM_PARAM_FLOAT(verb_stim)
 631         VM_PARAM_INTEGER(verb_id)
 632         VM_PARAM_FLOAT(noun_stim)
 633
 634         valid_agent(owner);
 635
 636         // TODO
 637 }
 638
 639 /**
 640  URGE WRIT (command) creature (agent) noun_id (integer) noun_stim (float) verb_id (integer) verb_stim (float)
 641  %status stub
 642
 643  Urges the specified Creature to perform the specified action (verb) on the specified object type
 644  (noun).  Provide a stim greater than 1 to force, and an id of -1 and a stim greater than 1 to unforce.
 645 */
 646 void caosVM::c_URGE_WRIT() {
 647         VM_PARAM_FLOAT(verb_stim)
 648         VM_PARAM_INTEGER(verb_id)
 649         VM_PARAM_FLOAT(noun_stim)
 650         VM_PARAM_INTEGER(noun_id)
 651         VM_PARAM_AGENT(creature)
 652
 653         if (!creature) return;
 654         c2eCreature *c = getc2eCreature(creature.get());
 655         if (!c) return; // ignored on non-creatures
 656
 657         // TODO
 658 }
 659
 660 /**
 661  DRIV (command) drive_id (integer) adjust (float)
 662  %status maybe
 663
 664  Modifies the level of a drive in target Creature by the given level, which can range from -1.0 (decrease) to 1.0 (increase).
 665 */
 666 void caosVM::c_DRIV() {
 667         VM_PARAM_FLOAT(adjust)
 668         VM_PARAM_INTEGER(drive_id) caos_assert(drive_id >= 0 && drive_id < 20);
 669
 670         valid_agent(targ);
 671         c2eCreature *c = getc2eCreature(targ.get());
 672         if (!c) return; // ignored on non-creatures
 673
 674         c->adjustDrive(drive_id, adjust);
 675 }
 676
 677 /**
 678  DRIV (float) drive_id (integer)
 679  %status maybe
 680
 681  Returns the level of a drive (0.0 to 1.0) in target Creature.
 682 */
 683 void caosVM::v_DRIV() {
 684         VM_PARAM_INTEGER(drive_id) caos_assert(drive_id >= 0 && drive_id < 20);
 685
 686         c2eCreature *c = getc2eCreature(targ.get());
 687         caos_assert(c);
 688
 689         result.setFloat(c->getDrive(drive_id));
 690 }
 691
 692 /**
 693  CHEM (command) chemical_id (integer) adjust (float)
 694  %status maybe
 695
 696  Modifies the level of a chemical in target Creature's bloodstream by adjust, which can range from -1.0 (decrease) to 1.0 (increase).
 697 */
 698 void caosVM::c_CHEM() {
 699         VM_PARAM_FLOAT(adjust)
 700         VM_PARAM_INTEGER(chemical_id) caos_assert(chemical_id >= 0 && chemical_id < 256);
 701
 702         valid_agent(targ);
 703         c2eCreature *c = getc2eCreature(targ.get());
 704         if (!c) return; // ignored on non-creatures
 705
 706         c->adjustChemical(chemical_id, adjust);
 707 }
 708
 709 /**
 710  CHEM (command) chemical_id (integer) adjust (integer)
 711  %status maybe
 712  %pragma variants c1 c2
 713  %pragma implementation caosVM::c_CHEM_c1
 714  %cost c1,c2 0
 715
 716  Set the level of a chemical (0 to 255) in target creature's bloodstream.
 717 */
 718 void caosVM::c_CHEM_c1() {
 719         VM_PARAM_INTEGER(adjust)
 720         VM_PARAM_INTEGER(chemical_id) caos_assert(chemical_id >= 0 && chemical_id < 256);
 721
 722         // TODO: can adjust be negative?
 723
 724         valid_agent(targ);
 725         oldCreature *c = getoldCreature(targ.get());
 726         if (!c) return; // ignored on non-creatures
 727
 728         c->addChemical(chemical_id, adjust);
 729 }
 730
 731 /**
 732  CHEM (float) chemical_id (integer)
 733  %status maybe
 734
 735  Returns the level of a chemical (0.0 to 1.0) in target creature's bloodstream.
 736 */
 737 void caosVM::v_CHEM() {
 738         VM_PARAM_INTEGER(chemical_id) caos_assert(chemical_id >= 0 && chemical_id < 256);
 739
 740         valid_agent(targ);
 741         c2eCreature *c = getc2eCreature(targ.get());
 742         caos_assert(c);
 743
 744         result.setFloat(c->getChemical(chemical_id));
 745 }
 746
 747 /**
 748  CHEM (integer) chemical_id (integer)
 749  %status maybe
 750  %pragma variants c1 c2
 751  %pragma implementation caosVM::v_CHEM_c1
 752
 753  Returns the level of a chemical (0 to 255) in target creature's bloodstream.
 754 */
 755 void caosVM::v_CHEM_c1() {
 756         VM_PARAM_INTEGER(chemical_id) caos_assert(chemical_id >= 0 && chemical_id < 256);
 757
 758         valid_agent(targ);
 759         oldCreature *c = getoldCreature(targ.get());
 760         caos_assert(c);
 761
 762         result.setInt(c->getChemical(chemical_id));
 763 }
 764
 765 /**
 766  ASLP (command) asleep (integer)
 767  %status maybe
 768  %pragma variants c1 c2 cv c3
 769
 770  If asleep is 1, makes the target creature sleep. If asleep is 0, makes the target creature wake.
 771 */
 772 void caosVM::c_ASLP() {
 773         VM_PARAM_INTEGER(asleep)
 774
 775         Creature *c = getTargCreature();
 776
 777         c->setAsleep(asleep);
 778 }
 779
 780 /**
 781  ASLP (integer)
 782  %status maybe
 783  %pragma variants c1 c2 cv c3
 784  %cost c1,c2 0
 785
 786  Determines whether the target Creature is asleep.
 787 */
 788 void caosVM::v_ASLP() {
 789         Creature *c = getTargCreature();
 790
 791         result.setInt(c->isAsleep());
 792 }
 793
 794 #include "AgentHelpers.h"
 795
 796 class blockUntilApproached : public blockCond {
 797         protected:
 798                 AgentRef parent, it;
 799                 CreatureAgent *parentcreature;
 800
 801         public:
 802                 blockUntilApproached(AgentRef p, AgentRef i) : parent(p), it(i) {
 803                         assert(parent);
 804                         parentcreature = dynamic_cast<CreatureAgent *>(parent.get());
 805                         assert(parentcreature);
 806                 }
 807                 virtual bool operator()() {
 808                         if (!parent) return false;
 809                         if (!it) return false; // TODO: CAs
 810
 811                         if (agentsTouching(parent, it)) return false;
 812
 813                         // parentcreature is guaranteed to be valid if parent is
 814
 815                         // TODO: cope with this problem (eg: another APPR, creature paused, non-skeletal creature, etc)
 816                         //if (parentcreature->isApproaching()) return false;
 817
 818                         // note that this merely sets up the approach to be done on the next tick of the creature
 819                         parentcreature->approach(it);
 820
 821                         return true;
 822                 }
 823 };
 824
 825 /**
 826  APPR (command)
 827  %status maybe
 828  %pragma variants c1 c2 cv c3
 829
 830  Makes the target Creature approach the IT agent (or if none, an agent of that category using CAs),
 831  blocking until it makes it there or gives up.
 832 */
 833 void caosVM::c_APPR() {
 834         CreatureAgent *a = getTargCreatureAgent();
 835         caos_assert(a);
 836
 837         startBlocking(new blockUntilApproached(targ, _it_));
 838 }
 839
 840 /**
 841  UNCS (command) unconscious (integer)
 842  %status stub
 843
 844  Makes the target Creature conscious if 0, or unconscious if 1.
 845 */
 846 void caosVM::c_UNCS() {
 847         VM_PARAM_INTEGER(unconscious)
 848
 849         Creature *c = getTargCreature();
 850
 851         // TODO
 852 }
 853
 854 /**
 855  UNCS (integer)
 856  %status stub
 857  %pragma variants c2 cv c3
 858
 859  Returns 1 if the target Creature is unconscious, or 0 otherwise.
 860 */
 861 void caosVM::v_UNCS() {
 862         Creature *c = getTargCreature();
 863
 864         result.setInt(0); // TODO
 865 }
 866
 867 /**
 868  FACE (command) number (integer)
 869  %status stub
 870 */
 871 void caosVM::c_FACE() {
 872         VM_PARAM_INTEGER(number)
 873
 874         caos_assert(targ);
 875         SkeletalCreature *c = dynamic_cast<SkeletalCreature *>(targ.get());
 876         caos_assert(c);
 877
 878         // TODO
 879 }
 880
 881 /**
 882  FACE INT (integer)
 883  %status maybe
 884
 885  Returns the front-facing pose for the current facial expression of the target creature.
 886 */
 887 void caosVM::v_FACE_INT() {
 888         caos_assert(targ);
 889         SkeletalCreature *c = dynamic_cast<SkeletalCreature *>(targ.get());
 890         caos_assert(c);
 891
 892         result.setInt(c->getFaceSpriteFrame());
 893 }
 894
 895 /**
 896  FACE STRING (string)
 897  %status maybe
 898
 899  Returns the current sprite filename for the face of the target creature.
 900 */
 901 void caosVM::v_FACE_STRING() {
 902         caos_assert(targ);
 903         SkeletalCreature *c = dynamic_cast<SkeletalCreature *>(targ.get());
 904         caos_assert(c);
 905
 906         result.setString(c->getFaceSpriteName());
 907 }
 908
 909 /**
 910  LIKE (command) creature (agent)
 911  %status stub
 912
 913  Causes the target Creature to state an opinion about the specified Creature.
 914 */
 915 void caosVM::c_LIKE() {
 916         VM_PARAM_VALIDAGENT(creature)
 917
 918         Creature *c = getTargCreature();
 919
 920         // TODO
 921 }
 922
 923 /**
 924  LIMB (string) bodypart (integer) genus (integer) gender (integer) age (integer) variant (integer)
 925  %status stub
 926
 927  Returns the filename for the specified part of a Creature, substituting as necessary.
 928 */
 929 void caosVM::v_LIMB() {
 930         VM_PARAM_INTEGER(variant)
 931         VM_PARAM_INTEGER(age)
 932         VM_PARAM_INTEGER(gender)
 933         VM_PARAM_INTEGER(genus)
 934         VM_PARAM_INTEGER(bodypart)
 935
 936         Creature *c = getTargCreature();
 937
 938         result.setString(""); // TODO
 939 }
 940
 941 /**
 942  ORDR SHOU (command) speech (string)
 943  %status stub
 944
 945  Makes the target Creature speak the specified speech to all creatures in hearing range.
 946 */
 947 void caosVM::c_ORDR_SHOU() {
 948         VM_PARAM_STRING(speech)
 949
 950         valid_agent(targ);
 951         // TODO
 952 }
 953
 954 /**
 955  ORDR SIGN (command) speech (string)
 956  %status stub
 957
 958  Makes the target Creature speak the specified speech to all creatures that can see it.
 959 */
 960 void caosVM::c_ORDR_SIGN() {
 961         VM_PARAM_STRING(speech)
 962
 963         valid_agent(targ);
 964         // TODO
 965 }
 966
 967 /**
 968  ORDR TACT (command) speech (string)
 969  %status stub
 970
 971  Makes the target Creature speak the specified speech to all creatures that are touching it.
 972 */
 973 void caosVM::c_ORDR_TACT() {
 974         VM_PARAM_STRING(speech)
 975
 976         valid_agent(targ);
 977         // TODO
 978 }
 979
 980 /**
 981  ORDR WRIT (command) creature (agent) speech (string)
 982  %status stub
 983
 984  Makes the target Creature speak the specified speech to the specified creature.
 985 */
 986 void caosVM::c_ORDR_WRIT() {
 987         VM_PARAM_STRING(speech)
 988         VM_PARAM_VALIDAGENT(creature)
 989
 990         valid_agent(targ);
 991         // TODO
 992 }
 993
 994 /**
 995  DREA (command) dream (integer)
 996  %status maybe
 997
 998  Turns a Creature's dreaming on and off.  A Creature's instincts are
 999  processed while it is dreaming.  If it is not asleep already, then it
1000  will be made to sleep before dreaming begins.
1001 */
1002 void caosVM::c_DREA() {
1003         VM_PARAM_INTEGER(dream)
1004
1005         Creature *c = getTargCreature();
1006         c->setDreaming(dream);
1007 }
1008
1009 /**
1010  DREA (integer)
1011  %status maybe
1012
1013  Returns whether or not the target Creature is dreaming (0 or 1).
1014 */
1015 void caosVM::v_DREA() {
1016         Creature *c = getTargCreature();
1017         result.setInt(c->isDreaming());
1018 }
1019
1020 /**
1021  BORN (command)
1022  %status maybe
1023
1024  Registers the birth of the target Creature, and sends a birth event to
1025  the game.
1026 */
1027 void caosVM::c_BORN() {
1028         Creature *c = getTargCreature();
1029         c->born();
1030 }
1031
1032 /**
1033  CAGE (integer)
1034  %status maybe
1035  %pragma variants c1 c2 cv c3
1036
1037  Returns the integer value of the target Creature's current life stage.
1038 */
1039 void caosVM::v_CAGE() {
1040         Creature *c = getTargCreature();
1041         result.setInt((int)c->getStage());
1042 }
1043
1044 /**
1045  BYIT (integer)
1046  %status maybe
1047
1048  Determines whether or not the target Creature can reach the IT agent (0
1049  or 1).
1050 */
1051 void caosVM::v_BYIT() {
1052         Creature *c = getTargCreature();
1053
1054         if (_it_ && agentsTouching(targ, _it_)) // TODO
1055                 result.setInt(1);
1056         else
1057                 result.setInt(0);
1058 }
1059
1060 /**
1061  _IT_ (agent)
1062  %status maybe
1063  %pragma implementation caosVM::v_IT
1064  %pragma variants c1 c2 cv c3
1065
1066  Returns the agent that the OWNR creature was focused on when the
1067  current script began running.
1068 */
1069 void caosVM::v_IT() {
1070         valid_agent(owner);
1071         caos_assert(dynamic_cast<CreatureAgent *>(owner.get())); // TODO: return null instead?
1072         result.setAgent(_it_);
1073 }
1074
1075 /**
1076  NEWC (command) family (integer) gene_agent (agent) gene_slot (integer) sex (integer) variant (integer)
1077  %status maybe
1078
1079  Creates a new creature over the space of a few ticks, using the specified agent/slot for genetic data. sex is 0 for random, 1 for male or 2 for female.
1080 */
1081 void caosVM::c_NEWC() {
1082         VM_PARAM_INTEGER(variant)
1083         VM_PARAM_INTEGER(sex)
1084         VM_PARAM_INTEGER(gene_slot)
1085         VM_PARAM_VALIDAGENT(gene_agent)
1086         VM_PARAM_INTEGER(family)
1087
1088         // TODO: creation should be blocking and multiple-tick!
1089
1090         std::map<unsigned int, shared_ptr<class genomeFile> >::iterator i = gene_agent->slots.find(gene_slot);
1091         caos_assert(i != gene_agent->slots.end());
1092
1093         // randomise sex if necessary
1094         if (sex == 0) sex = 1 + (int) (2.0 * (rand() / (RAND_MAX + 1.0)));
1095         caos_assert(sex == 1 || sex == 2); // TODO: correct?
1096
1097         // TODO: if variant is 0, randomise between 1 and 8
1098         SkeletalCreature *a = new SkeletalCreature(family);
1099         try {
1100                 c2eCreature *c = new c2eCreature(i->second, (sex == 2), variant, a);
1101                 a->setCreature(c);
1102         } catch (...) {
1103                 delete a;
1104                 throw;
1105         }
1106
1107         a->finishInit();
1108
1109         world.history.getMoniker(world.history.findMoniker(i->second)).moveToCreature(a);
1110         i->second.reset(); // TODO: remove the slot from the gene_agent entirely
1111
1112         setTarg(a);
1113 }
1114
1115 /**
1116  NEW: CREA (command) family (integer) gene_agent (agent) gene_slot (integer) sex (integer) variant (integer)
1117  %status stub
1118
1119  Creates a new creature using the specified agent/slot for genetic data. sex is 0 for random, 1 for male or 2 for female.
1120 */
1121 void caosVM::c_NEW_CREA() {
1122         /*VM_PARAM_INTEGER(variant)
1123         VM_PARAM_INTEGER(sex)
1124         VM_PARAM_INTEGER(gene_slot)
1125         VM_PARAM_VALIDAGENT(gene_agent)
1126         VM_PARAM_INTEGER(family)*/
1127
1128         c_NEWC(); // TODO
1129         //targ = NULL; // TODO
1130 }
1131
1132 /**
1133  NEW: CREA (command) moniker (integer) sex (integer)
1134  %status maybe
1135  %pragma variants c1 c2
1136  %pragma implementation caosVM::c_NEW_CREA_c1
1137
1138  Creates a new creature using the specified moniker for genetic data. sex is 0 for random, 1 for male or 2 for female.
1139 */
1140 void caosVM::c_NEW_CREA_c1() {
1141         VM_PARAM_INTEGER(sex)
1142         VM_PARAM_INTEGER(moniker)
1143
1144         caos_assert(moniker != 0);
1145
1146         std::string realmoniker = std::string((char *)&moniker, 4);
1147         shared_ptr<genomeFile> genome = world.loadGenome(realmoniker);
1148         if (!genome)
1149                 throw creaturesException("failed to find genome file '" + realmoniker + '"');
1150
1151         caos_assert(genome->getVersion() == engine.version);
1152
1153         // randomise sex if necessary
1154         if (sex == 0) sex = 1 + (int) (2.0 * (rand() / (RAND_MAX + 1.0)));
1155         caos_assert(sex == 1 || sex == 2); // TODO: correct?
1156
1157         SkeletalCreature *a = new SkeletalCreature(4);
1158
1159         // TODO: why do we even need to pass a variant here?
1160         oldCreature *c;
1161
1162         try {
1163                 if (engine.version == 1) c = new c1Creature(genome, (sex == 2), 0, a);
1164                 else c = new c2Creature(genome, (sex == 2), 0, a);
1165         } catch (...) {
1166                 delete a;
1167                 throw;
1168         }
1169
1170         a->setCreature(c);
1171         a->finishInit();
1172
1173         a->slots[0] = genome;
1174         world.newMoniker(genome, realmoniker, a);
1175         world.history.getMoniker(world.history.findMoniker(genome)).moveToCreature(a);
1176
1177         setTarg(a);
1178 }
1179
1180 int calculateRand(int value1, int value2); // caosVM_variables.cpp
1181
1182 /**
1183  LTCY (command) action (integer) min (integer) max (integer)
1184  %status maybe
1185  %pragma variants c1 c2 cv c3
1186 */
1187 void caosVM::c_LTCY() {
1188         VM_PARAM_INTEGER(max); caos_assert(max >= 0 && max <= 255);
1189         VM_PARAM_INTEGER(min); caos_assert(min >= 0 && min <= 255);
1190         VM_PARAM_INTEGER(action);
1191
1192         int n = calculateRand(min, max);
1193
1194         Creature *c = getTargCreature();
1195
1196         c2eCreature *c2ec = dynamic_cast<c2eCreature *>(c);
1197         if (c2ec) {
1198                 c2ec->setInvolActionLatency(action, n);
1199         }
1200
1201         // TODO: ltcy support for c1/c2
1202 }
1203
1204 /**
1205  F**K (command)
1206  %status stub
1207  %pragma variants c1
1208  %pragma implementation caosVM::c_MATE
1209 */
1210
1211 /**
1212  MATE (command)
1213  %pragma variants c2 cv c3
1214  %status stub
1215 */
1216 void caosVM::c_MATE() {
1217         Creature *c = getTargCreature();
1218         caos_assert(_it_);
1219         CreatureAgent *t = dynamic_cast<CreatureAgent *>(_it_.get());
1220         caos_assert(t);
1221         Creature *d = t->getCreature();
1222
1223         // TODO
1224 }
1225
1226 /**
1227  DRV! (integer)
1228  %status stub
1229  %pragma implementation caosVM::v_DRV
1230  %pragma variants c1 c2 cv c3
1231 */
1232 void caosVM::v_DRV() {
1233         Creature *c = getTargCreature();
1234         result.setInt(0); // TODO
1235 }
1236
1237 /**
1238  IITT (agent)
1239  %status maybe
1240
1241  Return the agent which the target creature is currently focused on. Note that you should probably use _IT_ in creature scripts.
1242 */
1243 void caosVM::v_IITT() {
1244         Creature *c = getTargCreature();
1245         result.setAgent(c->getAttentionFocus());
1246 }
1247
1248 /**
1249  AGES (command) times (integer)
1250  %status maybe
1251
1252  Age (ie, increase the life stage of) the target creature the specified number of times.
1253 */
1254 void caosVM::c_AGES() {
1255         VM_PARAM_INTEGER(times)
1256         caos_assert(times >= 0);
1257
1258         Creature *c = getTargCreature();
1259         for (int i = 0; i < times; i++) {
1260                 c->ageCreature();
1261         }
1262 }
1263
1264 /**
1265  LOCI (command) type (integer) organ (integer) tissue (integer) id (integer) value (float)
1266  %status maybe
1267
1268  Set the value of the specified loci of the target creature. 'type' is 0 for receptor loci and 1 for emitter loci.
1269  See genetics documentation for details of the parameters.
1270 */
1271 void caosVM::c_LOCI() {
1272         VM_PARAM_FLOAT(value)
1273         VM_PARAM_INTEGER(id)
1274         VM_PARAM_INTEGER(tissue)
1275         VM_PARAM_INTEGER(organ)
1276         VM_PARAM_INTEGER(type)
1277
1278         c2eCreature *c = getc2eCreature(targ.get());
1279
1280         float *f = c->getLocusPointer(!type, organ, tissue, id);
1281         caos_assert(f);
1282         *f = value;
1283 }
1284
1285 /**
1286  LOCI (float) type (integer) organ (integer) tissue (integer) id (integer)
1287  %status maybe
1288
1289  Return the current value of the specified loci of the target creature. 'type' is 0 for receptor loci and 1 for emitter loci.
1290  See genetics documentation for details of thei parameters.
1291 */
1292 void caosVM::v_LOCI() {
1293         VM_PARAM_INTEGER(id)
1294         VM_PARAM_INTEGER(tissue)
1295         VM_PARAM_INTEGER(organ)
1296         VM_PARAM_INTEGER(type)
1297
1298         c2eCreature *c = getc2eCreature(targ.get());
1299
1300         float *f = c->getLocusPointer(!type, organ, tissue, id);
1301         caos_assert(f);
1302         result.setFloat(*f);
1303 }
1304
1305 /**
1306  TAGE (integer)
1307  %status maybe
1308
1309  Returns age of target creature, in ticks. Only counts ticks since it was BORN.
1310 */
1311 void caosVM::v_TAGE() {
1312         Creature *c = getTargCreature();
1313         result.setInt(c->getAge());
1314 }
1315
1316 /**
1317  ORGN (integer)
1318  %status maybe
1319
1320  Return the number of organs the target creature has.
1321 */
1322 void caosVM::v_ORGN() {
1323         c2eCreature *c = getc2eCreature(targ.get());
1324         result.setInt(c->noOrgans());
1325 }
1326
1327 /**
1328  ORGF (float) organ (integer) value (integer)
1329  %status maybe
1330
1331  Return some data about the specified organ (numbered starting at zero) of the target creature.
1332
1333  value should be one of the following types of data:
1334  0: clock rate
1335  1: short term life force as a proportion of the initial life force
1336  2: repair rate
1337  3: injury to apply
1338  4: initial life force
1339  5: short term life force
1340  6: long term life force
1341  7: damage rate
1342  8: energy cost
1343  9: atp damage coefficient
1344
1345  Returns -1 if the specified organ or value is invalid.
1346 */
1347 void caosVM::v_ORGF() {
1348         VM_PARAM_INTEGER(value)
1349         VM_PARAM_INTEGER(organ)
1350
1351         c2eCreature *c = getc2eCreature(targ.get());
1352         if (organ < 0 || (unsigned int)organ >= c->noOrgans()) {
1353                 result.setFloat(-1.0f);
1354                 return;
1355         }
1356
1357         shared_ptr<c2eOrgan> o = c->getOrgan(organ);
1358
1359         switch (value) {
1360                 case 0: result.setFloat(o->getClockRate()); break;
1361                 case 1: result.setFloat(o->getShortTermLifeforce() / o->getInitialLifeforce()); break;
1362                 case 2: result.setFloat(o->getRepairRate()); break;
1363                 case 3: result.setFloat(o->getInjuryToApply()); break;
1364                 case 4: result.setFloat(o->getInitialLifeforce()); break;
1365                 case 5: result.setFloat(o->getShortTermLifeforce()); break;
1366                 case 6: result.setFloat(o->getLongTermLifeforce()); break;
1367                 case 7: result.setFloat(o->getDamageRate()); break;
1368                 case 8: result.setFloat(o->getEnergyCost()); break;
1369                 case 9: result.setFloat(o->getATPDamageCoefficient()); break;
1370                 default: result.setFloat(-1.0f); break;
1371         }
1372 }
1373
1374 /**
1375  ORGI (integer) organ (integer) value (integer)
1376  %status maybe
1377
1378  Returns a count of receptors (value 0), emitters (value 1) or reactions (value 2) in the specified organ (numbered starting at zero) of the target creature.
1379
1380  Returns -1 if the specified organ or value is invalid.
1381 */
1382 void caosVM::v_ORGI() {
1383         VM_PARAM_INTEGER(value)
1384         VM_PARAM_INTEGER(organ)
1385
1386         c2eCreature *c = getc2eCreature(targ.get());
1387         if (organ < 0 || (unsigned int)organ >= c->noOrgans()) {
1388                 result.setFloat(-1.0f);
1389                 return;
1390         }
1391
1392         shared_ptr<c2eOrgan> o = c->getOrgan(organ);
1393
1394         switch (value) {
1395                 case 0: result.setInt(o->getReceptorCount()); break;
1396                 case 1: result.setInt(o->getEmitterCount()); break;
1397                 case 2: result.setInt(o->getReactionCount()); break;
1398                 default: result.setFloat(-1.0f); break;
1399         }
1400 }
1401
1402 /**
1403  SOUL (command) part (integer) on (integer)
1404  %status stub
1405 */
1406 void caosVM::c_SOUL() {
1407         VM_PARAM_INTEGER(on)
1408         VM_PARAM_INTEGER(part)
1409         caos_assert(part >= 0 && part <= 8);
1410
1411         Creature *c = getTargCreature();
1412         // TODO
1413 }
1414
1415 /**
1416  SOUL (integer) part (integer)
1417  %status stub
1418 */
1419 void caosVM::v_SOUL() {
1420         VM_PARAM_INTEGER(part)
1421         caos_assert(part >= 0 && part <= 8);
1422
1423         Creature *c = getTargCreature();
1424         result.setInt(1); // TODO
1425 }
1426
1427 /**
1428  DECN (integer)
1429  %status maybe
1430 */
1431 void caosVM::v_DECN() {
1432         Creature *c = getTargCreature();
1433         result.setInt(c->getDecisionId());
1434 }
1435
1436 /**
1437  ATTN (integer)
1438  %status maybe
1439 */
1440 void caosVM::v_ATTN() {
1441         Creature *c = getTargCreature();
1442         result.setInt(c->getAttentionId());
1443 }
1444
1445 /**
1446  TOUC (command)
1447  %status stub
1448  %pragma variants c1 c2 cv c3
1449 */
1450 void caosVM::c_TOUC() {
1451         Creature *c = getTargCreature();
1452
1453         // TODO
1454 }
1455
1456 /**
1457  FORF (command) creature (agent)
1458  %status stub
1459 */
1460 void caosVM::c_FORF() {
1461         VM_PARAM_VALIDAGENT(creature)
1462
1463         Creature *c = getTargCreature();
1464         // TODO: do we handle pointer as well?
1465         Creature *learn = dynamic_cast<Creature *>(creature.get());
1466         if (!learn) return;
1467
1468         // TODO
1469 }
1470
1471 /**
1472  WALK (command)
1473  %status maybe
1474  %pragma variants c1 c2 cv c3
1475 */
1476 void caosVM::c_WALK() {
1477         CreatureAgent *c = getTargCreatureAgent();
1478
1479         c->startWalking();
1480 }
1481
1482 /**
1483  DONE (command)
1484  %status stub
1485  %pragma variants c1 c2 cv c3
1486 */
1487 void caosVM::c_DONE() {
1488         Creature *c = getTargCreature();
1489
1490         // TODO
1491 }
1492
1493 /**
1494  SAYN (command)
1495  %status stub
1496  %pragma variants c1 c2 cv c3
1497 */
1498 void caosVM::c_SAYN() {
1499         Creature *c = getTargCreature();
1500
1501         // TODO
1502 }
1503
1504 /**
1505  IMPT (command) nudge (integer)
1506  %status stub
1507  %pragma variants c1 c2
1508 */
1509 void caosVM::c_IMPT() {
1510         VM_PARAM_INTEGER(nudge)
1511
1512         // TODO: check for creature targ?
1513         // TODO
1514 }
1515
1516 /**
1517  AIM: (command) actionno (integer)
1518  %status stub
1519  %pragma variants c1 c2
1520 */
1521 void caosVM::c_AIM() {
1522         VM_PARAM_INTEGER(actionno)
1523
1524         // TODO: check for creature targ? who knows?
1525         // TODO
1526 }
1527
1528 /**
1529  BABY (variable)
1530  %status maybe
1531  %pragma variants c1 c2
1532 */
1533 CAOS_LVALUE_TARG_SIMPLE(BABY, targ->babymoniker); // TODO
1534
1535 /**
1536  SNEZ (command)
1537  %status stub
1538  %pragma variants c1 c2
1539 */
1540 void caosVM::c_SNEZ() {
1541         Creature *c = getTargCreature();
1542
1543         // TODO
1544 }
1545
1546 /**
1547  DRIV (integer) drive (integer)
1548  %status maybe
1549  %pragma variants c1 c2
1550  %pragma implementation caosVM::v_DRIV_c1
1551
1552  Returns the value for the specified drive of the target creature.
1553 */
1554 void caosVM::v_DRIV_c1() {
1555         VM_PARAM_INTEGER(drive)
1556         caos_assert(drive < 16);
1557
1558         oldCreature *c = getoldCreature(targ.get());
1559         // TODO: c2 support
1560         caos_assert(c);
1561
1562         result.setInt(c->getDrive(drive));
1563 }
1564
1565 /**
1566  DREA (command) max (integer)
1567  %status stub
1568  %pragma variants c1 c2
1569  %pragma implementation caosVM::c_DREA_c1
1570
1571  Start dreaming and process (at most?) max instincts.
1572 */
1573 void caosVM::c_DREA_c1() {
1574         VM_PARAM_INTEGER(max)
1575
1576         oldCreature *c = getoldCreature(targ.get());
1577         caos_assert(c);
1578
1579         // TODO
1580 }
1581
1582 /**
1583  BRED (integer) part (integer)
1584  %status stub
1585 */
1586 void caosVM::v_BRED() {
1587         VM_PARAM_INTEGER(part)
1588
1589         result.setInt(0); // TODO
1590 }
1591
1592 /**
1593  BVAR (integer)
1594  %status stub
1595 */
1596 void caosVM::v_BVAR() {
1597         result.setInt(0); // TODO
1598 }
1599
1600 /**
1601  EXPR (command) index (integer) ticks (integer)
1602  %status stub
1603 */
1604 void caosVM::c_EXPR() {
1605         VM_PARAM_INTEGER(ticks)
1606         VM_PARAM_INTEGER(index)
1607
1608         // TODO
1609 }
1610
1611 /**
1612  EXPR (integer)
1613  %status stub
1614 */
1615 void caosVM::v_EXPR() {
1616         result.setInt(0); // TODO
1617 }
1618
1619 /**
1620  TNTC (command) tintindex (integer) part (integer) commit (integer)
1621  %status stub
1622 */
1623 void caosVM::c_TNTC() {
1624         VM_PARAM_INTEGER(commit)
1625         VM_PARAM_INTEGER(part)
1626         VM_PARAM_INTEGER(tintindex)
1627
1628         // TODO
1629 }
1630
1631 /**
1632  INJR (command) organ (integer) amount (integer)
1633  %status stub
1634  %pragma variants c2
1635 */
1636 void caosVM::c_INJR() {
1637         VM_PARAM_INTEGER(amount)
1638         VM_PARAM_INTEGER(organ)
1639
1640         valid_agent(targ);
1641         // TODO
1642 }
1643
1644 /**
1645  SAY$ (command) string (string)
1646  %status stub
1647  %pragma variants c1
1648 */
1649 void caosVM::c_SAY() {
1650         VM_PARAM_STRING(string)
1651
1652         valid_agent(targ);
1653         // TODO
1654 }
1655
1656 /**
1657  TRIG (command) lobe (integer) cell (integer) amount (integer)
1658  %status stub
1659  %pragma variants c2
1660 */
1661 void caosVM::c_TRIG() {
1662         VM_PARAM_INTEGER(amount)
1663         VM_PARAM_INTEGER(cell)
1664         VM_PARAM_INTEGER(lobe)
1665
1666         valid_agent(targ);
1667         // TODO
1668 }
1669
1670 /**
1671  MONK (integer)
1672  %status stub
1673  %pragma variants c2
1674 */
1675 void caosVM::v_MONK() {
1676         oldCreature *c = getoldCreature(targ.get());
1677         caos_assert(c);
1678
1679         result.setInt(0); // TODO
1680 }
1681
1682 // clothes
1683
1684 /**
1685  BODY (command) set (integer) layer (integer)
1686  %status stub
1687 */
1688 void caosVM::c_BODY() {
1689         VM_PARAM_INTEGER(layer)
1690         VM_PARAM_INTEGER(set)
1691
1692         // TODO
1693 }
1694
1695 /**
1696  BODY (integer) part (integer)
1697  %status stub
1698 */
1699 void caosVM::v_BODY() {
1700         VM_PARAM_INTEGER(part)
1701
1702         result.setInt(-1); // TODO
1703 }
1704
1705 /**
1706  DYED (command) part (integer) overlay (integer) set (integer) layer (integer)
1707  %status stub
1708 */
1709 void caosVM::c_DYED() {
1710         VM_PARAM_INTEGER(layer)
1711         VM_PARAM_INTEGER(set)
1712         VM_PARAM_INTEGER(overlay)
1713         VM_PARAM_INTEGER(part)
1714
1715         // TODO
1716 }
1717
1718 /**
1719  HAIR (command) ruffleness (integer)
1720  %status stub
1721 */
1722 void caosVM::c_HAIR() {
1723         VM_PARAM_INTEGER(ruffleness)
1724
1725         // TODO
1726 }
1727
1728 /**
1729  NUDE (command)
1730  %status stub
1731 */
1732 void caosVM::c_NUDE() {
1733         // TODO
1734 }
1735
1736 /**
1737  RSET (command)
1738  %status stub
1739 */
1740 void caosVM::c_RSET() {
1741         // TODO
1742 }
1743
1744 /**
1745  STRE (command)
1746  %status stub
1747 */
1748 void caosVM::c_STRE() {
1749         // TODO
1750 }
1751
1752 /**
1753  SWAP (command) variant (integer) part (integer) commit (integer)
1754  %status stub
1755 */
1756 void caosVM::c_SWAP() {
1757         VM_PARAM_INTEGER(commit)
1758         VM_PARAM_INTEGER(part)
1759         VM_PARAM_INTEGER(variant)
1760
1761         // TODO
1762 }
1763
1764 /**
1765  WEAR (command) part (integer) set (integer) layer (integer)
1766  %status stub
1767 */
1768 void caosVM::c_WEAR() {
1769         VM_PARAM_INTEGER(layer)
1770         VM_PARAM_INTEGER(set)
1771         VM_PARAM_INTEGER(part)
1772
1773         // TODO
1774 }
1775
1776 /**
1777  WEAR (integer) part (integer) layer (integer)
1778  %status stub
1779 */
1780 void caosVM::v_WEAR() {
1781         VM_PARAM_INTEGER(layer)
1782         VM_PARAM_INTEGER(part)
1783
1784         result.setInt(-1); // TODO
1785 }
1786
1787 /**
1788  TNTO (command) tintindex (integer) part (integer) set (integer) layer (integer)
1789  %status stub
1790 */
1791 void caosVM::c_TNTO() {
1792         VM_PARAM_INTEGER(layer)
1793         VM_PARAM_INTEGER(set)
1794         VM_PARAM_INTEGER(part)
1795         VM_PARAM_INTEGER(tintindex)
1796
1797         // TODO
1798 }
1799
1800 // attachment locations
1801
1802 /**
1803  DFTX (float)
1804  %status stub
1805 */
1806 void caosVM::v_DFTX() {
1807         result.setFloat(0); // TODO
1808 }
1809
1810 /**
1811  DFTY (float)
1812  %status stub
1813 */
1814 void caosVM::v_DFTY() {
1815         result.setFloat(0); // TODO
1816 }
1817
1818 /**
1819  UFTX (float)
1820  %status stub
1821 */
1822 void caosVM::v_UFTX() {
1823         result.setFloat(0); // TODO
1824 }
1825
1826 /**
1827  UFTY (float)
1828  %status stub
1829 */
1830 void caosVM::v_UFTY() {
1831         result.setFloat(0); // TODO
1832 }
1833
1834 /**
1835  HEDX (float) index (integer)
1836  %status stub
1837 */
1838 void caosVM::v_HEDX() {
1839         VM_PARAM_INTEGER(index)
1840
1841         result.setFloat(0); // TODO
1842 }
1843
1844 /**
1845  HEDY (float) index (integer)
1846  %status stub
1847 */
1848 void caosVM::v_HEDY() {
1849         VM_PARAM_INTEGER(index)
1850
1851         result.setFloat(0); // TODO
1852 }
1853
1854 /**
1855  MTHX (float)
1856  %status stub
1857 */
1858 void caosVM::v_MTHX() {
1859         result.setFloat(0); // TODO
1860 }
1861
1862 /**
1863  MTHY (float)
1864  %status stub
1865 */
1866 void caosVM::v_MTHY() {
1867         result.setFloat(0); // TODO
1868 }
1869