00001 00002 00003 #ifndef __world_h__ 00004 #define __world_h__ 00005 00006 00007 #include "virtualMachine.h" 00008 #include "utilities.h" 00009 00010 00011 00012 00014 class entity 00015 : protected program 00016 { 00017 friend class world; 00018 00019 public: 00020 entity( uInt seed, 00021 const energy& e, 00022 const memory& m, 00023 const position& p, 00024 const direction& d ); 00025 00026 ~entity() {} 00027 00028 energy getEnergy() { return m_energy; } 00029 virtual void draw(); 00030 00031 protected: 00032 00034 energy m_energy; 00036 direction m_direction; 00038 position m_position; 00041 processId m_pid; 00042 00043 private: 00044 }; 00045 00046 00048 class tile 00049 { 00050 friend class world; 00051 00052 public: 00053 tile() : m_pEntity(NULL) 00054 , m_cost(0.0f) 00055 , m_energy(0) {} 00056 00057 tile(float cost, energy e); 00058 ~tile() {} 00059 00060 float getCost() { return m_cost; } 00061 00062 protected: 00064 entity* m_pEntity; 00066 float m_cost; 00068 energy m_energy; 00069 00070 private: 00071 }; 00072 00073 00074 00075 class world 00076 : protected virtualMachine 00077 { 00078 public: 00079 world(); 00080 ~world(); 00081 00082 void init(); 00083 00084 instruction addInstruction(instructionPtr instrPtr); 00085 bool replaceInstruction(instruction instr, instructionPtr instrPtr); 00086 uInt getNumInstructions(); 00087 00088 void setMaxThreadsPerProcess(uInt n); 00089 uInt getMaxThreadsPerProcess(); 00090 00091 void setEnergyPerUnitMemory(energy e) { m_energyPerUnitMemory = e; } 00092 energy getEnergyPerUnitMemory() { return m_energyPerUnitMemory; } 00093 00094 void setEnergyPerAbsorb(energy e) { m_absorbAmount = e; } 00095 energy getEnergyPerAbsorb() { return m_absorbAmount; } 00096 00097 void setMaxEnergyPerTile(energy e) { m_maxEnergyPerTile = e; } 00098 void setMaxCostPerTile(float e) { m_maxCostPerTile = e; } 00099 void setMaxEnergyPerEntity(energy e) { m_maxEnergyPerEntity = e; } 00100 void setMaxMemoryPerEntity(memory m) { m_maxMemoryPerEntity = m; } 00101 00102 void step(); 00103 00104 entity* spawnEntity(energy e, memory m, const position& p, const direction& d ); 00105 void kill(entityId entId); 00106 entity* getEntity(entityId entId); 00107 entity* getEntityAtPos(const position& p); 00108 00109 void moveEntity(entity& ent); 00110 void rotateEntityLeft(entity& ent); 00111 void rotateEntityRight(entity& ent); 00112 00113 energy transferEnergy(energy amount, energy& a, energy& b); 00114 energy transferEnergy(energy amount, tile& t, entity& ent); 00115 energy transferEnergy(energy amount, entity& entA, entity& entB); 00116 energy transferEnergy(energy amount, entity& ent); 00117 00118 void absorbEnergy(entity& ent); 00119 energy releaseEnergy(energy amount, entity& ent); 00120 00121 void transferMemory(address addr, program& a, program& b); 00122 void transferMemory(address addr, entity& entA, entity& entB); 00123 void giveMemory(entity& ent, address addr); 00124 void takeMemory(entity& ent, address addr); 00125 00126 void convertEnergyToMemory(entity& ent, energy e); 00127 void convertMemoryToEnergy(entity& ent, address addr); 00128 00129 tile* getTileAtPos(const position& p); 00130 position getPosInfrontOfEntity(entity& ent, uInt d); 00131 00132 virtual void draw(); 00133 00134 bool isDead() { return !activeProcesses(); } 00135 00136 protected: 00137 virtual bool canBeExecuted(process& proc); 00138 virtual void kill(process& proc); 00139 00140 typedef std::vector<tile> v_tiles; 00141 typedef std::vector<v_tiles> vv_tiles; 00142 vv_tiles m_tiles; 00143 vector2i m_size; 00144 00145 energy m_absorbAmount; 00146 energy m_energyPerUnitMemory; 00147 00148 energy m_maxEnergyPerTile; 00149 float m_maxCostPerTile; 00150 00151 energy m_maxEnergyPerEntity; 00152 energy m_maxMemoryPerEntity; 00153 00154 private: 00155 }; 00156 00157 00158 00159 #endif 00160