player_t *player_create(void){
player_t *player = malloc(sizeof(player_t));
player->body = body_create();
player->sprite = sprite_create();
player->flashing = 0;
player->body->rect->x = 205;
player->body->rect->y = 128;
player->body->rect->w = 30;
player->body->rect->h = 38;
player->fall_speed = 10.0;
player->fall_accel = 0.35;
player->ground_speed = 4.00;
player->ground_accel = 0.25;
player->ground_decel = 0.25;
player->jump_force = -8.2;
player->jump_brake = -3.0;
player->face_dir = DIR_R;
player->ctrl_dir = DIR_X;
player->move_dir = DIR_X;
return player;
}
void animation_create(animation *ani, void *src, int id) {
sd_animation *sdani = (sd_animation*)src;
// Copy simple stuff
ani->id = id;
ani->start_pos = vec2i_create(sdani->start_x, sdani->start_y);
str_create_from_cstr(&ani->animation_string, sdani->anim_string);
// Copy collision coordinates
vector_create(&ani->collision_coords, sizeof(collision_coord));
collision_coord tmp_coord;
for(int i = 0; i < sdani->col_coord_count; i++) {
tmp_coord.pos = vec2i_create(sdani->col_coord_table[i].x, sdani->col_coord_table[i].y);
tmp_coord.frame_index = sdani->col_coord_table[i].y_ext;
vector_append(&ani->collision_coords, &tmp_coord);
}
// Copy extra strings
vector_create(&ani->extra_strings, sizeof(str));
str tmp_string;
for(int i = 0; i < sdani->extra_string_count; i++) {
str_create_from_cstr(&tmp_string, sdani->extra_strings[i]);
vector_append(&ani->extra_strings, &tmp_string);
// don't str_free tmp_str here because it will free the pointers
// inside it, which vector_append does not copy
}
// Handle sprites
vector_create(&ani->sprites, sizeof(sprite));
sprite tmp_sprite;
for(int i = 0; i < sdani->frame_count; i++) {
sprite_create(&tmp_sprite, (void*)sdani->sprites[i], i);
vector_append(&ani->sprites, &tmp_sprite);
}
}
static void collide_world(sprite_t *this_sprite, int x, int y)
{
sprite_t *s;
s = sprite_create(&explosion,NULL);
sprite_set_pos(s,x,y);
sprite_group_insert(effects_group,s);
sprite_kill(this_sprite);
}
item_t *item_create(void){
item_t *item = malloc(sizeof(item_t));
item->type = 0;
item->body = body_create();
item->sprite = sprite_create();
item->flags = 0;
return item;
}
static void crashing_trigger(sprite_t *s)
{
sprite_t *p;
float v[2] = {0,-20};
p = sprite_create(&blacksmoke,NULL);
sprite_set_pos(p,s->x,s->y);
sprite_set_vel(p,v);
sprite_group_insert(effects_group,p);
create_effect(&fire,s->x,s->y);
}
int main(void)
{
//Create game object
zephyrjc_t *game = zephyrjc_init();
//Init graphics
zephyrjc_init_graphics(game, 640, 480, 32);
//Init keyboard
zephyrjc_keyboard_init(game);
//Create scenario and set as current
scenario_t *test_scenario = scenario_create(game);
zephyrjc_set_current_scenario(game, test_scenario);
//Create an abstract object
object_t *obj = object_create(test_scenario);
//Add transform component to object
component_t *transform = transform_create(obj);
//Add tilemap
component_t *tileengine = tileengine_create(obj);
tilepool_t *tp = create_tilepool("tiles.png", 16, 16, 0, 0, 55, 36);
uint16_t test_array[36][55];
for(int y=0;y<36;y++)
{
for (int x=0;x<55;x++)
{
test_array[y][x] = x+y*55;
}
}
tilemap_t *tilemap = create_tilemap(tp, (uint16_t*) *test_array, 55, 36, 0);
tileengine_t *cte = (tileengine_t*) tileengine;
cte->current_tilemap = tilemap;
cte->source.x = 0;
cte->source.y = 0;
cte->source.w = 640;
cte->source.h = 480;
//Add sprite component to object. Set sprite
sprite_t *sp = (sprite_t*) sprite_create(obj);
spriteBuffer_t *sprite = create_sprite();
load_bmp(sprite, "mario.png");
sprite_set(sp, sprite);
//Start Zephyr Jarlsberg & Chedar engine
zephyrjc_start(game);
return 0;
}
static void collide(sprite_t *this_sprite,
sprite_t *other_sprite,
int x, int y)
{
sprite_t *s;
float n[2];
if (other_sprite->type == &missile)
return;
s = sprite_create(&dsmoke,NULL);
sprite_set_pos(s,x,y);
sprite_get_vel(this_sprite, n);
s->anim_p = ((vangle(n) + 128) & 255)/8 ;
sprite_get_vel(other_sprite,n);
sprite_set_vel(s,n);
sprite_group_insert(effects_group,s);
sprite_kill(this_sprite);
}
void scorekeeper()
{
char cbuf[500];
char cbuf2[40];
sprite_t *s;
int i;
update_teams_score(nbTeams,nbPlayers);
int endOfGame=0;
int maxscore = 0;
/** une équipe atteint le score max**/
for (i = 0; i < nbTeams; i++){
if (teams[i].points>=max_points)
endOfGame=1;
if (teams[i].points>maxscore)
maxscore=teams[i].points;
}
/** le temps est écoulé **/
if (sprite_global.game_clock>timeToStop)
endOfGame=1;
if(endOfGame){
sprintf(cbuf,"Les gagnants sont :\n");
for (i = 0; i < nbTeams; i++){
if(teams[i].points==maxscore){
/*<string-array name="colors">
<item>vert Clair</item>
<item>Rouge</item>
<item>Bleu</item>
<item>Jaune</item>
<item>Turquoise</item>
<item>Violet</item>
<item>Orange</item>
<item>Gris</item>
<item>Vert Foncé</item>
<item>Bleu Foncé</item>
</string-array>*/
switch (i){
case 0:
sprintf(cbuf2," Les Verts Clairs \n");
break;
case 1:
sprintf(cbuf2," Les Rouges \n");
break;
case 2:
sprintf(cbuf2," Les Bleus \n");
break;
case 3:
sprintf(cbuf2," Les Jaunes \n");
break;
case 4:
sprintf(cbuf2," Les Turquoises \n");
break;
case 5:
sprintf(cbuf2," Les Violets \n");
break;
case 6:
sprintf(cbuf2," Les Oranges \n");
break;
case 7:
sprintf(cbuf2," Les Gris \n");
break;
case 8:
sprintf(cbuf2," Les Verts Foncés \n");
break;
case 9:
sprintf(cbuf2," Les Bleus Foncés \n");
break;
default:
break;
}
//sprintf(cbuf2," Team %d\n",i);
strcat(cbuf,cbuf2);
}
}
sprintf(cbuf2,"\n\n %d points\n",maxscore);
strcat(cbuf,cbuf2);
message_time(cbuf,10);
message_time("Starting in 3",1);
message_time("Starting in 2",1);
message_time("Starting in 1",1);
message_time("GO !",1);
init_spawn_delays();
int j;
for (j = 0; j< nbTeams; j++){
teams[j].points=0;
}
for (j = 0; j < playerCount; j++){
players[j].points=0;
sprite_kill(players[j].sprite);
}
timeToStop=sprite_global.game_clock+1000*cfgnum("game.max_duration",60);
return;
}
for (i = 0; i < playerCount; i++)
{
if (!sprite_isvalid(&(players[i].controller->target)))
{
if (!players[i].spawnTimer){
sprite_release(&(players[i].sprite));
sprite_timer_set(&(players[i].spawnTimer),players[i].timeBeforeRespawn);
printf("timer set player %d %d\n", i ,players[i].timeBeforeRespawn );
}else{
if (sprite_timer_finished(players[i].spawnTimer)){
s = sprite_create(players[i].sprite_type,&players[i]);
sprite_aquire(s, &(players[i].sprite));
sprite_aquire(players[i].sprite, &(players[i].controller->target));
assert(sprite_isvalid(&(players[i].controller->target)));
s = players[i].sprite;
sprite_group_insert(mech_group, s);
sprite_set_pos(s, players[i].startpos[0], players[i].startpos[1]);
players[i].spawnTimer=NULL;
}
}
}
}
}
void objects_setup(void)
{
int i, x, y;
sprite_t *sp;
float v[2];
srand(23);
sprite_t *s;
for (i=0;i<nbTeams;i++){
s = sprite_create(&teamicon,&teams[i]);
sprite_set_pos(s,75+100*(i), sprite_global.display->h - 75);
sprite_group_insert(ui_group, s);
}
for (i=0;i<nbTeams;i++){
int x = 190+300*(i%5);
int y = 80;
if (i>4)
y+=400;
s = sprite_create(&teamicon,&teams[i]);
sprite_set_pos(s,x, y);
sprite_group_insert(ui_group_connect, s);
}
/*sp = sprite_create(&bonusmachine);
sprite_group_insert(mech_group,sp);
sprite_set_pos(sp,level.xmax/2,15);*/
/*for (i=0;i<3;i++)
{
sp = sprite_create(&bird);
sprite_group_insert(mech_group,sp);
}*/
/*for (i=0;i<5;i++)
{
sp = sprite_create(&bouncer);
sprite_group_insert(mech_group,sp);
sprite_set_pos(sp,rand() % 700 + 50,rand() % 200 + 100);
}*/
/*sp = sprite_create(&cloud);
sprite_group_insert(foreground_group,sp);
sprite_set_pos(sp,400,70);
v[0] = 15; v[1] = 0;
sprite_set_vel(sp,v);*/
/*sp = sprite_create(&cloud);
sprite_group_insert(foreground_group,sp);
sprite_set_pos(sp,0,150);
v[0] = 10; v[1] = 0;
sprite_set_vel(sp,v);*/
/*sp = sprite_create(&zeppelin);
sprite_group_insert(mech_group,sp);
sprite_set_pos(sp,50,200);*/
/*sp = sprite_create(&airballoon);
sprite_group_insert(mech_group,sp);
sprite_set_pos(sp,100,150);
v[0] = 5; v[1] = 3;
sprite_set_vel(sp,v);*/
/*sp = sprite_create(&cannon);
sprite_group_insert(mech_group,sp);
sprite_set_pos(sp,380,518);*/
}
static void sigget(sprite_t *s, int signal, void *data)
{
float v[2] = {0,0};
sprite_t *p;
float r[2];
int sigabs;
switch(signal)
{
case SIGNAL_CANCONTROL:
*(int *)data = !(s->state & PLANE_CRASHING);
break;
case SIGNAL_DAMAGE:
((mech_sprite_t *)s)->damage += *(int *)data;
((player_t*)s->owner)->damage=(100*((mech_sprite_t *)s)->damage)/hitpoints;
break;
case SIGNAL_LAST_ENNEMI:
((player_t*)s->owner)->lastEnnemi=(player_t*)data;
break;
case SIGNAL_ACCELERATE:
s->state |= PLANE_ACCELERATING;
break;
case -SIGNAL_ACCELERATE:
s->state &= ~PLANE_ACCELERATING;
break;
case SIGNAL_UP:
s->state |= PLANE_UP;
s->state &= ~PLANE_DOWN;
break;
case -SIGNAL_UP:
s->state &= ~PLANE_UP;
break;
case SIGNAL_DOWN:
s->state |= PLANE_DOWN;
s->state &= ~PLANE_UP;
break;
case -SIGNAL_DOWN:
s->state &= ~PLANE_DOWN;
break;
case SIGNAL_FIRE: /* create bullet */
if (sprite_timer_finished(((struct biplane*)s)->gun_timer) &&
!(s->state & PLANE_CRASHING))
{
sound_effect(&sound_gunfire,s->x,s->y);
p = sprite_create(((struct biplane*)s)->bullet_type,s->owner);
//p->owner=s->owner;
sprite_group_insert(bullet_group,p);
r[0] = mech_heading((mech_sprite_t *)s)[0];
r[1] = mech_heading((mech_sprite_t *)s)[1];
vmul(r,21); /* Find start of bullet in clumsy way */
vrot(r,-9);
sprite_set_pos(p,s->x + r[0],s->y + r[1]);
sprite_get_vel(s,v);
vmadd(v,200,mech_heading((mech_sprite_t *)s));
sprite_set_vel(p,v);
/* cannot fire again in some time */
sprite_timer_set(&(((struct biplane*)s)->gun_timer),bullet_delay);
}
break;
case SIGNAL_NUM0: /* create bomb */
if (sprite_timer_finished(((struct biplane*)s)->bomb_timer) &&
(!(s->state & PLANE_CRASHING)) &&
(((struct biplane*)s)->nr_bombs > 0))
{
((struct biplane*)s)->nr_bombs--;
p = sprite_create(&bomb,s->owner);
p->anim_p = s->anim_p;
((mech_sprite_t *)p)->angle = ((mech_sprite_t *)s)->angle;
r[0] = mech_heading((mech_sprite_t *)s)[0];
r[1] = mech_heading((mech_sprite_t *)s)[1];
vmul(r,14);
vrot(r,-80);
sprite_set_pos(p,s->x + r[0],s->y + r[1]);
sprite_get_vel(s,v);
vmadd(v,5,r);
sprite_set_vel(p,v);
sprite_group_insert(bomb_group,p);
sprite_timer_set(&(((struct biplane*)s)->bomb_timer),
bomb_delay);
}
break;
case SIGNAL_NUM1: /* jump ship */
if (sprite_timer_finished(((struct biplane*)s)->bomb_timer) &&
(!(s->state & PLANE_CRASHING)))
{
p = sprite_create(¶chute,NULL);
r[0] = mech_heading((mech_sprite_t *)s)[0];
r[1] = mech_heading((mech_sprite_t *)s)[1];
vmul(r,14);
vrot(r,80);
sprite_set_pos(p,s->x + r[0],s->y + r[1]);
sprite_get_vel(s,v);
vmadd(v,5,r);
sprite_set_vel(p,v);
sprite_group_insert(mech_group,p);
sprite_timer_set(&(((struct biplane*)s)->bomb_timer),bomb_delay);
}
break;
case SIGNAL_KILL:
create_effect(&explosion,s->x,s->y);
sprite_kill(s);
break;
case SIGNAL_ISHARMLESS:
if (s->state & PLANE_CRASHING)
((struct signal_reply *)data)->reply = 1;
break;
case SIGNAL_STATSTRING://TTODO : useless ?
sprintf(data,"%i bombs",((struct biplane*)s)->nr_bombs);
break;
default:
break;
}
}
int main(int argc, char** argv){
printf("hello world\n");
behaviors_init();
log_file_open("log.txt");
if (SDL_Init(SDL_INIT_EVERYTHING) == -1){
printf("%s\n", SDL_GetError());
return 1;
}
printf("sdl init success\n");
SDL_Renderer *renderer = NULL;
SDL_Window *window = NULL;
//Setup our window and renderer
window = SDL_CreateWindow("Stick Fighter", SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
if (window == NULL){
printf("%s\n", SDL_GetError());
return 2;
}
renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
if (renderer == NULL){
printf("%s\n", SDL_GetError());
return 3;
}
SDL_Texture *background1 = NULL;
SDL_Texture *background2 = NULL;
SDL_Texture *image = NULL;
//background = sprite_load_image(renderer, "res/background_rcr.png");
background1 = sprite_load_image(renderer, "res/background_rcr.png");
background2 = sprite_load_image(renderer, "res/background_new.png");
SDL_Texture* backgrounds[2];
backgrounds[0] = background1;
backgrounds[1] = background2;
SDL_Rect bg;
//Query the texture to get its width and height to use
SDL_QueryTexture(background1, NULL, NULL, &bg.w, &bg.h);
float bg_width = bg.w;
float bg_height = bg.h;
float world_width = bg_width / 10;
float world_height = bg_height / 10;
printf("bg_width: %f bg_height: %f world_width: %f world_height: %f\n", bg_width, bg_height, world_width, world_height);
//printf("bg 1: [%p]\n", backgrounds[0]);
//printf("bg 2: [%p]\n", backgrounds[1]);
image = sprite_load_image(renderer, "res/output.png");
//printf("after sprite load image\n");
//load the meta info
char* filename = "res/animation_meta_info.txt";
DArray meta_info;
darray_init(&meta_info);
sprite_load_meta_file(filename, &meta_info);
darray_print(&meta_info);
float interval = 0.0f;
float start = 0.0f;
int quit = 0;
float delay = 1000.0f / FPS;
Sprite* player = sprite_create(PLAYER, WALK, 200, 300, delay, image);
player->x_speed = 0;
player->y_speed = 0;
Sprite* enemy = sprite_create(ENEMY, WALK, 0, 300, delay, image);
enemy->x_speed = 2;
enemy->y_speed = 2;
enemy->advance_frame = 1;
//set white background
SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
pixel_to_world(bg_width, bg_height, world_width, world_height,
enemy->x, enemy->y, &enemy->location->coords->x, &enemy->location->coords->y);
int dest_x = 0;
int dest_y = 0;
//TODO:
//animations for punch and basic kick
//animation for getting hit
//animations for walk left and run left
//2 more ai behaviors
//health bars above units and health stats
//dying animation
//dying logic
//generate enemies off screen and have them walk on to screen
//redo tornado kick and spinning back kick so stick figure is same size
//figure out how to color stick figure without having to make new sprites on sheet...need to make figures white to set modulation
//add rolling punch move
//add game state which keeps track of game state
//add buy moves screen in between levels
//add a generator which generates guys for 100 levels
int i = 0;
while (!quit){
printf("iteration: %i\n", i);
start = SDL_GetTicks();
quit = player_input(player, &meta_info);
//printf("quit: %i\n", quit);
//log_msg(LOG_DEBUG, "after player input: current frame: %i\n", player->current_frame[HIT]);
//pixel location to world location
pixel_to_world(bg_width, bg_height, world_width, world_height,
player->x, player->y, &player->location->coords->x, &player->location->coords->y);
//world location to pixel location
world_to_pixel(bg_width, bg_height, world_width, world_height,
enemy->location->coords->x, enemy->location->coords->y, &dest_x, &dest_y);
//boundry check
boundry_check(SCREEN_WIDTH, SCREEN_HEIGHT, enemy, &meta_info, &dest_x, &dest_y);
//printf("2nd before moveto = enemy x:%i enemy y:%i dest_x:%i dest_y:%i\n", enemy->x, enemy->y, dest_x, dest_y);
//update enemy sprite by sprite's speed
moveto_coordinates(enemy, dest_x, dest_y);
//are we at the original world location in pixel coordinates?
int arrived = within_coordinates(enemy, dest_x, dest_y);
printf("arrived: %i\n", arrived);
if(arrived == 1) {
//wander(enemy);
// we reached last behavior's destination so do new AI behavior
wander_stall_attack(player, enemy, &meta_info, 3);
}
sprite_update_bounding_box(player, &meta_info);
sprite_update_bounding_box(enemy, &meta_info);
//check collision
int collision = sprite_check_collision(player, enemy);
//printf("collision: %i\n", collision);
if(collision) {
sprite_handle_collision(player, enemy, &meta_info);
}
//handle collision
//if animation is an attack then check frame range that triggers a hit
//check if attack animation triggers a hi or low hit
//if sequence of attacks is within delta time then 4th hit triggers a knockdown
//if attack would make health below 0 then it triggers a knockdown
//handle opposite attack from opposing sprite
//if is in attack animation then check frame range for a hit
//update animation frame
sprite_update(player, &meta_info, renderer);
sprite_update(enemy, &meta_info, renderer);
//Rendering
SDL_RenderClear(renderer);
//printf("player->x: %i\n", player->x);
//printf("moving right: %i\n", player->moving_right);
//printf("moving left: %i\n", player->moving_left);
int current_background = 0;
sprite_draw_background(renderer, backgrounds, 2, ¤t_background, player->x, player->moving_right, player->moving_left, &player->scroll);
sprite_draw_health_bar(renderer, player, &meta_info, 100);
sprite_draw_health_bar(renderer, enemy, &meta_info, 100);
//draw sprite
sprite_render_frame(SCREEN_WIDTH, SCREEN_HEIGHT, player, &meta_info, renderer, 0);
sprite_render_frame(bg_width, bg_height, enemy, &meta_info, renderer, 0);
//Update the screen
SDL_RenderPresent(renderer);
interval = SDL_GetTicks() - start;
if(interval > 0) {
//float fps = 1.0f / (interval / 1000.0f);
//printf("%f fps\n", fps);
}
i++;
}
//SDL_Delay(4000);
//Destroy the various items
sprite_destroy(player);
sprite_destroy(enemy);
darray_destroy(&meta_info);
SDL_DestroyTexture(backgrounds[0]);
SDL_DestroyTexture(backgrounds[1]);
SDL_DestroyTexture(image);
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
printf("after destory text rend win\n");
SDL_Quit();
log_file_close();
return 0;
}
