Creature.h

   1 /*
   2  *  Creature.h
   3  *  openc2e
   4  *
   5  *  Created by Alyssa Milburn on Tue May 25 2004.
   6  *  Copyright (c) 2004-2006 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 #ifndef __CREATURE_H
  21 #define __CREATURE_H
  22
  23 #include "Agent.h"
  24 #include "genome.h"
  25
  26 #include <deque>
  27
  28 class CreatureAgent;
  29 class Creature;
  30
  31 class Creature {
  32 protected:
  33         CreatureAgent *parent;
  34         shared_ptr<genomeFile> genome;
  35
  36         // non-specific bits
  37         unsigned short genus;
  38         unsigned int variant;
  39         bool female;
  40
  41         // state
  42         bool alive, asleep, dreaming, tickage;
  43         bool zombie;
  44
  45         unsigned int ticks;
  46         unsigned int age; // in ticks
  47         lifestage stage;
  48
  49         AgentRef attention;
  50         int attn, decn;
  51
  52         std::vector<AgentRef> chosenagents;
  53         bool agentInSight(AgentRef a);
  54         void chooseAgents();
  55         virtual AgentRef selectRepresentativeAgent(int type, std::vector<AgentRef> possibles) { return AgentRef(); } // TODO: make pure virtual?
  56
  57         // linguistic stuff
  58
  59         // to-be-processed instincts
  60         std::deque<creatureInstinctGene *> unprocessedinstincts;
  61
  62         // conscious flag? brain/motor enabled flags? flags for each 'faculty'?
  63
  64         unsigned short tintinfo[5]; // red, green, blue, rotation, swap
  65
  66         virtual void processGenes();
  67         virtual void addGene(gene *);
  68
  69         Creature(shared_ptr<genomeFile> g, bool is_female, unsigned char _variant, CreatureAgent *a);
  70         void finishInit();
  71
  72 public:
  73         virtual ~Creature();
  74         virtual void tick();
  75
  76         virtual void ageCreature();
  77         lifestage getStage() { return stage; }
  78
  79         void setAsleep(bool asleep);
  80         bool isAsleep() { return asleep; }
  81         void setDreaming(bool dreaming);
  82         bool isDreaming() { return dreaming; }
  83         bool isFemale() { return female; }
  84         bool isAlive() { return alive; }
  85         void setZombie(bool z) { zombie = z; }
  86         bool isZombie() { return zombie; }
  87         unsigned int getAge() { return age; }
  88         shared_ptr<genomeFile> getGenome() { return genome; }
  89
  90         unsigned short getGenus() { return genus; }
  91         unsigned int getVariant() { return variant; }
  92         unsigned short getTint(unsigned int id) { return tintinfo[id]; }
  93
  94         AgentRef getAttentionFocus() { return attention; }
  95         int getAttentionId() { return attn; }
  96         int getDecisionId() { return decn; }
  97
  98         virtual unsigned int getGait() = 0;
  99
 100         void born();
 101         void die();
 102
 103         bool shouldProcessGene(gene *);
 104 };
 105
 106 // c1/c2
 107
 108 class oldCreature : public Creature {
 109 protected:
 110         // biochemistry
 111         unsigned char chemicals[256];
 112
 113         class oldBrain *brain;
 114
 115         unsigned int biochemticks;
 116         bioHalfLivesGene *halflives;
 117
 118         // loci
 119         unsigned char floatingloci[8];
 120         unsigned char muscleenergy;
 121         unsigned char lifestageloci[7];
 122         unsigned char fertile, receptive, pregnant;
 123         unsigned char dead;
 124         unsigned char involaction[8];
 125
 126         void addGene(gene *);
 127         void tickBrain();
 128         virtual void tickBiochemistry();
 129
 130         inline unsigned int calculateTickMask(unsigned char);
 131         inline unsigned int calculateMultiplier(unsigned char);
 132
 133         oldCreature(shared_ptr<genomeFile> g, bool is_female, unsigned char _variant, CreatureAgent *a);
 134
 135         void processGenes();
 136
 137 public:
 138         void addChemical(unsigned char id, unsigned char val);
 139         void subChemical(unsigned char id, unsigned char val);
 140         unsigned char getChemical(unsigned char id) { return chemicals[id]; }
 141
 142         // TODO: is it really worth having drives outside oldCreature?
 143         virtual unsigned char getDrive(unsigned int id) = 0;
 144
 145         oldBrain *getBrain() { return brain; }
 146 };
 147
 148 // c1
 149
 150 struct c1Reaction {
 151         bioReactionGene *data;
 152         void init(bioReactionGene *);
 153 };
 154
 155 struct c1Receptor {
 156         bioReceptorGene *data;
 157         unsigned char *locus;
 158         void init(bioReceptorGene *, class c1Creature *);
 159 };
 160
 161 struct c1Emitter {
 162         bioEmitterGene *data;
 163         unsigned char *locus;
 164         void init(bioEmitterGene *, class c1Creature *);
 165 };
 166
 167 class c1Creature : public oldCreature {
 168 protected:
 169         std::vector<shared_ptr<c1Reaction> > reactions;
 170         std::vector<c1Receptor> receptors;
 171         std::vector<c1Emitter> emitters;
 172
 173         // loci
 174         unsigned char senses[6];
 175         unsigned char gaitloci[8];
 176         unsigned char drives[16];
 177
 178         void addGene(gene *);
 179         void tickBiochemistry();
 180         void processReaction(c1Reaction &);
 181         void processEmitter(c1Emitter &);
 182         void processReceptor(c1Receptor &);
 183
 184 public:
 185         c1Creature(shared_ptr<genomeFile> g, bool is_female, unsigned char _variant, CreatureAgent *a);
 186
 187         void tick();
 188
 189         unsigned char getDrive(unsigned int id) { assert(id < 16); return drives[id]; }
 190
 191         unsigned char *getLocusPointer(bool receptor, unsigned char o, unsigned char t, unsigned char l);
 192
 193         unsigned int getGait();
 194 };
 195
 196 // c2
 197
 198 struct c2Reaction {
 199         bioReactionGene *data;
 200         float rate;
 201         unsigned int receptors;
 202         void init(bioReactionGene *);
 203 };
 204
 205 struct c2Receptor {
 206         bioReceptorGene *data;
 207         bool processed;
 208         float lastvalue;
 209         float *locus;
 210         unsigned int *receptors;
 211         float nominal, threshold, gain;
 212         void init(bioReceptorGene *, class c2Organ *, shared_ptr<c2Reaction>);
 213 };
 214
 215 struct c2Emitter {
 216         bioEmitterGene *data;
 217         unsigned char sampletick;
 218         float *locus;
 219         float threshold, gain;
 220         void init(bioEmitterGene *, class c2Organ *);
 221 };
 222
 223
 224 class c2Organ {
 225 protected:
 226         class c2Creature *parent;
 227         organGene *ourGene;
 228
 229         std::vector<shared_ptr<c2Reaction> > reactions;
 230         std::vector<c2Receptor> receptors;
 231         std::vector<c2Emitter> emitters;
 232
 233         // data
 234         unsigned char energycost, atpdamagecoefficient;
 235
 236         // variables
 237         float lifeforce, shorttermlifeforce, longtermlifeforce;
 238
 239         // locuses
 240         unsigned char biotick, damagerate, repairrate, clockrate, injurytoapply;
 241         unsigned int clockratereceptors, repairratereceptors, injuryreceptors;
 242
 243         void processReaction(c2Reaction &);
 244         void processEmitter(c2Emitter &);
 245         void processReceptor(c2Receptor &, bool checkchem);
 246
 247         unsigned char *getLocusPointer(bool receptor, unsigned char o, unsigned char t, unsigned char l, unsigned int **receptors);
 248
 249 public:
 250         c2Organ(c2Creature *p, organGene *g);
 251         void tick();
 252
 253         void processGenes();
 254
 255         unsigned char getClockRate() { return clockrate; }
 256         unsigned char getRepairRate() { return repairrate; }
 257         unsigned char getDamageRate() { return damagerate; }
 258         unsigned char getEnergyCost() { return energycost; }
 259         unsigned char getInjuryToApply() { return injurytoapply; }
 260         float getInitialLifeforce() { return lifeforce; }
 261         float getShortTermLifeforce() { return shorttermlifeforce; }
 262         float getLongTermLifeforce() { return longtermlifeforce; }
 263         unsigned char getATPDamageCoefficient() { return atpdamagecoefficient; }
 264
 265         unsigned int getReceptorCount() { return receptors.size(); }
 266         unsigned int getEmitterCount() { return emitters.size(); }
 267         unsigned int getReactionCount() { return reactions.size(); }
 268
 269         void applyInjury(float);
 270
 271 };
 272
 273 class c2Creature : public oldCreature {
 274 protected:
 275         // biochemistry
 276         std::vector<shared_ptr<c2Organ> > organs;
 277
 278         // loci
 279         unsigned char senses[14];
 280         unsigned char gaitloci[16];
 281         unsigned char drives[17];
 282         unsigned char mutationchance, mutationdegree;
 283
 284         void addGene(gene *);
 285         void tickBiochemistry();
 286         void processGenes();
 287
 288 public:
 289         c2Creature(shared_ptr<genomeFile> g, bool is_female, unsigned char _variant, CreatureAgent *a);
 290
 291         void tick();
 292
 293         unsigned char getDrive(unsigned int id) { assert(id < 17); return drives[id]; }
 294
 295         unsigned char *getLocusPointer(bool receptor, unsigned char o, unsigned char t, unsigned char l);
 296
 297         unsigned int getGait();
 298 };
 299
 300 // c2e
 301
 302 struct c2eReaction {
 303         bioReactionGene *data;
 304         float rate;
 305         unsigned int receptors;
 306         void init(bioReactionGene *);
 307 };
 308
 309 struct c2eReceptor {
 310         bioReceptorGene *data;
 311         bool processed;
 312         float lastvalue;
 313         float *locus;
 314         unsigned int *receptors;
 315         float nominal, threshold, gain;
 316         void init(bioReceptorGene *, class c2eOrgan *, shared_ptr<c2eReaction>);
 317 };
 318
 319 struct c2eEmitter {
 320         bioEmitterGene *data;
 321         unsigned char sampletick;
 322         float *locus;
 323         float threshold, gain;
 324         void init(bioEmitterGene *, class c2eOrgan *);
 325 };
 326
 327 class c2eOrgan {
 328 protected:
 329         friend struct c2eReceptor;
 330         friend struct c2eEmitter;
 331
 332         class c2eCreature *parent;
 333         organGene *ourGene;
 334
 335         std::vector<shared_ptr<c2eReaction> > reactions;
 336         std::vector<c2eReceptor> receptors;
 337         std::vector<c2eEmitter> emitters;
 338
 339         // data
 340         float energycost, atpdamagecoefficient;
 341
 342         // variables
 343         float lifeforce, shorttermlifeforce, longtermlifeforce;
 344
 345         // locuses
 346         float biotick, damagerate, repairrate, clockrate, injurytoapply;
 347         unsigned int clockratereceptors, repairratereceptors, injuryreceptors;
 348
 349         void processReaction(c2eReaction &);
 350         void processEmitter(c2eEmitter &);
 351         void processReceptor(c2eReceptor &, bool checkchem);
 352
 353         float *getLocusPointer(bool receptor, unsigned char o, unsigned char t, unsigned char l, unsigned int **receptors);
 354
 355 public:
 356         c2eOrgan(c2eCreature *p, organGene *g);
 357         void tick();
 358
 359         void processGenes();
 360
 361         float getClockRate() { return clockrate; }
 362         float getRepairRate() { return repairrate; }
 363         float getDamageRate() { return damagerate; }
 364         float getEnergyCost() { return energycost; }
 365         float getInjuryToApply() { return injurytoapply; }
 366         float getInitialLifeforce() { return lifeforce; }
 367         float getShortTermLifeforce() { return shorttermlifeforce; }
 368         float getLongTermLifeforce() { return longtermlifeforce; }
 369         float getATPDamageCoefficient() { return atpdamagecoefficient; }
 370
 371         unsigned int getReceptorCount() { return receptors.size(); }
 372         unsigned int getEmitterCount() { return emitters.size(); }
 373         unsigned int getReactionCount() { return reactions.size(); }
 374
 375         void applyInjury(float);
 376 };
 377
 378 struct c2eStim {
 379         int noun_id;
 380         float noun_amount;
 381         int verb_id;
 382         float verb_amount;
 383
 384         int drive_id[4];
 385         float drive_amount[4];
 386         bool drive_silent[4];
 387
 388         c2eStim() { noun_id = -1; verb_id = -1; drive_id[0] = -1; drive_id[1] = -1; drive_id[2] = -1; drive_id[3] = -1; }
 389         void setupDriveStim(unsigned int num, int id, float amt, bool si) { drive_id[num] = id; drive_amount[num] = amt; drive_silent[num] = si; }
 390 };
 391
 392 class c2eCreature : public Creature {
 393 protected:
 394         // brain config: should possibly be global
 395         std::vector<unsigned int> mappinginfo;
 396
 397         // biochemistry
 398         std::vector<shared_ptr<c2eOrgan> > organs;
 399         float chemicals[256];
 400
 401         // loci
 402         float lifestageloci[7];
 403         float muscleenergy;
 404         float floatingloci[32];
 405         float fertile, pregnant, ovulate, receptive, chanceofmutation, degreeofmutation;
 406         float dead;
 407         float senses[14], involaction[8], gaitloci[16];
 408         float drives[20];
 409
 410         unsigned int involactionlatency[8];
 411
 412         bioHalfLivesGene *halflives;
 413
 414         class c2eBrain *brain;
 415
 416         void tickBrain();
 417         bool processInstinct();
 418         void tickBiochemistry();
 419         void processGenes();
 420         void addGene(gene *);
 421
 422         int reverseMapVerbToNeuron(unsigned int verb);
 423         AgentRef selectRepresentativeAgent(int type, std::vector<AgentRef> possibles);
 424
 425 public:
 426         c2eCreature(shared_ptr<genomeFile> g, bool is_female, unsigned char _variant, CreatureAgent *a);
 427
 428         void tick();
 429
 430         void adjustChemical(unsigned char id, float value);
 431         float getChemical(unsigned char id) { return chemicals[id]; }
 432         void adjustDrive(unsigned int id, float value);
 433         float getDrive(unsigned int id) { assert(id < 20); return drives[id]; }
 434
 435         void setInvolActionLatency(unsigned int id, unsigned int n) { assert(id < 8); involactionlatency[id] = n; }
 436
 437         void handleStimulus(c2eStim &stim);
 438         void handleStimulus(unsigned int id, float strength);
 439
 440         unsigned int noOrgans() { return organs.size(); }
 441         shared_ptr<c2eOrgan> getOrgan(unsigned int i) { assert(i < organs.size()); return organs[i]; }
 442
 443         class c2eBrain *getBrain() { return brain; }
 444
 445         float *getLocusPointer(bool receptor, unsigned char o, unsigned char t, unsigned char l);
 446
 447         unsigned int getGait();
 448 };
 449
 450 #endif
 451
 452 /* vim: set noet: */