/** Handle stolen task */
int handle_stolen_task(struct generic_task_desc * _tweed_top_) {
trace_event(TRACE_SUBSYS_TWEED, TRACE_EVENT_TWEED_WAIT,
GET_THIEF(_tweed_top_)->core_id);
while ((_tweed_top_->balarm & TWEED_TASK_COMPLETE) == 0) {
if (!waiting(_tweed_top_)) {
thread_yield();
}
}
trace_event(TRACE_SUBSYS_TWEED, TRACE_EVENT_TWEED_WAIT_END,
GET_THIEF(_tweed_top_)->core_id); ;
// update bot
set_bot(_tweed_top_);
return 0;
}
int main(void)
{
srand(time(0));
FILE *file;
file = fopen("file.txt","w");
last = 0;
int keypress = 0,h = 0, k = 0,i, px, py, j, food = 50;
long long b = 0, v = 0, a = MAX_AGE;
unsigned short g[MEM_SIZE];
short selected[MEM_SIZE];
bots = (struct bot *)malloc(sizeof(struct bot) * SX * SY);
struct bot **lb = (struct bot **)malloc(sizeof(struct bot *) * SX * SY);
for (i = 0; i < SX * SY; i++) {
lb[i] = NULL;
}
for (j = 0; j < 5000; j++) {
px = rand() % WIDTH;
py = rand() % HEIGHT;
for (i = 0; i < MEM_SIZE; i++) {
g[i] = rand() % 9;
}
set_bot(&bots[last++], py * SX + px, 10000, g, lb, 0);
}
short get = 0, view = 0;
float comp;
char buf[20];
while (!keypress) {
food = 70 - 100 * last / (float)(SX * SY);
++k;
for (i = 0; i < last; i++) {
compute(&bots[i], lb);
}
for (i = 0; i < SX * SY; i++) {
lb[i] = NULL;
}
for (i = 0; i < last; i++) {
if (bots[i].energy > 0 && bots[i].age > 0) {
lb[bots[i].p] = &bots[i];
} else {
bots[i] = bots[--last];
}
if (k % 100 == 0) {
if (bots[i].energy > v
&& bots[i].generation > 20) {
b = i;
v = bots[i].energy;
}
}
}
if (k % 100 == 0) {
for (i = 0; i < MEM_SIZE - 1; i++) {
fprintf(file, "%i, ", bots[b].gcode[i]);
}
fprintf(file, "%i\n", bots[b].gcode[i]);
v = 0;
printf("%i %i %i\n", k / 100, last, food);
}
for (j = 0; rand() % 100 < food; j++) {
px = rand() % WIDTH;
py = rand() % HEIGHT;
for (i = 0; i < MEM_SIZE; i++) {
g[i] = rand() % 9;
}
if (lb[py * SX + px] == NULL)
set_bot(&bots[last++], py * SX + px, 10000, g,
lb, 0);
}
}
return (0);
}
void run(struct bot *b, struct bot **lb)
{
--b->energy;
//printf("%i -> %i\n", b->ptr, b->memory[b->ptr]);
unsigned short ngcode[MEM_SIZE];
int mean, p, index = MEM_SIZE / 2, i;
switch (b->memory[b->ptr]) {
case 1:
b->dir = (b->dir + 1) % 4;
break;
case 2:
b->dir = (b->dir - 1) % 4;
break;
case 3:
switch (b->dir) {
case 0:
if (b->p + 1 < SX * SY && lb[b->p + 1] == NULL) {
lb[b->p] = NULL;
lb[b->p + 1] = b;
b->p = b->p + 1;
}
break;
case 1:
if (b->p - SX >= 0 && lb[b->p - SX] == NULL) {
lb[b->p] = NULL;
lb[b->p - SX] = b;
b->p = b->p - SX;
}
break;
case 2:
if (b->p - 1 >= 0 && lb[b->p - 1] == NULL) {
lb[b->p] = NULL;
lb[b->p - 1] = b;
b->p = b->p - 1;
}
break;
case 3:
if (b->p + SX < SX * SY && lb[b->p + SX] == NULL) {
lb[b->p] = NULL;
lb[b->p + SX] = b;
b->p = b->p + SX;
}
break;
}
break;
case 4:
switch (b->dir) {
case 2:
if (b->p + 1 < SX * SY && lb[b->p + 1] == NULL) {
lb[b->p] = NULL;
lb[b->p + 1] = b;
b->p = b->p + 1;
}
break;
case 3:
if (b->p - SX >= 0 && lb[b->p - SX] == NULL) {
lb[b->p] = NULL;
lb[b->p - SX] = b;
b->p = b->p - SX;
}
break;
case 0:
if (b->p - 1 >= 0 && lb[b->p - 1] == NULL) {
lb[b->p] = NULL;
lb[b->p - 1] = b;
b->p = b->p - 1;
}
break;
case 1:
if (b->p + SX < SX * SY && lb[b->p + SX] == NULL) {
lb[b->p] = NULL;
lb[b->p + SX] = b;
b->p = b->p + SX;
}
break;
}
break;
case 5:
for (i = 0; i < MEM_SIZE; i++) {
ngcode[i] = b->gcode[i];
}
for(i = 0; i < 100; i++){
if (rand() % 1000 > 400)
ngcode[rand() % MEM_SIZE] = rand() % 9;
else
break;
}
switch (b->dir) {
case 0:
if (b->p + 1 < SX * SY && lb[b->p + 1] == NULL) {
lb[b->p + 1] = &bots[last];
set_bot(&bots[last++], b->p + 1,
b->energy / 5.0, ngcode, lb,
b->generation);
b->energy -= b->energy / 5.0;
}
break;
case 1:
if (b->p - SX >= 0 && lb[b->p - SX] == NULL) {
lb[b->p - SX] = &bots[last];
set_bot(&bots[last++], b->p - SX,
b->energy / 5.0, ngcode, lb,
b->generation);
b->energy -= b->energy / 5.0;
}
break;
case 2:
if (b->p - 1 >= 0 && lb[b->p - 1] == NULL) {
lb[b->p - 1] = &bots[last];
set_bot(&bots[last++], b->p - 1,
b->energy / 5.0, ngcode, lb,
b->generation);
b->energy -= b->energy / 5.0;
}
break;
case 3:
if (b->p + SX < SX * SY && lb[b->p + SX] == NULL) {
lb[b->p + SX] = &bots[last];
set_bot(&bots[last++], b->p + SX,
b->energy / 5.0, ngcode, lb,
b->generation);
b->energy -= b->energy / 5.0;
}
break;
}
break;
case 6:
switch (b->dir) {
case 0:
if (b->p + 1 < SX * SY && lb[b->p + 1] != NULL) {
b->energy += lb[b->p + 1]->energy / 2.0;
lb[b->p + 1]->energy /= 2.0;
}
break;
case 1:
if (b->p - SX >= 0 && lb[b->p - SX] != NULL) {
b->energy += lb[b->p - SX]->energy / 2.0;
lb[b->p - SX]->energy /= 2.0;
}
break;
case 2:
if (b->p - 1 >= 0 && lb[b->p - 1] != NULL) {
b->energy += lb[b->p - 1]->energy / 2.0;
lb[b->p - 1]->energy /= 2.0;
}
break;
case 3:
if (b->p + SX < SX * SY && lb[b->p + SX] != NULL) {
b->energy += lb[b->p + SX]->energy / 2.0;
lb[b->p + SX]->energy /= 2.0;
}
break;
}
break;
case 7:
switch (b->dir) {
case 0:
if (b->p + 1 < SX * SY && lb[b->p + 1] != NULL
&& compatible(lb[b->p + 1], b)) {
mean = (b->energy + lb[b->p + 1]->energy) / 2.0;
b->energy = mean;
lb[b->p + 1]->energy = mean;
}
break;
case 1:
if (b->p - SX >= 0 && lb[b->p - SX] != NULL
&& compatible(lb[b->p - SX], b)) {
mean =
(b->energy + lb[b->p - SX]->energy) / 2.0;
b->energy = mean;
lb[b->p - SX]->energy = mean;
}
break;
case 2:
if (b->p - 1 >= 0 && lb[b->p - 1] != NULL
&& compatible(lb[b->p - 1], b)) {
mean = (b->energy + lb[b->p - 1]->energy) / 2.0;
b->energy = mean;
lb[b->p - 1]->energy = mean;
}
break;
case 3:
if (b->p + SX < SX * SY && lb[b->p + SX] != NULL
&& compatible(lb[b->p + SX], b)) {
mean =
(b->energy + lb[b->p + SX]->energy) / 2.0;
b->energy = mean;
lb[b->p + SX]->energy = mean;
}
break;
}
break;
case 8:
switch (b->dir) {
index = rand() % MEM_SIZE;
case 0:
if (b->p + 1 < SX * SY && b->p + SX < SX * SY && lb[b->p + 1] != NULL && lb[b->p + SX] == NULL){
//&& compatible(lb[b->p + 1], b)) {
for(i = 0; i < index; i++){
ngcode[i] = b->gcode[i];
}
for(i = index; i < MEM_SIZE; i++){
ngcode[i] = lb[b->p + 1]->gcode[i];
}
set_bot(&bots[last++], b->p + SX,
b->energy / 5.0 + lb[b->p + 1]->energy / 5.0, ngcode, lb,
b->generation > lb[b->p + 1]->generation ? b->generation:lb[b->p + 1]->generation);
b->energy -= b->energy / 5.0;
lb[b->p + 1]->energy -= lb[b->p + 1]->energy/5.0;
}
break;
case 1:
if (b->p - SX >= 0 && b->p + 1 < SX * SY && lb[b->p - SX] != NULL && lb[b->p + 1] == NULL){
//&& compatible(lb[b->p - SX], b)) {
for(i = 0; i < index; i++){
ngcode[i] = b->gcode[i];
}
for(i = index; i < MEM_SIZE; i++){
ngcode[i] = lb[b->p - SX]->gcode[i];
}
set_bot(&bots[last++], b->p + 1,
b->energy / 5.0 + lb[b->p - SX]->energy / 5.0, ngcode, lb,
b->generation > lb[b->p - SX]->generation ? b->generation:lb[b->p - SX]->generation);
b->energy -= b->energy / 5.0;
lb[b->p - SX]->energy -= lb[b->p - SX]->energy/5.0;
}
break;
case 2:
if (b->p - 1 >= 0 && b->p - SX >= 0 && lb[b->p - 1] != NULL && lb[b->p - SX] == NULL){
//&& compatible(lb[b->p - 1], b)) {
for(i = 0; i < index; i++){
ngcode[i] = b->gcode[i];
}
for(i = index; i < MEM_SIZE; i++){
ngcode[i] = lb[b->p - 1]->gcode[i];
}
set_bot(&bots[last++], b->p - SX,
b->energy / 5.0 + lb[b->p - 1]->energy / 5.0, ngcode, lb,
b->generation > lb[b->p - 1]->generation ? b->generation:lb[b->p - 1]->generation);
b->energy -= b->energy / 5.0;
lb[b->p - 1]->energy -= lb[b->p - 1]->energy/5.0;
}
break;
case 3:
if (b->p + SX < SX * SY && b->p - 1 >= 0 && lb[b->p + SX] != NULL && lb[b->p - 1] == NULL){
//&& compatible(lb[b->p + SX], b)) {
for(i = 0; i < index; i++){
ngcode[i] = b->gcode[i];
}
for(i = index; i < MEM_SIZE; i++){
ngcode[i] = lb[b->p + SX]->gcode[i];
}
set_bot(&bots[last++], b->p - 1,
b->energy / 5.0 + lb[b->p + SX]->energy / 5.0, ngcode, lb,
b->generation > lb[b->p + SX]->generation ? b->generation:lb[b->p + SX]->generation);
b->energy -= b->energy / 5.0;
lb[b->p + SX]->energy -= lb[b->p + SX]->energy/5.0;
}
break;
}
break;
}
}
int main(void)
{
srand(time(0));
FILE *file;
file = fopen("data.txt", "a+");
SDL_Surface *screen;
SDL_Event event;
last = 0;
float total_energy_sum = 0;
int keypress = 0, k = 0, i, position, j, food = 10, dr = 0, dg = 0, db = 0, depth = 0;
long long b = 0, v = 0;
struct bot *atual_dad;
if (SDL_Init(SDL_INIT_VIDEO) < 0)
return 1;
if (!(screen = SDL_SetVideoMode(WIDTH, HEIGHT, DEPTH, SDL_HWSURFACE))) {
SDL_Quit();
return 1;
}
short selected[MEM_SIZE];
bots = (struct bot *)malloc(sizeof(struct bot) * SX * SY);
struct bot **lb = (struct bot **)malloc(sizeof(struct bot *) * SX * SY);
for (i = 0; i < SX * SY; i++) {
lb[i] = NULL;
}
short g[MEM_SIZE];//{
//7, 4, 8, 0, 2, 7, 0, 9, 4, 2, 9, 6, 2, 4, 4, 2, 9, 3, 2, 7, 2, 0, 2, 0, 3, 4, 6, 2, 2, 2, 2, 1, 8, 0, 2, 8, 8, 5, 9, 2, 9, 6, 7, 5, 8, 8, 6, 9, 2, 8
//7, 6, 8, 8, 7, 3, 3, 9, 4, 4, 9, 6, 8, 0, 6, 4, 9, 2, 2, 6, 9, 6, 2, 0, 3, 4, 6, 7, 2, 2, 2, 1, 8, 0, 9, 8, 5, 5, 7, 2, 9, 6, 8, 0, 8, 6, 6, 9, 9, 9
//-1, -1, 3, 7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 11, 51, 55, 5, 63, 67, 71, 75, 79, 83, 87, 91, 95, 13, 9, 107, 111, 115, 3, 123, 127, 131, 135, 139, 143, 147, 13, 155, 8, 163, 167, 171, 175, 179, 183, 187, 191, 195, 199, 203, 207, 211, 215, 219, 223, 227, 231, 235, 239, 243, 247, 251, 255, 259, 263, 267, 271, 275, 279, 283, 287, 291, 295, 299, 303, 307, 311, 315, 13, 323, 327, 331, 335, 339, 343, 347, 351, 355, 359, 363, 367, 6, 375, 9, 383, 387, 391, 6, 3, 7, 14, 13, 9, 13, 6, 3, 0, 10, 0, 4, 12, 13, 12, 12, 2, 8, 12, 14, 15, 1, 6, 2, 0, 1, 12, 12, 4, 16, 1, 7, 11, 6, 11, 4, 10, 0, 15, 10, 11, 15, 14, 14, 2, 9, 0, 4, 9, 13, 1, 15, 14, 7, 0, 5, 16, 12, 8, 12, 16, 0, 10, 2, 6, 5, 14, 0, 5, 12, 10, 7, 1, 8, 4, 3, 8, 5, 15, 0, 9, 16, 7, 14, 15, 16, 10, 5, 2, 5, 0, 2, 1, 11, 12, 15, 7, 9, 15
//};
//for (i = 0; i < 0; i++)
// set_bot(&bots[last++], NULL, rand() % (SX * SY), 1000, g, lb, 0);
short get = 0, view = 0;
float comp;
while (!keypress) {
++k;
for (i = 0; i < last; i++) {
compute(&bots[i], lb);
switch (view) {
case 0:
setpixel(screen, bots[i].p % SX, bots[i].p / SX % SY, bots[i].r, bots[i].g, bots[i].b);
break;
case 1:
setpixel(screen, bots[i].p % SX, bots[i].p / SX % SY, bots[i].energy, bots[i].energy / 10.0, bots[i].energy / 100.0);
break;
case 2:
setpixel(screen, bots[i].p % SX, bots[i].p / SX % SY, bots[i].age / MAX_AGE * 255, bots[i].age / MAX_AGE * 255, bots[i].age / MAX_AGE * 255);
break;
case 3:
if (bots[i].generation > 2)
setpixel(screen, bots[i].p % SX, bots[i].p / SX % SY, bots[i].generation / 100.0, bots[i].generation / 100.0, bots[i].generation / 100.0);
break;
case 4:
if (bots[i].generation > 1)
setpixel(screen, bots[i].p % SX, bots[i].p / SX % SY, bots[i].r, bots[i].g, bots[i].b);
break;
case 5:
if (selected != NULL) {
comp = compatibility(selected, &bots[i]) * 255;
setpixel(screen, bots[i].p % SX, bots[i].p / SX % SY, comp, comp, comp);
}
break;
}
}
for(i = 0; i < SX * SY; i++){
lb[i] = NULL;
}
total_energy_sum = 0;
for (i = 0; i < last; i++) {
if (bots[i].energy > 0 && bots[i].age > 0) {
lb[bots[i].p] = &bots[i];
total_energy_sum += bots[i].energy;
} else {
lb[bots[i].p] = NULL;
bots[i] = bots[--last];
}
if (k % 10 == 0) {
if (bots[i].energy > v && bots[i].generation > 20) {
b = i;
v = bots[i].energy;
}
} else if (get) {
dr += bots[i].r;
dg += bots[i].g;
db += bots[i].b;
if (bots[i].energy > v && bots[i].generation > 20) {
b = i;
v = bots[i].energy;
}
}
}
if (get) {
printf("Mean Color -> (%f, %f, %f)\n", dr / (float)last, dg / (float)last, db / (float)last);
dr = 0;
dg = 0;
db = 0;
printf("Atual best cell specification:");
v = 0;
atual_dad = &bots[b];
while(atual_dad != NULL && depth < MAX_GENENARATION_UP_SHOW){
printf("#%i# generations up genoma# ", depth++);
for (i = 0; i < MEM_SIZE - 1; i++) {
printf("%i, ", atual_dad->gcode[i]);
}
printf("%i\n", atual_dad->gcode[MEM_SIZE - 1]);
atual_dad = atual_dad->dad;
}
printf("\n\n");
printf("##################\n");
depth = 0;
get = 0;
}
for (j = 0; rand() % 100 < food; j++) {
position = rand() % (SX * SY);
for (i = 0; i < MEM_SIZE; i++) {
g[i] = rand() % 20;
}
if (lb[position] == NULL)
set_bot(&bots[last++], NULL, position, 10000, g, lb, 0);
}
if (k % 10 == 0) {
for (i = 0; i < MEM_SIZE - 1; i++) {
fprintf(file, "%i, ", bots[b].gcode[i]);
}
fprintf(file, "%i, %i, %f\n", bots[b].gcode[i], last, total_energy_sum);
}
if (view != 6) {
SDL_Flip(screen);
//sprintf(buf ,"%d", k / 100);
//SDL_SaveBMP(screen, buf);
SDL_FillRect(screen, NULL, 0x000000);
}
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_QUIT:
keypress = 1;
break;
case SDL_KEYDOWN:
switch (event.key.keysym.sym) {
case SDLK_g:
get = 1;
break;
case SDLK_v:
view = (view + 1) % 7;
switch (view) {
case 0:
printf("Genetic View\n");
break;
case 1:
printf("Energy View\n");
break;
case 2:
printf("Age View\n");
break;
case 3:
printf("Generation View\n");
break;
case 4:
printf("Filtered Genetic View\n");
break;
case 5:
printf("Compatibility View\n");
break;
case 6:
printf("Don't rendening\n");
SDL_FillRect(screen, NULL, 0x000000);
break;
}
break;
case SDLK_UP:
++food;
printf("More Food -> %i\n", food);
break;
case SDLK_DOWN:
--food;
printf("Less Food -> %i\n", food);
break;
}
break;
case SDL_MOUSEBUTTONDOWN:
if (event.button.button == 1){
if (lb[event.button.x + SX * event.button.y] != NULL) {
v = 0;
atual_dad = lb[event.button.x + SX * event.button.y];
while(atual_dad != NULL && depth < MAX_GENENARATION_UP_SHOW){
printf("#%i# generations up genoma# ", depth++);
if(depth == 1){
for (i = 0; i < MEM_SIZE - 1; i++) {
printf("%X,", atual_dad->gcode[i]);
selected[i] = atual_dad->gcode[i];
}
printf("%X\n", atual_dad->gcode[MEM_SIZE - 1]);
selected[MEM_SIZE - 1] =atual_dad->gcode[MEM_SIZE - 1];
}else{
for (i = 0; i < MEM_SIZE - 1; i++) {
printf("%X,", atual_dad->gcode[i]);
}
printf("%X\n", atual_dad->gcode[MEM_SIZE - 1]);
}
atual_dad = atual_dad->dad;
}
printf("\n\n");
printf("##################\n");
depth = 0;
}
break;
}else if (event.button.button == 3){
if (lb[event.button.x + SX * event.button.y] != NULL) {
v = 0;
atual_dad = lb[event.button.x + SX * event.button.y];
while(atual_dad != NULL && depth < 1){
printf("#%i# generations up genoma# ", depth++);
for (i = 0; i < MEM_SIZE - 1; i++) {
printf("%X,", atual_dad->gcode[i]);
selected[i] = atual_dad->gcode[i];
}
printf("%X\n", atual_dad->gcode[MEM_SIZE - 1]);
selected[MEM_SIZE - 1] =atual_dad->gcode[MEM_SIZE - 1];
atual_dad = atual_dad->dad;
}
printf("\n");
printf("##################\n");
depth = 0;
}
break;
}
}
}
}
return (0);
}
void compute(struct bot *b, struct bot **lb)
{
--b->energy;
short ngcode[MEM_SIZE];
int mean, index = MEM_SIZE / 2, i;
--b->age;
if (b->pos -1 > MEM_SIZE || b->ptr -1 > MEM_SIZE || b->ptr < 0 || b->nl > MAX_LOUPS)
return;
switch (b->gcode[b->pos++]) {
case 1:
b->ptr++;
break;
case 2:
b->ptr--;
break;
case 3:
b->memory[b->ptr]++;
break;
case 4:
b->memory[b->ptr]--;
break;
case 5:
if (b->memory[b->ptr])
b->loops[b->nl] = b->pos;
b->loops_ptr[b->nl++] = b->ptr;
break;
case 6:
if (b->nl && b->memory[b->loops_ptr[b->nl - 1]] <= 0) {
b->pos = b->loops[b->nl - 1];
} else if(b->nl) {
--b->nl;
}
break;
case 7:
switch (b->dir) {
case 0:
if (b->p + 1 < SX * SY && lb[b->p + 1] != NULL) {
if(compatible(lb[b->p + 1], b)){
b->memory[b->ptr] = 2;
} else {
b->memory[b->ptr] = 1;
}
} else {
b->memory[b->ptr] = 0;
}
break;
case 1:
if (b->p - SX >= 0 && lb[b->p - SX] != NULL) {
if(compatible(lb[b->p - SX], b)){
b->memory[b->ptr] = 2;
} else {
b->memory[b->ptr] = 1;
}
} else {
b->memory[b->ptr] = 0;
}
break;
case 2:
if (b->p - 1 >= 0 && lb[b->p - 1] != NULL) {
if(compatible(lb[b->p - 1], b)){
b->memory[b->ptr] = 2;
} else {
b->memory[b->ptr] = 1;
}
} else {
b->memory[b->ptr] = 0;
}
break;
case 3:
if (b->p + SX < SX * SY && lb[b->p + SX] != NULL) {
if(compatible(lb[b->p + SX], b)){
b->memory[b->ptr] = 2;
} else {
b->memory[b->ptr] = 1;
}
} else {
b->memory[b->ptr] = 0;
}
break;
}
break;
case 8:
b->memory[b->ptr] = b->dir;
break;
case 9:
if(b->last_adr < MEM_SIZE)b->new_gcode[ b->last_adr++] = b->memory[b->ptr];
break;
case 19:
if(b->last_adr < MEM_SIZE) b->new_gcode[ b->last_adr++] = b->gcode[b->pos++];
break;
case 10:
switch(b->dir){
case 0:
b->dir = 1;
break;
case 1:
b->dir = 2;
break;
case 2:
b->dir = 3;
break;
case 3:
b->dir = 0;
break;
}
break;
case 11:
switch(b->dir){
case 0:
b->dir = 3;
break;
case 1:
b->dir = 0;
break;
case 2:
b->dir = 1;
break;
case 3:
b->dir = 2;
break;
}
break;
case 12:
//b->energy -= 40;
switch (b->dir) {
case 0:
if (b->p + 1 < SX * SY && lb[b->p + 1] == NULL) {
lb[b->p + 1] = b;
b->p = b->p + 1;
}
break;
case 1:
if (b->p - SX >= 0 && lb[b->p - SX] == NULL) {
lb[b->p - SX] = b;
b->p = b->p - SX;
}
break;
case 2:
if (b->p - 1 >= 0 && lb[b->p - 1] == NULL) {
lb[b->p - 1] = b;
b->p = b->p - 1;
}
break;
case 3:
if (b->p + SX < SX * SY && lb[b->p + SX] == NULL) {
lb[b->p + SX] = b;
b->p = b->p + SX;
}
break;
}
break;
case 13:
//b->energy -= 40;
switch (b->dir) {
case 2:
if (b->p + 1 < SX * SY && lb[b->p + 1] == NULL) {
lb[b->p + 1] = b;
b->p = b->p + 1;
}
break;
case 3:
if (b->p - SX >= 0 && lb[b->p - SX] == NULL) {
lb[b->p - SX] = b;
b->p = b->p - SX;
}
break;
case 0:
if (b->p - 1 >= 0 && lb[b->p - 1] == NULL) {
lb[b->p - 1] = b;
b->p = b->p - 1;
}
break;
case 1:
if (b->p + SX < SX * SY && lb[b->p + SX] == NULL) {
lb[b->p + SX] = b;
b->p = b->p + SX;
}
break;
}
break;
case 14:
for (i = 0; i < MEM_SIZE; i++) {
ngcode[i] = b->gcode[i];
}
for (i = 0; i < 100; i++) {
if (rand() % 1000 < VAR_TAX)
ngcode[rand() % MEM_SIZE] = rand() % 20;
else
break;
}
switch (b->dir) {
case 0:
if (b->p + 1 < SX * SY && lb[b->p + 1] == NULL) {
lb[b->p + 1] = &bots[last];
set_bot(&bots[last++], b, b->p + 1, b->energy / 5.0, ngcode, lb, b->generation);
b->energy -= b->energy / 5.0;
}
break;
case 1:
if (b->p - SX >= 0 && lb[b->p - SX] == NULL) {
lb[b->p - SX] = &bots[last];
set_bot(&bots[last++], b, b->p - SX, b->energy / 5.0, ngcode, lb, b->generation);
b->energy -= b->energy / 5.0;
}
break;
case 2:
if (b->p - 1 >= 0 && lb[b->p - 1] == NULL) {
lb[b->p - 1] = &bots[last];
set_bot(&bots[last++], b, b->p - 1, b->energy / 5.0, ngcode, lb, b->generation);
b->energy -= b->energy / 5.0;
}
break;
case 3:
if (b->p + SX < SX * SY && lb[b->p + SX] == NULL) {
lb[b->p + SX] = &bots[last];
set_bot(&bots[last++], b, b->p + SX, b->energy / 5.0, ngcode, lb, b->generation);
b->energy -= b->energy / 5.0;
}
break;
}
break;
case 15:
switch (b->dir) {
index = rand() % MEM_SIZE;
case 0:
if (b->p + 1 < SX * SY && b->p + SX < SX * SY && lb[b->p + 1] != NULL && lb[b->p + SX] == NULL) {
//&& compatible(lb[b->p + 1], b)) {
for (i = 0; i < index; i++) {
ngcode[i] = b->gcode[i];
}
for (i = index; i < MEM_SIZE; i++) {
ngcode[i] = lb[b->p + 1]->gcode[i];
}
for (i = 0; i < 100; i++) {
if (rand() % 1000 < VAR_TAX)
ngcode[rand() % MEM_SIZE] = rand() % 20;
else
break;
}
//set_bot(&bots[last++], b, b->p + SX, b->energy / 5.0 + lb[b->p + 1]->energy / 5.0, ngcode, lb, b->generation > lb[b->p + 1]->generation ? b->generation : lb[b->p + 1]->generation);
set_bot(&bots[last++], b, b->p + SX, b->energy / 5.0, ngcode, lb, b->generation > lb[b->p + 1]->generation ? b->generation : lb[b->p + 1]->generation);
b->energy -= b->energy / 5.0;
//lb[b->p + 1]->energy -= lb[b->p + 1]->energy / 5.0;
}
break;
case 1:
if (b->p - SX >= 0 && b->p + 1 < SX * SY && lb[b->p - SX] != NULL && lb[b->p + 1] == NULL) {
//&& compatible(lb[b->p - SX], b)) {
for (i = 0; i < index; i++) {
ngcode[i] = b->gcode[i];
}
for (i = index; i < MEM_SIZE; i++) {
ngcode[i] = lb[b->p - SX]->gcode[i];
}
for (i = 0; i < 100; i++) {
if (rand() % 1000 < VAR_TAX)
ngcode[rand() % MEM_SIZE] = rand() % 20;
else
break;
}
//set_bot(&bots[last++], b, b->p + 1, b->energy / 5.0 + lb[b->p - SX]->energy / 5.0, ngcode, lb, b->generation > lb[b->p - SX]->generation ? b->generation : lb[b->p - SX]->generation);
set_bot(&bots[last++], b, b->p + 1, b->energy / 5.0, ngcode, lb, b->generation > lb[b->p - SX]->generation ? b->generation : lb[b->p - SX]->generation);
b->energy -= b->energy / 5.0;
//lb[b->p - SX]->energy -= lb[b->p - SX]->energy / 5.0;
}
break;
case 2:
if (b->p - 1 >= 0 && b->p - SX >= 0 && lb[b->p - 1] != NULL && lb[b->p - SX] == NULL) {
//&& compatible(lb[b->p - 1], b)) {
for (i = 0; i < index; i++) {
ngcode[i] = b->gcode[i];
}
for (i = index; i < MEM_SIZE; i++) {
ngcode[i] = lb[b->p - 1]->gcode[i];
}
for (i = 0; i < 100; i++) {
if (rand() % 1000 < VAR_TAX)
ngcode[rand() % MEM_SIZE] = rand() % 20;
else
break;
}
//set_bot(&bots[last++], b, b->p - SX, b->energy / 5.0 + lb[b->p - 1]->energy / 5.0, ngcode, lb, b->generation > lb[b->p - 1]->generation ? b->generation : lb[b->p - 1]->generation);
set_bot(&bots[last++], b, b->p - SX, b->energy / 5.0 , ngcode, lb, b->generation > lb[b->p - 1]->generation ? b->generation : lb[b->p - 1]->generation);
b->energy -= b->energy / 5.0;
//lb[b->p - 1]->energy -= lb[b->p - 1]->energy / 5.0;
}
break;
case 3:
if (b->p + SX < SX * SY && b->p - 1 >= 0 && lb[b->p + SX] != NULL && lb[b->p - 1] == NULL) {
//&& compatible(lb[b->p + SX], b)) {
for (i = 0; i < index; i++) {
ngcode[i] = b->gcode[i];
}
for (i = index; i < MEM_SIZE; i++) {
ngcode[i] = lb[b->p + SX]->gcode[i];
}
for (i = 0; i < 100; i++) {
if (rand() % 1000 < VAR_TAX)
ngcode[rand() % MEM_SIZE] = rand() % 20;
else
break;
}
//set_bot(&bots[last++], b, b->p - 1, b->energy / 5.0 + lb[b->p + SX]->energy / 5.0, ngcode, lb, b->generation > lb[b->p + SX]->generation ? b->generation : lb[b->p + SX]->generation);
set_bot(&bots[last++], b, b->p - 1, b->energy / 5.0 , ngcode, lb, b->generation > lb[b->p + SX]->generation ? b->generation : lb[b->p + SX]->generation);
b->energy -= b->energy / 5.0;
//lb[b->p + SX]->energy -= lb[b->p + SX]->energy / 5.0;
}
break;
}
break;
case 16:
switch (b->dir) {
case 0:
if (b->p + 1 < SX * SY && lb[b->p + 1] != NULL) {
b->energy += lb[b->p + 1]->energy / 10.0;
lb[b->p + 1]->energy = lb[b->p + 1]->energy / 10.0 * 9;
}
break;
case 1:
if (b->p - SX >= 0 && lb[b->p - SX] != NULL) {
b->energy += lb[b->p - SX]->energy / 10.0;
lb[b->p - SX]->energy = lb[b->p - SX]->energy / 10.0 * 9;
}
break;
case 2:
if (b->p - 1 >= 0 && lb[b->p - 1] != NULL) {
b->energy += lb[b->p - 1]->energy / 10.0;
lb[b->p - 1]->energy = lb[b->p - 1]->energy / 10.0 * 9;
}
break;
case 3:
if (b->p + SX < SX * SY && lb[b->p + SX] != NULL) {
b->energy += lb[b->p + SX]->energy / 10.0;
lb[b->p + SX]->energy = lb[b->p + SX]->energy / 10.0 * 9;
}
break;
}
break;
case 17:
switch (b->dir) {
case 0:
if (b->p + 1 < SX * SY && lb[b->p + 1] != NULL && compatible(lb[b->p + 1], b)) {
mean = (b->energy + lb[b->p + 1]->energy) / 2.0;
b->energy = mean;
lb[b->p + 1]->energy = mean;
}
break;
case 1:
if (b->p - SX >= 0 && lb[b->p - SX] != NULL && compatible(lb[b->p - SX], b)) {
mean = (b->energy + lb[b->p - SX]->energy) / 2.0;
b->energy = mean;
lb[b->p - SX]->energy = mean;
}
break;
case 2:
if (b->p - 1 >= 0 && lb[b->p - 1] != NULL && compatible(lb[b->p - 1], b)) {
mean = (b->energy + lb[b->p - 1]->energy) / 2.0;
b->energy = mean;
lb[b->p - 1]->energy = mean;
}
break;
case 3:
if (b->p + SX < SX * SY && lb[b->p + SX] != NULL && compatible(lb[b->p + SX], b)) {
mean = (b->energy + lb[b->p + SX]->energy) / 2.0;
b->energy = mean;
lb[b->p + SX]->energy = mean;
}
break;
}
break;
case 18:
switch (b->dir) {
case 0:
if (b->p + 1 < SX * SY && lb[b->p + 1] == NULL) {
lb[b->p + 1] = &bots[last];
set_bot(&bots[last++], b, b->p + 1, b->energy / 5.0, b->new_gcode, lb, b->generation);
b->energy -= b->energy / 5.0;
}
break;
case 1:
if (b->p - SX >= 0 && lb[b->p - SX] == NULL) {
lb[b->p - SX] = &bots[last];
set_bot(&bots[last++], b, b->p - SX, b->energy / 5.0, b->new_gcode, lb, b->generation);
b->energy -= b->energy / 5.0;
}
break;
case 2:
if (b->p - 1 >= 0 && lb[b->p - 1] == NULL) {
lb[b->p - 1] = &bots[last];
set_bot(&bots[last++], b, b->p - 1, b->energy / 5.0, b->new_gcode, lb, b->generation);
b->energy -= b->energy / 5.0;
}
break;
case 3:
if (b->p + SX < SX * SY && lb[b->p + SX] == NULL) {
lb[b->p + SX] = &bots[last];
set_bot(&bots[last++], b, b->p + SX, b->energy / 5.0, b->new_gcode, lb, b->generation);
b->energy -= b->energy / 5.0;
}
break;
}
break;
}
//b->memory[b->ptr] = b->memory[b->ptr] % 9;
}
