src/modules/modAI.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <assert.h>
   5
   6 #include "main.h"
   7 #include "modules.h"
   8 #include "tux.h"
   9 #include "shot.h"
  10 #include "list.h"
  11 #include "gun.h"
  12 #include "space.h"
  13
  14 #ifndef PUBLIC_SERVER
  15 #include "interface.h"
  16 #include "image.h"
  17 #else
  18 #include "publicServer.h"
  19 #endif
  20
  21 static export_fce_t *export_fce;
  22
  23 typedef struct alternative_struct {
  24         int first;
  25         int route;
  26         int step;
  27         int x, y;
  28 } alternative_t;
  29
  30 static alternative_t *newAlternative(int route, int x, int y)
  31 {
  32         alternative_t *new;
  33
  34         new = malloc(sizeof(alternative_t));
  35         new->first = route;
  36         new->route = route;
  37         new->x = x;
  38         new->y = y;
  39         new->step = 0;
  40
  41         return new;
  42 }
  43
  44 static alternative_t *cloneAlternative(alternative_t *p, int route, int x, int y)
  45 {
  46         alternative_t *new;
  47
  48         assert(p != NULL);
  49
  50         UNUSED(x);
  51         UNUSED(y);
  52
  53         new = newAlternative(route, p->x, p->y);
  54         new->first = p->first;
  55         new->step = p->step;
  56
  57         return new;
  58 }
  59
  60 static void forkAlternative(list_t *list, alternative_t *p, int w, int h)
  61 {
  62         int x, y;
  63
  64         assert(list != NULL);
  65         assert(p != NULL);
  66
  67         x = p->x;
  68         y = p->y;
  69
  70         switch (p->route) {
  71         case TUX_UP:
  72                 list_add(list, cloneAlternative(p, TUX_RIGHT, x + (w + 5), y));
  73                 list_add(list, cloneAlternative(p, TUX_LEFT, x - (w + 5), y));
  74                 break;
  75         case TUX_RIGHT:
  76                 list_add(list, cloneAlternative(p, TUX_UP, x, y - (h + 5)));
  77                 list_add(list, cloneAlternative(p, TUX_DOWN, x, y + (h + 5)));
  78                 break;
  79         case TUX_LEFT:
  80                 list_add(list, cloneAlternative(p, TUX_UP, x, y - (h + 5)));
  81                 list_add(list, cloneAlternative(p, TUX_DOWN, x, y + (h + 5)));
  82                 break;
  83         case TUX_DOWN:
  84                 list_add(list, cloneAlternative(p, TUX_RIGHT, x + (w + 5), y));
  85                 list_add(list, cloneAlternative(p, TUX_LEFT, x - (w + 5), y));
  86                 break;
  87         }
  88
  89 }
  90
  91 static void moveAlternative(alternative_t *p, int offset)
  92 {
  93         assert(p != NULL);
  94
  95         p->step++;
  96
  97         /*printf("move %d %d %d\n", p->x, p->y, p->step);*/
  98
  99         switch (p->route) {
 100         case TUX_UP:
 101                 p->y -= offset;
 102                 break;
 103         case TUX_RIGHT:
 104                 p->x += offset;
 105                 break;
 106         case TUX_LEFT:
 107                 p->x -= offset;
 108                 break;
 109         case TUX_DOWN:
 110                 p->y += offset;
 111                 break;
 112         }
 113 }
 114
 115 static void destroyAlternative(alternative_t *p)
 116 {
 117         assert(p != NULL);
 118         free(p);
 119 }
 120
 121 static void cmd_ai(char *line)
 122 {
 123         UNUSED(line);
 124 }
 125
 126 static int init(export_fce_t *p)
 127 {
 128         export_fce = p;
 129
 130         return 0;
 131 }
 132
 133 #ifndef PUBLIC_SERVER
 134 static int draw(int x, int y, int w, int h)
 135 {
 136         UNUSED(x);
 137         UNUSED(y);
 138         UNUSED(w);
 139         UNUSED(h);
 140
 141         return 0;
 142 }
 143 #endif
 144
 145 static tux_t *findOtherTux(space_t *space)
 146 {
 147         int i;
 148
 149         for (i = 0; i < space_get_count(space); i++) {
 150                 tux_t *thisTux;
 151
 152                 thisTux = space_get_item(space, i);
 153
 154                 if (thisTux->control != TUX_CONTROL_AI) {
 155                         return thisTux;
 156                 }
 157         }
 158
 159         return NULL;
 160 }
 161
 162 static void shotTux(arena_t *arena, tux_t *tux_ai, tux_t *tux_rival)
 163 {
 164         const int limit = 20;
 165         int x_ai, y_ai;
 166         int x_rival, y_rival;
 167         int w, h;
 168
 169         UNUSED(arena);
 170
 171         export_fce->fce_tux_get_proportion(tux_ai, &x_ai, &y_ai, &w, &h);
 172         export_fce->fce_tux_get_proportion(tux_rival, &x_rival, &y_rival, &w, &h);
 173
 174         if (y_rival < y_ai && x_rival > x_ai && x_rival < x_ai + limit) {
 175                 export_fce->fce_tux_action(tux_ai, TUX_UP);
 176                 export_fce->fce_tux_action(tux_ai, TUX_SHOT);
 177         }
 178
 179         if (x_rival > x_ai && y_rival > y_ai && y_rival < y_ai + limit) {
 180                 export_fce->fce_tux_action(tux_ai, TUX_RIGHT);
 181                 export_fce->fce_tux_action(tux_ai, TUX_SHOT);
 182         }
 183
 184         if (x_rival < x_ai && y_rival > y_ai && y_rival < y_ai + limit) {
 185                 export_fce->fce_tux_action(tux_ai, TUX_LEFT);
 186                 export_fce->fce_tux_action(tux_ai, TUX_SHOT);
 187         }
 188
 189         if (y_rival > y_ai && x_rival > x_ai && x_rival < x_ai + limit) {
 190                 export_fce->fce_tux_action(tux_ai, TUX_DOWN);
 191                 export_fce->fce_tux_action(tux_ai, TUX_SHOT);
 192         }
 193 }
 194
 195 static void tux_eventAI(tux_t *tux)
 196 {
 197         arena_t *arena;
 198         tux_t *rivalTux;
 199
 200         list_t *listAlternative;
 201         list_t *listDst;
 202         list_t *listFork;
 203
 204         int x, y, w, h;
 205         int rival_x, rival_y;
 206         int i, my_index;
 207
 208         int countFork = 0;
 209         int countDel = 0;
 210         int countLimit = 0;
 211         int countDo = 0;
 212
 213         export_fce->fce_tux_get_proportion(tux, &x, &y, &w, &h);
 214         /*printf("tux AI %d %d\n", x, y);*/
 215
 216         arena = export_fce->fce_arena_get_current();
 217
 218         rivalTux = findOtherTux(arena->spaceTux);
 219
 220         if (rivalTux == NULL || rivalTux->status != TUX_STATUS_ALIVE) {
 221                 return;
 222         }
 223
 224         listAlternative = list_new();
 225         listDst = list_new();
 226         listFork = list_new();
 227
 228         shotTux(arena, tux, rivalTux);
 229
 230         export_fce->fce_tux_get_proportion(rivalTux, &rival_x, &rival_y, NULL, NULL);
 231         /*printf("tux rival %d %d\n", rival_x, rival_y);*/
 232
 233         list_add(listAlternative, newAlternative(TUX_UP, x, y - (h + 10)));
 234         list_add(listAlternative, newAlternative(TUX_RIGHT, x + (w + 10), y));
 235         list_add(listAlternative, newAlternative(TUX_LEFT, x - (w + 10), y));
 236         list_add(listAlternative, newAlternative(TUX_DOWN, x, y + (h + 10)));
 237
 238         my_index = -1;
 239         while (1) {
 240                 alternative_t *this;
 241
 242                 my_index++;
 243                 if (my_index < 0 || my_index >= listAlternative->count) {
 244
 245                         int j;
 246
 247                         /*printf("listFork->count = %d\n", listFork->count);*/
 248
 249                         for (j = 0; j < listFork->count; j++) {
 250                                 list_add(listAlternative, listFork->list[j]);
 251                         }
 252
 253                         list_do_empty(listFork);
 254
 255                         my_index = 0;
 256                 }
 257
 258                 if (listAlternative->count == 0) {
 259                         break;
 260                 }
 261
 262                 this = (alternative_t *) listAlternative->list[my_index];
 263
 264                 if (++countDo == 100)
 265                         break;
 266
 267                 if (this->step > 100) {
 268                         list_del_item(listAlternative, my_index, destroyAlternative);
 269                         countLimit++;
 270                         my_index--;
 271                         continue;
 272                 }
 273
 274                 moveAlternative(this, w * 2);
 275
 276                 if (export_fce->fce_arena_is_free_space(arena, this->x, this->y, w, h) == 1) {
 277                         forkAlternative(listFork, this, 2 * w, 2 * h);
 278                         countFork++;
 279                         continue;
 280                 }
 281
 282                 if (export_fce->
 283                         fce_arena_conflict_space(this->x, this->y, w, h, rival_x, rival_y, w,
 284                                                           h)) {
 285                         /*printf("this->step = %d\n", this->step);*/
 286
 287                         list_del(listAlternative, my_index);
 288                         list_add(listDst, this);
 289                         my_index--;
 290                         /*continue;*/
 291                         break;
 292                 }
 293
 294                 if (export_fce->fce_arena_is_free_space(arena, this->x, this->y, w, h) == 0) {
 295                         /*forkAlternative(listFork, this, w*2, h*2);*/
 296                         list_del_item(listAlternative, my_index, destroyAlternative);
 297                         my_index--;
 298                         countDel++;
 299
 300                         continue;
 301                 }
 302
 303         }
 304
 305         int minStep = 1000;
 306         int recRoute = 0;
 307
 308         /*printf("------------\n");*/
 309         for (i = 0; i < listDst->count; i++) {
 310                 alternative_t *this;
 311
 312                 this = (alternative_t *) listDst->list[i];
 313
 314                 /*printf("XXX step %d route = %d\n", this->step, this->first);*/
 315                 if (this->step < minStep) {
 316                         minStep = this->step;
 317                         recRoute = this->first;
 318                 }
 319         }
 320
 321         if (recRoute != 0) {
 322                 export_fce->fce_tux_action(tux, recRoute);
 323         }
 324
 325         list_destroy_item(listFork, destroyAlternative);
 326         list_destroy_item(listAlternative, destroyAlternative);
 327         list_destroy_item(listDst, destroyAlternative);
 328 /*
 329         printf("countFork = %d\n", countFork);
 330         printf("countDel = %d\n", countDel);
 331         printf("countLimit = %d\n", countLimit);
 332         printf("countDo = %d\n", countDo);
 333 */
 334 }
 335
 336 static void action_tuxAI(space_t *space, tux_t *tux, void *p)
 337 {
 338         UNUSED(space);
 339         UNUSED(p);
 340
 341         if (tux->control == TUX_CONTROL_AI && tux->status == TUX_STATUS_ALIVE) {
 342                 tux_eventAI(tux);
 343         }
 344 }
 345
 346 static int event()
 347 {
 348         static my_time_t lastEvent = 0;
 349         my_time_t curentTime;
 350         arena_t *arena;
 351         int countTuxAI;
 352         /*int i;*/
 353
 354         if (lastEvent == 0) {
 355                 lastEvent = export_fce->fce_timer_get_current_time();
 356         }
 357
 358         curentTime = export_fce->fce_timer_get_current_time();
 359
 360         if (curentTime - lastEvent < 25) {
 361                 return 0;
 362         }
 363
 364         lastEvent = export_fce->fce_timer_get_current_time();
 365         /*printf("event AI\n");*/
 366
 367         arena = export_fce->fce_arena_get_current();
 368
 369         if (arena == NULL) {
 370                 return 0;
 371         }
 372
 373         countTuxAI = 0;
 374
 375         space_action(arena->spaceTux, action_tuxAI, NULL);
 376 /*
 377         for( i = 0 ; i < arena->spaceTux->list->count ; i++ )
 378         {
 379                 tux_t *thisTux;
 380
 381                 thisTux = arena->spaceTux->list->list[i];
 382
 383                 if( thisTux->control == TUX_CONTROL_AI &&
 384                     thisTux->status == TUX_STATUS_ALIVE )
 385                 {
 386                         tux_event(thisTux);
 387                         countTuxAI = 0;
 388                 }
 389         }
 390 */
 391         return 0;
 392 }
 393
 394 static int isConflict(int x, int y, int w, int h)
 395 {
 396         UNUSED(x);
 397         UNUSED(y);
 398         UNUSED(w);
 399         UNUSED(h);
 400
 401         return 0;
 402 }
 403
 404 static void cmdArena(char *line)
 405 {
 406         if (strncmp(line, "ai", 2) == 0)
 407                 cmd_ai(line);
 408 }
 409
 410 static void recvMsg(char *msg)
 411 {
 412         UNUSED(msg);
 413 }
 414
 415 static int destroy()
 416 {
 417         return 0;
 418 }
 419
 420 mod_sym_t modai_sym =   { &init,
 421 #ifndef PUBLIC_SERVER
 422                           &draw,
 423 #else
 424                           0,
 425 #endif
 426                           &event,
 427                           &isConflict,
 428                           &cmdArena,
 429                           &recvMsg,
 430                           &destroy };