API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 24th, 2017
69
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 10.41 KB | None | 0 0
raw download clone embed print report
  1.  
  2. /************************************************************************************************************************/
  3.  
  4. constexpr char DEPTH = 3;
  5. constexpr char POOL_SIZE = 50;
  6. constexpr char GENERATIONS = 50;
  7.  
  8. constexpr int MAX_MOVES = 360;
  9. constexpr int THRUST_LIMIT = 300;
  10. constexpr char PLAYERS = 3;
  11. constexpr char CARS_PER_PLAYER = 3;
  12. constexpr char MAX_DATA = 2;
  13.  
  14. class DNA;
  15. class Population;
  16.  
  17.  
  18. class DNA
  19. {
  20. public:
  21. int genes[PLAYERS][DEPTH][MAX_DATA];
  22. float fitness;
  23.  
  24. inline void randomizeGenes(int ourShips){
  25. //srand (time(NULL));
  26. int move = 0;
  27.  
  28. for(int ii = 0;ii < CARS_PER_PLAYER;ii++)
  29. {
  30. for(int i = 0;i < DEPTH;i++)
  31. {
  32. move = rnd(37) * 10;
  33. if(move == 360){
  34. genes[ii][i][0] = -1;
  35. genes[ii][i][1] = 0;
  36. }else{
  37. genes[ii][i][0] = move;
  38. genes[ii][i][1] = 300;
  39. }
  40.  
  41. //cerr << "Gene " << i << " is: " << returnMove(genes[i]) << endl;cerr << "RNG " << rand() % 8 << endl;
  42. }
  43. }
  44.  
  45. }
  46.  
  47. inline void copy(DNA dna){
  48. for(int ii = 0;ii < CARS_PER_PLAYER;ii++)
  49. {
  50. for(int i = 0;i < DEPTH;i++)
  51. {
  52. genes[ii][i][0] = dna.genes[ii][i][0];
  53. genes[ii][i][1] = dna.genes[ii][i][1];
  54. }
  55. }
  56. }
  57.  
  58. void debugDNA(int ourShips){
  59. for(int ii = 0;ii < ourShips;ii++)
  60. {
  61. for(int i = 0;i < DEPTH;i++)
  62. {
  63. cerr << " " << (int)genes[ii][i][0] << " " << (int)genes[ii][i][1] << " | ";
  64. //cerr << "Gene " << i << " is: " << returnMove(genes[i]) << endl;cerr << "RNG " << rand() % 8 << endl;
  65. }
  66. cerr << " & ";
  67. }
  68. cerr << endl;
  69. }
  70.  
  71. inline static Point transformToPoint(int x,int y,int moveN){
  72.  
  73. if(moveN == -1)return NULL_TARGET;
  74.  
  75. int xDir = cosines[moveN];
  76. int yDir = sines[moveN];
  77.  
  78. return Point(x+xDir, y+yDir);
  79. }
  80.  
  81. };
  82.  
  83. class Population
  84. {
  85. public:
  86.  
  87. DNA pool[POOL_SIZE];
  88. DNA bestDNA;
  89.  
  90. inline void debugPop(int ourShips){
  91. for(int i = 0;i < POOL_SIZE;i++)
  92. {
  93. pool[i].debugDNA(ourShips);//cerr << "Gene 1 " << pool[i].dna.genes[0] << endl;
  94. }
  95. }
  96.  
  97. Population()
  98. {
  99.  
  100. }
  101.  
  102. inline void init(int ourShips)
  103. {
  104.  
  105. for(int i = 0;i < POOL_SIZE;i++)
  106. {
  107. pool[i].randomizeGenes(CARS_PER_PLAYER);
  108. //cerr << "Gene 1 " << pool[i].dna.genes[0] << endl;
  109. }
  110.  
  111. }
  112.  
  113. inline DNA findBest()
  114. {
  115. bestDNA = pool[0];
  116.  
  117. for(int i = 1;i < POOL_SIZE;i++)
  118. {
  119. if(pool[i].fitness > bestDNA.fitness) bestDNA = pool[i];
  120. }
  121.  
  122.  
  123.  
  124. return bestDNA;
  125. }
  126.  
  127. };
  128.  
  129. class GA{
  130.  
  131. public:
  132. Population pop,newPop;
  133. int elitismOffset,generations;
  134. const int MAX_PERCENT = 100;
  135. const int crossoverRate = 50;
  136. const int mutationRate = 10;
  137. const int tournamentK = 10;
  138.  
  139. vector<Wreck>wrecksC;
  140. vector<SkillEffect>skillEffectsC;
  141.  
  142. GA(){
  143. elitismOffset = 1;
  144. generations = 0;
  145. }
  146.  
  147. inline void initParams(int eliOffset){
  148. elitismOffset = eliOffset;
  149. generations = 0;
  150. }
  151.  
  152. inline double getFitness(int owner,int round){
  153.  
  154. double fitness = 0;
  155.  
  156. double destroyerScore = 0;
  157. double reaperScore = 0;
  158. double doofScore = 0;
  159.  
  160. double totalDist = 0;
  161. double bestDist = 12000.0;
  162.  
  163. //Destroyer score------------------------------------------------
  164. for(int i = 0;i < tankers.size();i++){
  165. //if(tankers[i]->distance(WATERTOWN) > 6000.0 || tankers[i]->water < 2 )continue;
  166. if(tankers[i]->dead == true)continue;
  167.  
  168. double tempDist = players[owner].getDestroyer()->distance(tankers[i]) / (tankers[i]->water);
  169. if(tempDist < bestDist)bestDist = tempDist;
  170. }
  171.  
  172. destroyerScore += - bestDist / 12000.0;
  173. //destroyerScore += (players[owner].getDestroyer()->destroyedTanks);
  174.  
  175. //Reaper score---------------------------------------------------
  176. bestDist = 12000.0;
  177.  
  178. reaperScore += -players[owner].getReaper()->distance(players[owner].getDestroyer()) / 12000.0;
  179.  
  180. //Doof score-----------------------------------------------------
  181.  
  182. bestDist = 12000.0;
  183.  
  184. doofScore += -bestDist / 12000.0;
  185.  
  186.  
  187. //General Score--------------------------------------------------
  188.  
  189. fitness += players[owner].score * 100.0;
  190. fitness += destroyerScore ;
  191. // fitness += doofScore;
  192. fitness += reaperScore;
  193.  
  194. //for(int i = 0;i < MAX_PLAYERS;i++)if(i != owner)fitness += -(players[owner].score) * 20.0;
  195.  
  196. return fitness;
  197. }
  198.  
  199.  
  200. inline void copyData(){
  201. skillEffectsC.clear();
  202. wrecksC.clear();
  203.  
  204. //cerr<< "LOOTERS" << endl;
  205. for(int i = 0;i < 9;i++){
  206. looters[i]->save();
  207. }
  208.  
  209. //cerr<< "TANKERS" << endl;
  210. for(int i = 0;i < tankers.size();i++){
  211. tankers[i]->save();
  212. }
  213. // cerr << "Saving" << endl;
  214.  
  215. //cerr<< "PLAYERS" << endl;
  216. for(int i = 0;i < MAX_PLAYERS;i++){
  217. players[i].save();
  218. }
  219.  
  220. //cerr<< "WRECKS" << endl;
  221. wrecksC = wrecks;
  222. //cerr<< "SKILLEFFECT" << endl;
  223. skillEffectsC = skillEffects;
  224.  
  225. }
  226.  
  227. inline void copyData2(){
  228.  
  229. wrecks = wrecksC;
  230. skillEffects = skillEffectsC;
  231. for(int i = 0;i < 9;i++){
  232. looters[i]->load();
  233. }
  234. for(int i = 0;i < tankers.size();i++){
  235. tankers[i]->load();
  236. }
  237.  
  238. // cerr << "Loading" << endl;
  239. for(int i = 0;i < MAX_PLAYERS;i++){
  240. players[i].load();
  241. }
  242.  
  243. }
  244.  
  245. inline void evolvePopulation(int owner,DNA dummy[2]){
  246.  
  247. if(generations != 0){
  248. selectionTourny();
  249. // if(rounds > 1)cerr << "2";
  250.  
  251. }
  252.  
  253.  
  254. copyData2();
  255.  
  256.  
  257. int index = 0;
  258.  
  259. for(int i = 0;i < POOL_SIZE;i++)
  260. {
  261.  
  262. pop.pool[i].fitness = 0;
  263.  
  264. for(int rounds = 0;rounds < DEPTH;rounds++){
  265.  
  266. //Assign actions
  267. for(int a = 0;a < 3;a++){
  268.  
  269. if(owner == a){
  270. for(int b = 0;b < 3;b++){
  271.  
  272. looters[players[a].lootersI[b]]->wantedThrustTarget = DNA::transformToPoint(looters[players[a].lootersI[b]]->x,looters[players[a].lootersI[b]]->y,pop.pool[i].genes[b][rounds][0]);
  273. looters[players[a].lootersI[b]]->wantedThrustPower = pop.pool[i].genes[b][rounds][1];
  274. }
  275. }else{
  276. for(int b = 0;b < 3;b++){
  277.  
  278. //cerr << "PLAYER " << a << " DUMMY " << index << " MOVE " << dummy[index].genes[b][rounds][0] << "|" << dummy[index].genes[b][rounds][1] << endl;
  279. looters[players[a].lootersI[b]]->wantedThrustTarget = DNA::transformToPoint(looters[players[a].lootersI[b]]->x,looters[players[a].lootersI[b]]->y,dummy[index].genes[b][rounds][0]);
  280. looters[players[a].lootersI[b]]->wantedThrustPower = dummy[index].genes[b][rounds][1];
  281.  
  282. }
  283.  
  284. index++;
  285. }
  286. }
  287.  
  288. index = 0;
  289.  
  290.  
  291. updateGame(rounds);
  292.  
  293.  
  294.  
  295. }pop.pool[i].fitness += getFitness(owner,rounds);
  296. //Reset simulator
  297. copyData2();
  298.  
  299.  
  300. }
  301.  
  302.  
  303. generations++;
  304. }
  305.  
  306.  
  307.  
  308. inline void mutate(DNA& dna1)
  309. {
  310.  
  311. for(int ii = 0;ii < CARS_PER_PLAYER;ii++)
  312. {
  313. int index1;
  314. int index2;
  315. int firstIndex;
  316. int secondIndex;
  317.  
  318. do
  319. {
  320. index1 = rnd(DEPTH);
  321. index2 = rnd(DEPTH);
  322. }while(index1 == index2);
  323.  
  324. int gene[2] ;
  325. for(int i = 0;i < MAX_DATA;i++)gene[i] = dna1.genes[ii][index1][i];
  326.  
  327. for(int i = 0;i < MAX_DATA;i++)dna1.genes[ii][index1][i] = dna1.genes[ii][index2][i];
  328. for(int i = 0;i < MAX_DATA;i++)dna1.genes[ii][index2][i] = gene[i];
  329. //if(dna1.genes[ii][index2] > MAX_MOVES || dna1.genes[ii][index1] > MAX_MOVES )cerr << "ERROR IN MUTATION GENERATION " << generations << endl;
  330.  
  331. }
  332.  
  333. }
  334.  
  335.  
  336.  
  337. inline void selectionTourny()
  338. {
  339. //srand (time(NULL));
  340.  
  341.  
  342. newPop.pool[0] = pop.findBest();
  343.  
  344. for(int i = elitismOffset;i < POOL_SIZE;i++)
  345. {
  346.  
  347. int index1 = 0;
  348. int index2 = 0;
  349. int firstIndex;
  350. int secondIndex;
  351.  
  352. for(int k = 0;k < tournamentK;k++){
  353.  
  354. do
  355. {
  356. index2 = rnd(POOL_SIZE);
  357. }while(index1 == index2);
  358.  
  359. index1 = pop.pool[index1].fitness > pop.pool[index2].fitness ? index1 : index2;
  360. }
  361.  
  362. firstIndex = index1;
  363.  
  364. for(int k = 0;k < tournamentK;k++){
  365.  
  366. do
  367. {
  368. index2 = rnd(POOL_SIZE);
  369. }while(index1 == index2);
  370.  
  371. index1 = pop.pool[index1].fitness > pop.pool[index2].fitness ? index1 : index2;
  372. }
  373.  
  374. secondIndex = index1;
  375.  
  376. if(rnd(MAX_PERCENT) < crossoverRate)
  377. newPop.pool[i] = crossoverUniform(pop.pool[firstIndex],pop.pool[secondIndex]);
  378. else
  379. newPop.pool[i] = pop.pool[i];
  380.  
  381.  
  382. if(rnd(MAX_PERCENT) < mutationRate)
  383. mutate(newPop.pool[i]);
  384. }
  385.  
  386. for(int i = 0;i < POOL_SIZE;i++)
  387. {
  388. pop.pool[i] = newPop.pool[i];
  389. }
  390. // cerr << "Populated 1" << endl;
  391. for(int i = 0;i < POOL_SIZE;i++)
  392. {
  393. pop.pool[rnd(POOL_SIZE -1) + 1].randomizeGenes(CARS_PER_PLAYER);
  394. }
  395. // cerr << "Populated 2" << endl;
  396. }
  397.  
  398.  
  399.  
  400.  
  401. inline DNA crossoverOnePoint(DNA& dna1,DNA& dna2){
  402. // srand (time(NULL));
  403.  
  404. int limit = DEPTH / 2;
  405.  
  406. DNA newDNA;
  407.  
  408. for(int ii = 0;ii < CARS_PER_PLAYER;ii++)
  409. {
  410. for(int i = 0;i < limit;i++)
  411. {
  412. for(int a = 0;a < MAX_DATA;a++)newDNA.genes[ii][i][a] = dna1.genes[ii][i][a];
  413. for(int a = 0;a < MAX_DATA;a++)newDNA.genes[ii][DEPTH - 1 - i][a] = dna2.genes[ii][DEPTH -1 - i][a];
  414. }
  415. }
  416.  
  417.  
  418.  
  419. return newDNA;
  420. }
  421.  
  422. inline DNA crossoverMultiPoint(DNA& dna1,DNA& dna2){
  423.  
  424. int index1;
  425. int index2;
  426.  
  427. DNA newDNA;
  428.  
  429.  
  430. int threshold = DEPTH > 2 ? 0 : -1;
  431.  
  432. do{
  433. index1 = rnd(DEPTH);
  434. index2 = rnd(DEPTH);
  435. }while((index1 == threshold)||(index2 == threshold)||(index1 == index2));
  436.  
  437. for(int s = 0;s < CARS_PER_PLAYER;s++)
  438. {
  439. for(int i = 0;i < index1;i++){
  440. for(int a = 0;a < MAX_DATA;a++)newDNA.genes[s][i][a] = dna1.genes[s][i][a];
  441. }
  442. }
  443.  
  444. for(int s = 0;s < CARS_PER_PLAYER;s++)
  445. {
  446. for(int i = index1;i < index2;i++){
  447. for(int a = 0;a < MAX_DATA;a++)newDNA.genes[s][i][a] = dna2.genes[s][i][a];
  448. }
  449. }
  450.  
  451. for(int s = 0;s < CARS_PER_PLAYER;s++)
  452. {
  453. for(int i = index2;i < DEPTH;i++){
  454. for(int a = 0;a < MAX_DATA;a++)newDNA.genes[s][i][a] = dna1.genes[s][i][a];
  455. }
  456. }
  457.  
  458. return newDNA;
  459. }
  460.  
  461.  
  462. inline DNA crossoverUniform(DNA& dna1,DNA& dna2){
  463.  
  464. int coin;
  465. DNA newDNA;
  466.  
  467. for(int i = 0;i < DEPTH;i++){
  468.  
  469. coin = rnd(2);
  470.  
  471. for(int s = 0;s < CARS_PER_PLAYER;s++)
  472. {
  473. for(int a = 0;a < MAX_DATA;a++)newDNA.genes[s][i][a] = coin == 0 ? dna1.genes[s][i][a] : dna2.genes[s][i][a]; //if(dna2.genes[s][i] > MAX_MOVES||dna1.genes[s][i] > MAX_MOVES)cerr << "ERROR IN GENERATION CROSSOVER" << generations << endl;
  474. }
  475. }
  476. return newDNA;
  477. }
  478.  
  479. inline void printMoves(DNA dummy){
  480.  
  481.  
  482. }
  483.  
  484. };
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!