src/base/modules.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <assert.h>
   5
   6 #include "main.h"
   7 #include "list.h"
   8 #include "tux.h"
   9 #include "shot.h"
  10 #include "modules.h"
  11 #include "arena.h"
  12 #include "arenaFile.h"
  13 #include "proto.h"
  14 #include "shareFunction.h"
  15
  16 #ifndef PUBLIC_SERVER
  17 #include "interface.h"
  18 #include "image.h"
  19 #include "layer.h"
  20 #include "configFile.h"
  21 #endif /* PUBLIC_SERVER */
  22
  23 static export_fce_t export_fce = {
  24 #ifndef PUBLIC_SERVER
  25         .fce_addLayer = addLayer,
  26         .fce_image_get = image_get,
  27 #endif /* PUBLIC_SERVER */
  28         .fce_module_load_dep = module_load_dep,
  29         .fce_share_function_add = share_function_add,
  30         .fce_share_function_get = share_function_get,
  31
  32         .fce_getValue = arena_file_get_value,
  33         .fce_net_multiplayer_get_game_type = net_multiplayer_get_game_type,
  34         .fce_tux_get_proportion = tux_get_proportion,
  35         .fce_tux_set_proportion = tux_set_proportion,
  36         .fce_tux_action = tux_action,
  37
  38         .fce_timer_get_current_time = timer_get_current_time,
  39
  40         .fce_arena_get_current = arena_get_current,
  41         .fce_arena_conflict_space = arena_conflict_space,
  42         .fce_arena_is_free_space = arena_is_free_space,
  43         .fce_arena_find_free_space = arena_find_free_space,
  44
  45         .fce_proto_send_module_server = proto_send_module_server,
  46         .fce_proto_send_del_server = proto_send_del_server,
  47 #ifndef PUBLIC_SERVER
  48         .fce_proto_send_module_client = proto_send_module_client,
  49 #endif /* PUBLIC_SERVER */
  50         .fce_shot_destroy = shot_destroy,
  51         .fce_shot_bound_bombBall = shot_bound_bombBall,
  52         .fce_shot_transform_lasser = shot_transform_lasser
  53 };
  54
  55 static list_t *listModule;
  56 static mod_reg_t mod_reglist;
  57
  58 /* register module as valid */
  59 static mod_reg_t *mod_register(char *name, mod_sym_t *sym)
  60 {
  61         /* alloc and init context */
  62         mod_reg_t *mod = (mod_reg_t *) malloc(sizeof(mod_reg_t));
  63
  64         if (!mod) {
  65                 return 0;
  66         }
  67
  68         mod->name = strdup(name);
  69         mod->sym = sym;
  70
  71         /* add entry into list */
  72         mod->next = &mod_reglist;
  73         mod->prev = mod_reglist.prev;
  74         mod->prev->next = mod;
  75         mod->next->prev = mod;
  76
  77         return mod;
  78 }
  79
  80 /* free all unnecessary memory blocks from module's reglist */
  81 static void mod_destroy()
  82 {
  83         unsigned i;
  84         for (;;) {
  85                 i = 0;
  86
  87                 mod_reg_t *mod;
  88                 for (mod = mod_reglist.next; mod != &mod_reglist; mod = mod->next) {
  89                         /* delete entry from context */
  90                         mod->next->prev = mod->prev;
  91                         mod->prev->next = mod->next;
  92
  93                         free(mod->name);
  94                         free(mod);
  95
  96                         i++;
  97
  98                         break;
  99                 }
 100
 101                 if (!i) {
 102                         break;
 103                 }
 104         }
 105 }
 106
 107 static mod_reg_t *mod_find(char *name)
 108 {
 109         mod_reg_t *mod;
 110         for (mod = mod_reglist.next; mod != &mod_reglist; mod = mod->next) {
 111                 if (!strcmp(mod->name, name)) {
 112                         return mod;
 113                 }
 114         }
 115
 116         return 0;
 117 }
 118
 119 static module_t *newModule(char *name)
 120 {
 121         assert(name != NULL);
 122
 123         mod_reg_t *mod = mod_find(name);
 124
 125         if (!mod) {
 126                 error("Module [%s] is unavailable", name);
 127                 return 0;
 128         }
 129
 130         module_t *ret = malloc(sizeof(module_t));
 131
 132         if (!ret) {
 133                 return 0;
 134         }
 135
 136         ret->name = strdup(name);
 137
 138         if (!ret->name) {
 139                 free(ret);
 140                 return 0;
 141         }
 142
 143         ret->fce_init = mod->sym->init;
 144 #ifndef PUBLIC_SERVER
 145         ret->fce_draw = mod->sym->draw;
 146 #endif /* PUBLIC_SERVER */
 147         ret->fce_event = mod->sym->event;
 148         ret->fce_destroy = mod->sym->destroy;
 149         ret->fce_isConflict = mod->sym->isConflict;
 150         ret->fce_cmd = mod->sym->cmdArena;
 151         ret->fce_recvMsg = mod->sym->recvMsg;
 152
 153         debug("Loading module [%s]", name);
 154
 155         if (ret->fce_init(&export_fce) != 0) {
 156                 error("Unable to load module [%s]", name);
 157                 free(ret->name);
 158                 free(ret);
 159                 return NULL;
 160         }
 161
 162         return ret;
 163 }
 164
 165 static int destroyModule(module_t *p)
 166 {
 167         assert(p != NULL);
 168
 169         debug("Unloading module [%s]", p->name);
 170
 171         p->fce_destroy();
 172
 173         free(p->name);
 174         free(p);
 175
 176         return 0;
 177 }
 178
 179 void module_init()
 180 {
 181         listModule = list_new();
 182         share_function_init();
 183
 184         mod_reglist.next = &mod_reglist;
 185         mod_reglist.prev = &mod_reglist;
 186
 187         mod_register("libmodAI", &modai_sym);
 188         mod_register("libmodWall", &modwall_sym);
 189         mod_register("libmodPipe", &modpipe_sym);
 190         mod_register("libmodMove", &modmove_sym);
 191         mod_register("libmodBasic", &modbasic_sym);
 192         mod_register("libmodTeleport", &modteleport_sym);
 193 }
 194
 195 int isModuleLoaded(char *name)
 196 {
 197         int i;
 198
 199         for (i = 0; i < listModule->count; i++) {
 200                 module_t *this;
 201
 202                 this = (module_t *) listModule->list[i];
 203
 204                 if (strcmp(this->name, name) == 0) {
 205                         return 1;
 206                 }
 207         }
 208
 209         return 0;
 210 }
 211
 212 int module_load(char *name)
 213 {
 214         module_t *module;
 215
 216         if (isModuleLoaded(name)) {
 217                 error("Unable to load already loaded module [%s]", name);
 218                 return -1;
 219         }
 220
 221         module = newModule(name);
 222
 223         if (module == NULL) {
 224                 error("Unable to load module [%s]", name);
 225                 return -1;
 226         }
 227
 228         list_add(listModule, module);
 229
 230         return 0;
 231 }
 232
 233 int module_load_dep(char *name)
 234 {
 235         if (isModuleLoaded(name)) {
 236                 return 0;
 237         }
 238
 239         return module_load(name);
 240 }
 241
 242 void module_cmd(char *s)
 243 {
 244         int i;
 245
 246         for (i = 0; i < listModule->count; i++) {
 247                 module_t *this;
 248
 249                 this = (module_t *) listModule->list[i];
 250                 this->fce_cmd(s);
 251         }
 252 }
 253
 254 #ifndef PUBLIC_SERVER
 255 void module_draw(int x, int y, int w, int h)
 256 {
 257         int i;
 258
 259         for (i = 0; i < listModule->count; i++) {
 260                 module_t *this;
 261
 262                 this = (module_t *) listModule->list[i];
 263                 this->fce_draw(x, y, w, h);
 264         }
 265 }
 266 #endif /* PUBLIC_SERVER */
 267
 268 void module_event()
 269 {
 270         int i;
 271
 272         for (i = 0; i < listModule->count; i++) {
 273                 module_t *this;
 274
 275                 this = (module_t *) listModule->list[i];
 276                 this->fce_event();
 277         }
 278 }
 279
 280 int module_is_conflict(int x, int y, int w, int h)
 281 {
 282         int i;
 283
 284         for (i = 0; i < listModule->count; i++) {
 285                 module_t *this;
 286
 287                 this = (module_t *) listModule->list[i];
 288
 289                 if (this->fce_isConflict(x, y, w, h) == 1) {
 290                         return 1;
 291                 }
 292         }
 293
 294         return 0;
 295 }
 296
 297 int module_recv_msg(char *msg)
 298 {
 299         int i;
 300
 301         for (i = 0; i < listModule->count; i++) {
 302                 module_t *this;
 303
 304                 this = (module_t *) listModule->list[i];
 305                 this->fce_recvMsg(msg);
 306         }
 307
 308         return 0;
 309 }
 310
 311 void module_quit()
 312 {
 313         list_destroy_item(listModule, destroyModule);
 314         share_function_quit();
 315
 316         mod_destroy();
 317 }