self->events = new_array(sizeof(event_t), 20);
self->current_wave = -1;
self->life = 10;
+ self->bits = 0;
if (!self->waves || !self->events) {
uninit_engine(self);
self->current_tick++;
}
+int engine_add_tower(engine_t *self, tower_t *tower) {
+ int x = tower->x;
+ int y = tower->y;
+ if (x < 0 || y < 0)
+ return 0;
+ if (x >= self->map->width || y >= self->map->height)
+ return 0;
+ if (self->map->data[y * self->map->width + x])
+ return 0;
+
+ tower_t **ptr = array_new(self->map->towers);
+ *ptr = tower;
+
+ self->map->data[y * self->map->width + x] = tower2any(tower);
+ return 1;
+}
+
+tower_base_t *setup_tower_base(engine_t *self) {
+ //TODO
+ return NULL;
+}
+
int setup_wave(engine_t *self, int start_tick, int bits) {
wave_t *wave = array_new(self->waves);
if (!wave)
return wave_add_enemy(wave, enemy);
}
+int setup_path(engine_t *self, int x, int y) {
+ if (x < 0 || y < 0)
+ return 0;
+ if (x >= self->map->width || y >= self->map->height)
+ return 0;
+ if (self->map->data[y * self->map->width + x])
+ return 0;
+
+ path_t *loc = array_new(self->map->paths);
+ init_path(loc, x, y);
+ loc->index = self->map->paths->count - 1;
+
+ self->map->data[y * self->map->width + x] = path2any(loc);
+ return 1;
+}
+
enemy_t *last_enemy;
int current_wave;
int life;
+ int bits;
} engine_t;
/**
// will clear events on start!
void engine_tick(engine_t *self);
-int setup_enemy(engine_t *self, enemy_t *enemy);
+int engine_add_tower(engine_t *self, tower_t *tower);
+
+tower_base_t *setup_tower_base(engine_t *self);
int setup_wave(engine_t *self, int start_tick, int bits);
+int setup_enemy(engine_t *self, enemy_t *enemy);
+
+int setup_path(engine_t *self, int x, int y);
+
#endif /* ENGINE_H */
self->CNAME[0] = '!';
if (self->towers) {
- array_loop(self->towers, tower, tower_t*) {
- free_tower(*tower);
+ array_loop(self->towers, ptr, tower_t*) {
+ free_tower(*ptr);
}
}
event_t event;
init_event(&event, FIRE);
- array_loop(self->towers, tower, tower_t) {
+ array_loop(self->towers, ptr, tower_t*) {
+ tower_t *tower = *ptr;
+
tower_rearm(tower);
proj_t *target = tower_fire(tower, current_tick,
self->alive, self->paths);
}
}
-int setup_path(map_t *self, int x, int y) {
- if (x < 0 || y < 0)
- return 0;
- if (x >= self->width || y >= self->height)
- return 0;
- if (self->data[y * self->width + x])
- return 0;
-
- path_t *loc = array_new(self->paths);
- init_path(loc, x, y);
- loc->index = self->paths->count - 1;
-
- self->data[y * self->width + x] = path2any(loc);
- return 1;
-}
-
-int setup_tower(map_t *self, tower_t *tower) {
- int x = tower->x;
- int y = tower->y;
- if (x < 0 || y < 0)
- return 0;
- if (x >= self->width || y >= self->height)
- return 0;
- if (self->data[y * self->width + x])
- return 0;
-
- tower_t **ttt = array_new(self->towers);
- *ttt = tower;
-
- self->data[y * self->width + x] = tower2any(tower);
- return 1;
-}
-
void move(map_t *self, enemy_t *enemy, array_t *events, int reverse) {
int source = enemy->index;
int target = source >= 0 ? source+1 : 0;
void map_hit_1(map_t *self, int current_tick, array_t *events);
-int setup_path(map_t *self, int x, int y);
-
-int setup_tower(map_t *self, tower_t *tower);
-
#endif /* MAP_H */
case FILE404:
fprintf(stderr, "Unknown file(s):\n");
array_loop_i (cmd->data, ptr, char*, i) {
- fprintf(stderr, "%d. \"%s\"\n", (i+1), *ptr);
+ fprintf(stderr, "%zu. \"%s\"\n", (i+1), *ptr);
}
break;
case UNKNOWN:
return 1;
}
- setup_path(map, 0, 0);
- setup_path(map, 1, 0);
- setup_path(map, 2, 0);
- setup_path(map, 3, 0);
- setup_path(map, 3, 1);
- setup_path(map, 3, 2);
- setup_path(map, 4, 2);
- setup_path(map, 5, 2);
+ setup_path(engine, 0, 0);
+ setup_path(engine, 1, 0);
+ setup_path(engine, 2, 0);
+ setup_path(engine, 3, 0);
+ setup_path(engine, 3, 1);
+ setup_path(engine, 3, 2);
+ setup_path(engine, 4, 2);
+ setup_path(engine, 5, 2);
- tower_t *tower = new_tower(2, 1);
- setup_tower(map, tower);
+ tower_base_t base;
+ init_tower_base(&base, 0);
+
+ tower_t *tower = new_tower(&base, 2, 1);
+ // TODO: fix setup_tower_base
+ // TODO: use the tower base array (0 or 1.. instead of base)
+ // TODO: use bits
+ engine_add_tower(engine, tower);
enemy_t *enemy = new_enemy(0, 1);
enemy->speed = 1;
#include "tower.h"
-tower_t *new_tower(int x, int y) {
+tower_t *new_tower(tower_base_t *base, int x, int y) {
tower_t *self = malloc(sizeof(tower_t));
- if (!init_tower(self, x, y)) {
+ if (!init_tower(self, base, x, y)) {
free(self);
self = NULL;
}
return self;
}
-int init_tower(tower_t *self, int x, int y) {
+int init_tower(tower_t *self, tower_base_t *base, int x, int y) {
size_t sz = sizeof(self->CNAME);
strncpy(self->CNAME, "[tower ", sz);
self->CNAME[sz - 2] = ']';
self->CNAME[sz - 1] = '\0';
+ self->base = base;
self->x = x;
self->y = y;
- self->range = 0;
- self->speed = 0;
+ self->lvl_speed = 0;
+ self->lvl_range = 0;
+ self->lvl_range = 0;
+ self->proj_speed = 1;
self->super = 0;
- self->fire_delay = 0;
self->fire_delayed = 0;
init_proj_desc(&self->projectile);
self->CNAME[0] = '!';
}
+int init_tower_base(tower_base_t *self, int type) {
+ self->type = type;
+ self->stats_sz = 0;
+ self->super_cost = 0;
+ self->super_power = 0;
+ memset(self->stats, '\0', sizeof(self->stats));
+ return 1;
+}
+
void tower_rearm(tower_t *self) {
if (self->fire_delayed > 0)
self->fire_delayed--;
proj->desc.damage = 10; // TODO
proj->boom_tick = current_tick + 3; // TODO: compute from speed
- self->fire_delayed = self->fire_delay;
+ self->fire_delayed = self->base->stats[self->lvl_speed].attack;
return proj;
}
#include "cutils/array.h"
#include "proj.h"
+typedef struct {
+ int attack;
+ int speed; // fire_delay in ticks
+ int range;
+ int cost; // upgrade cost in bits
+} tower_lvl_t;
+
+typedef struct {
+ int type; // identify the unique tower type
+ tower_lvl_t stats[6];
+ int stats_sz; // how many are used
+ int super_cost;
+ int super_power;
+} tower_base_t;
+
/**
* @brief bla
*
*/
typedef struct {
char CNAME[10];
+ tower_base_t *base;
int x;
int y;
- int range;
- int speed; // speed of the proj in locs per tick
+ // levels are 0-based
+ int lvl_attack;
+ int lvl_speed; // speed = fire_delay in ticks
+ int lvl_range;
+ int proj_speed; // speed of the proj in locs per tick
int super;
- int fire_delay; // in ticks
int fire_delayed; // in ticks still to wait
+ int cost; // total cost in bits
proj_desc_t projectile;
} tower_t;
/**
* Create a new tower.
*
+ * @param base the type of tower (will NOT be free'd by this object)
* @param x the X coordinate
* @param y the Y coordinate
*
*
* @return a new tower (you must later call `free_tower()`)
*/
-tower_t *new_tower(int x, int y);
+tower_t *new_tower(tower_base_t *base, int x, int y);
/**
* Initialise a new tower.
*
+ * @param base the type of tower (will NOT be free'd by this object)
* @param x the X coordinate
* @param y the Y coordinate
*/
-int init_tower(tower_t *self, int x, int y);
+int init_tower(tower_t *self, tower_base_t *base, int x, int y);
/**
* Free the resources held for the given tower: you must not use it any more.
*/
void uninit_tower(tower_t *self);
+int init_tower_base(tower_base_t *self, int type);
+
void tower_rearm(tower_t *self);
proj_t *tower_fire(tower_t *self, int current_tick, array_t *enemies,
git://git.nikiroo.be / tdef.git / commitdiff