Use clang-format to beautify code.

This commit is contained in:
KikooDX 2021-03-23 14:21:59 +01:00
parent 4ab913dac3
commit 2fb7f1db4f
9 changed files with 559 additions and 471 deletions

7
.clang-format Normal file
View File

@ -0,0 +1,7 @@
BasedOnStyle: LLVM
IndentWidth: 8
UseTab: AlignWithSpaces
BreakBeforeBraces: Linux
AllowShortIfStatementsOnASingleLine: false
IndentCaseLabels: false
ColumnLimit: 80

View File

@ -21,3 +21,5 @@ Pour ouvrir l'éditeur de niveau (Python et Pygame obligatoire).
Pour compiler le jeu (fxsdk + gint obligatoire).
`$ fxsdk build-cg`
Appliquer le formatage au code après vos modifications.
`$ clang-format -style=file -i src/* include*`

1
include/save.h Executable file → Normal file
View File

@ -3,4 +3,3 @@ int loadtime(int idlevel);
void loadfile(void);
void restore(void);
void savetimes(float framelevel, int id_level);

3
include/setlevel.h Executable file → Normal file
View File

@ -1,3 +1,4 @@
void set_level(int id_level, char level[], int *startx, int *starty, char *gravity, int *appear, int *disappear);
void set_level(int id_level, char level[], int *startx, int *starty,
char *gravity, int *appear, int *disappear);
void set_gravity(int id_level, char *default_gravity);
void del_level(char level[]);

75
src/collide.c Executable file → Normal file
View File

@ -1,44 +1,51 @@
#include "collide.h"
#include "define.h"
#define DEAD_COLLISION 3 //make the collision with the deadly block less effective
#define DEAD_COLLISION \
3 // make the collision with the deadly block less effective
char collide(int x, int y, char level[], char block) //detect if player is in a block
char collide(int x, int y, char level[],
char block) // detect if player is in a block
{
if((level[(int)(x/16) + (int)((y + PLAYER_HEIGHT)/16) * 25] == block ||
level[(int)((x + PLAYER_HEIGHT)/16) + (int)((y + PLAYER_HEIGHT)/16) * 25] == block ||
level[(int)(x/16) + (int)((y/16) * 25)] == block ||
level[(int)((x + PLAYER_HEIGHT)/16) + (int)((y/16) * 25)] == block)) return 1;
if ((level[(int)(x / 16) + (int)((y + PLAYER_HEIGHT) / 16) * 25] ==
block ||
level[(int)((x + PLAYER_HEIGHT) / 16) +
(int)((y + PLAYER_HEIGHT) / 16) * 25] == block ||
level[(int)(x / 16) + (int)((y / 16) * 25)] == block ||
level[(int)((x + PLAYER_HEIGHT) / 16) + (int)((y / 16) * 25)] ==
block))
return 1;
return 0;
}
char collide_solid(int x, int y, char level[])
{
return collide(x, y, level, '1')
|| collide(x, y, level, '3')
|| collide(x, y, level, '4')
|| collide(x, y, level, 'c')
|| collide(x, y, level, 'C')
|| collide(x, y, level, 'B')
|| collide(x, y, level, 'i')
|| collide(x, y, level, 'H');
return collide(x, y, level, '1') || collide(x, y, level, '3') ||
collide(x, y, level, '4') || collide(x, y, level, 'c') ||
collide(x, y, level, 'C') || collide(x, y, level, 'B') ||
collide(x, y, level, 'i') || collide(x, y, level, 'H');
}
char collide_dead(int x, int y, char level[])
{
return collide_point(x + DEAD_COLLISION, y + DEAD_COLLISION, level, 'd') ||
collide_point(x + PLAYER_HEIGHT - DEAD_COLLISION, y + DEAD_COLLISION, level, 'd') ||
collide_point(x + DEAD_COLLISION, y + PLAYER_HEIGHT - DEAD_COLLISION, level, 'd') ||
collide_point(x + PLAYER_HEIGHT - DEAD_COLLISION, y + PLAYER_HEIGHT - DEAD_COLLISION, level, 'd') ||
collide_point(x + 1, y + 1, level, 'C') ||
collide_point(x + PLAYER_HEIGHT - 1, y + 1, level, 'C') ||
collide_point(x + 1, y + PLAYER_HEIGHT - 1, level, 'C') ||
collide_point(x + PLAYER_HEIGHT - 1, y + PLAYER_HEIGHT - 1, level, 'C');
return collide_point(x + DEAD_COLLISION, y + DEAD_COLLISION, level,
'd') ||
collide_point(x + PLAYER_HEIGHT - DEAD_COLLISION,
y + DEAD_COLLISION, level, 'd') ||
collide_point(x + DEAD_COLLISION,
y + PLAYER_HEIGHT - DEAD_COLLISION, level, 'd') ||
collide_point(x + PLAYER_HEIGHT - DEAD_COLLISION,
y + PLAYER_HEIGHT - DEAD_COLLISION, level, 'd') ||
collide_point(x + 1, y + 1, level, 'C') ||
collide_point(x + PLAYER_HEIGHT - 1, y + 1, level, 'C') ||
collide_point(x + 1, y + PLAYER_HEIGHT - 1, level, 'C') ||
collide_point(x + PLAYER_HEIGHT - 1, y + PLAYER_HEIGHT - 1,
level, 'C');
}
char collide_point(int x, int y, char level[], char block)
{
return (level[(int)(x/16) + (int)(y/16) * 25] == block);
return (level[(int)(x / 16) + (int)(y / 16) * 25] == block);
}
char collide_end(int x, int y, char level[])
@ -48,20 +55,18 @@ char collide_end(int x, int y, char level[])
void collide_replace(int x, int y, char level[], char collide, char replace)
{
if(collide_point(x, y, level, collide))
{
level[((x)/16)+((y)/16)*25] = replace;
if (collide_point(x, y, level, collide)) {
level[((x) / 16) + ((y) / 16) * 25] = replace;
}
if(collide_point(x + PLAYER_HEIGHT, y, level, collide))
{
level[((x + PLAYER_HEIGHT)/16)+((y)/16)*25] = replace;
if (collide_point(x + PLAYER_HEIGHT, y, level, collide)) {
level[((x + PLAYER_HEIGHT) / 16) + ((y) / 16) * 25] = replace;
}
if(collide_point(x, y + PLAYER_HEIGHT, level, collide))
{
level[((x)/16)+((y + PLAYER_HEIGHT)/16)*25] = replace;
if (collide_point(x, y + PLAYER_HEIGHT, level, collide)) {
level[((x) / 16) + ((y + PLAYER_HEIGHT) / 16) * 25] = replace;
}
if(collide_point(x + PLAYER_HEIGHT, y + PLAYER_HEIGHT, level, collide))
{
level[((x + PLAYER_HEIGHT)/16)+((y + PLAYER_HEIGHT)/16)*25] = replace;
if (collide_point(x + PLAYER_HEIGHT, y + PLAYER_HEIGHT, level,
collide)) {
level[((x + PLAYER_HEIGHT) / 16) +
((y + PLAYER_HEIGHT) / 16) * 25] = replace;
}
}

210
src/drawlevel.c Executable file → Normal file
View File

@ -1,33 +1,33 @@
#include "drawlevel.h"
#include <gint/std/string.h>
#include <gint/display.h>
#include "define.h"
#include "times.h"
#include <gint/display.h>
#include <gint/std/string.h>
#define VISIBLE_RECT 35
extern bopti_image_t img_solid; //solid block
extern bopti_image_t img_coin; //facultative coin
extern bopti_image_t img_dead; //dead block
extern bopti_image_t img_player; //player
extern bopti_image_t img_end; //end of level
extern bopti_image_t img_key1; //key 1
extern bopti_image_t img_blackout; //blackout
extern bopti_image_t img_chrono1; //chronoblock
extern bopti_image_t img_chrono2; //chronoblock 2
extern bopti_image_t img_key2; //key 2
extern bopti_image_t img_damaged; //damaged block
extern bopti_image_t img_chock; //chock block
extern bopti_image_t img_switch; //switch block
extern bopti_image_t img_ice; //switch block
extern bopti_image_t img_appear; //appear block
extern bopti_image_t img_solid; // solid block
extern bopti_image_t img_coin; // facultative coin
extern bopti_image_t img_dead; // dead block
extern bopti_image_t img_player; // player
extern bopti_image_t img_end; // end of level
extern bopti_image_t img_key1; // key 1
extern bopti_image_t img_blackout; // blackout
extern bopti_image_t img_chrono1; // chronoblock
extern bopti_image_t img_chrono2; // chronoblock 2
extern bopti_image_t img_key2; // key 2
extern bopti_image_t img_damaged; // damaged block
extern bopti_image_t img_chock; // chock block
extern bopti_image_t img_switch; // switch block
extern bopti_image_t img_ice; // switch block
extern bopti_image_t img_appear; // appear block
extern bopti_image_t img_endscreen;
extern bopti_image_t img_new;
void draw_player(int x, int y, char type)
{
dsubimage(x,y,&img_player, 12*(type-1),0,12,12, DIMAGE_NONE);
dsubimage(x, y, &img_player, 12 * (type - 1), 0, 12, 12, DIMAGE_NONE);
}
void draw_level(char level[])
@ -36,76 +36,76 @@ void draw_level(char level[])
unsigned int x = 0;
unsigned int y = 0;
unsigned int i = 0;
while (i!=strlen(level))
{
switch(level[i])
{
case '1': //solid block
dimage(x,y,&img_solid);
break;
case 't': //coin (treasure)
dimage(x,y,&img_coin);
break;
case 'd': //dead block
dimage(x,y,&img_dead);
break;
case 'e': //end of level
dimage(x,y,&img_end);
break;
case '3': //block link to the key1
dsubimage(x,y,&img_key1,0,0,16,16,DIMAGE_NONE);
break;
case 'k': //key1
dsubimage(x,y,&img_key1,16,0,16,16,DIMAGE_NONE);
break;
case 'a': //block link to the key2 when it's not on
dsubimage(x,y,&img_key2,0,0,16,16,DIMAGE_NONE);
break;
case '4': //block link to the key2
dsubimage(x,y,&img_key2,16,0,16,16,DIMAGE_NONE);
break;
case 'K': //key2
dsubimage(x,y,&img_key2,32,0,16,16,DIMAGE_NONE);
break;
case 'c': //chrono blocks
dimage(x,y,&img_chrono1);
break;
case 'C': //chrono blocks
dsubimage(x,y,&img_chrono2,16,0,16,16,DIMAGE_NONE);
break;
case 'b': //blackout blocks
dimage(x,y,&img_blackout);
break;
case 'B': //damaged block
dimage(x,y,&img_damaged);
break;
case 'l': //chock blocks
dimage(x,y,&img_chock);
break;
case 'i': //chock blocks
dimage(x,y,&img_ice);
break;
case 'S': //chock blocks
dimage(x,y,&img_switch);
break;
case 'h': //void appear blocks
dsubimage(x,y,&img_appear,0,0,16,16,DIMAGE_NONE);
break;
case 'H': //appear blocks
dsubimage(x,y,&img_appear,16,0,16,16,DIMAGE_NONE);
break;
case 'y': //appear blocks
dsubimage(x,y,&img_appear,0,0,16,16,DIMAGE_NONE);
break;
case 'm': //chronoappear blocks
dsubimage(x,y,&img_chrono2,0,0,16,16,DIMAGE_NONE);
break;
while (i != strlen(level)) {
switch (level[i]) {
case '1': // solid block
dimage(x, y, &img_solid);
break;
case 't': // coin (treasure)
dimage(x, y, &img_coin);
break;
case 'd': // dead block
dimage(x, y, &img_dead);
break;
case 'e': // end of level
dimage(x, y, &img_end);
break;
case '3': // block link to the key1
dsubimage(x, y, &img_key1, 0, 0, 16, 16, DIMAGE_NONE);
break;
case 'k': // key1
dsubimage(x, y, &img_key1, 16, 0, 16, 16, DIMAGE_NONE);
break;
case 'a': // block link to the key2 when it's not on
dsubimage(x, y, &img_key2, 0, 0, 16, 16, DIMAGE_NONE);
break;
case '4': // block link to the key2
dsubimage(x, y, &img_key2, 16, 0, 16, 16, DIMAGE_NONE);
break;
case 'K': // key2
dsubimage(x, y, &img_key2, 32, 0, 16, 16, DIMAGE_NONE);
break;
case 'c': // chrono blocks
dimage(x, y, &img_chrono1);
break;
case 'C': // chrono blocks
dsubimage(x, y, &img_chrono2, 16, 0, 16, 16,
DIMAGE_NONE);
break;
case 'b': // blackout blocks
dimage(x, y, &img_blackout);
break;
case 'B': // damaged block
dimage(x, y, &img_damaged);
break;
case 'l': // chock blocks
dimage(x, y, &img_chock);
break;
case 'i': // chock blocks
dimage(x, y, &img_ice);
break;
case 'S': // chock blocks
dimage(x, y, &img_switch);
break;
case 'h': // void appear blocks
dsubimage(x, y, &img_appear, 0, 0, 16, 16, DIMAGE_NONE);
break;
case 'H': // appear blocks
dsubimage(x, y, &img_appear, 16, 0, 16, 16,
DIMAGE_NONE);
break;
case 'y': // appear blocks
dsubimage(x, y, &img_appear, 0, 0, 16, 16, DIMAGE_NONE);
break;
case 'm': // chronoappear blocks
dsubimage(x, y, &img_chrono2, 0, 0, 16, 16,
DIMAGE_NONE);
break;
}
x+=16;
if(x==16*25)
{
x=0;
y+=16;
x += 16;
if (x == 16 * 25) {
x = 0;
y += 16;
}
i++;
}
@ -113,35 +113,37 @@ void draw_level(char level[])
void draw_blackout(int x, int y)
{
x+=5;
y+=5;
drect(0, 0, 395, y-VISIBLE_RECT, C_BLACK); //top rect
drect(0, y-VISIBLE_RECT, x-VISIBLE_RECT, y+VISIBLE_RECT, C_BLACK); //left rect
drect(x+VISIBLE_RECT, y-VISIBLE_RECT, 395, y+VISIBLE_RECT, C_BLACK); //right rect
drect(0, y+VISIBLE_RECT, 395, 223, C_BLACK); //bottom rect
x += 5;
y += 5;
drect(0, 0, 395, y - VISIBLE_RECT, C_BLACK); // top rect
drect(0, y - VISIBLE_RECT, x - VISIBLE_RECT, y + VISIBLE_RECT,
C_BLACK); // left rect
drect(x + VISIBLE_RECT, y - VISIBLE_RECT, 395, y + VISIBLE_RECT,
C_BLACK); // right rect
drect(0, y + VISIBLE_RECT, 395, 223, C_BLACK); // bottom rect
}
void draw_timer(unsigned int frame)
{
float framefloat = frame;
dprint_opt(0, 0, C_WHITE, C_BLACK, DTEXT_LEFT, DTEXT_TOP, "%.2j", (int)(framefloat/FPS*100));
dprint_opt(0, 0, C_WHITE, C_BLACK, DTEXT_LEFT, DTEXT_TOP, "%.2j",
(int)(framefloat / FPS * 100));
}
void draw_end(int framelevel, int id_level, char record)
{
float framefloat = framelevel;
dimage(144,60,&img_endscreen);
if(record!=2)
{
dprint_opt(220, 115, C_WHITE, C_BLACK, DTEXT_LEFT, DTEXT_TOP, "%d", framelevel);
dprint(166, 87, C_RED, "%.2j",(int)(framefloat/FPS*100));
dimage(144, 60, &img_endscreen);
if (record != 2) {
dprint_opt(220, 115, C_WHITE, C_BLACK, DTEXT_LEFT, DTEXT_TOP,
"%d", framelevel);
dprint(166, 87, C_RED, "%.2j", (int)(framefloat / FPS * 100));
check_medal(framelevel, id_level, 178, 140);
if(record==1) dimage(60,100,&img_new);
}
else
{
if (record == 1)
dimage(60, 100, &img_new);
} else {
dprint(166, 87, C_RED, "GG !");
dprint(178, 140, C_RED, "%.2j",(int)(framefloat/FPS*100));
dprint(178, 140, C_RED, "%.2j", (int)(framefloat / FPS * 100));
}
dupdate();
}

600
src/main.c Executable file → Normal file
View File

@ -1,17 +1,17 @@
#include <gint/display.h>
#include <gint/keyboard.h>
#include <gint/clock.h>
#include <gint/timer.h>
#include <gint/display.h>
#include <gint/gint.h>
#include <gint/keyboard.h>
#include <gint/std/string.h>
#include <gint/timer.h>
#include "setlevel.h"
#include "drawlevel.h"
#include "collide.h"
#include "menu.h"
#include "times.h"
#include "save.h"
#include "define.h"
#include "drawlevel.h"
#include "menu.h"
#include "save.h"
#include "setlevel.h"
#include "times.h"
#define VACCELERATION 0.2
#define HACCELERATION 0.4
@ -23,391 +23,456 @@ void end(unsigned int frame);
int callback(volatile int *frame_elapsed)
{
*frame_elapsed = 1;
return TIMER_CONTINUE;
*frame_elapsed = 1;
return TIMER_CONTINUE;
}
void game(int *id_level, char mode, char *type)
{
volatile int frame_elapsed = 1;
int timer = timer_setup(TIMER_ANY, 1000000/FPS, callback, &frame_elapsed);
int timer =
timer_setup(TIMER_ANY, 1000000 / FPS, callback, &frame_elapsed);
timer_start(timer);
char game_loop = 1;
unsigned int frame = 0;
int framelevel = 0;
int player_x = 20, player_y = 20;
char level[351];
char gravity = 0; //0 down 1 up
char gravity = 0; // 0 down 1 up
char check = 1;
char blackout = 0;
int start_x;
int start_y;
int death_count = 0;
int coin = 0;
char check_coin = 0;
char double_check = 1;
int appear = 10;
int disappear = 13;
float vspd = 1.0;
float hspd = 0.0;
if(*id_level==10 && *type!=3) *type = 2;
else if(*type!=3) *type = 1;
if (*id_level == 10 && *type != 3)
*type = 2;
else if (*type != 3)
*type = 1;
extern bopti_image_t img_speedrun;
set_level(*id_level, level, &start_x, &start_y, &gravity, &appear, &disappear);
set_level(*id_level, level, &start_x, &start_y, &gravity, &appear,
&disappear);
player_x = start_x;
player_y = start_y;
draw_level(level);
while(game_loop)
{
while(!frame_elapsed) sleep();
while (game_loop) {
while (!frame_elapsed)
sleep();
frame_elapsed = 0;
frame++;
framelevel++;
if(!(frame%2))
{
if (!(frame % 2)) {
draw_level(level);
if(blackout) draw_blackout(player_x, player_y);
if (blackout)
draw_blackout(player_x, player_y);
draw_player(player_x, player_y, *type);
if(!mode) draw_timer(frame);
else draw_timer(framelevel);
if(*id_level==0 && !mode)
{
dprint(85,180,C_RGB(245,245,0),"SHIFT");
dprint(120,3,C_RGB(220,220,220),"Keys has effects on blocks");
dprint(15,67,C_RGB(220,220,220),"Red blocks = death");
dprint(30,211,C_RGB(220,220,220),"^ special blocks");
dprint(290,131,C_RGB(110,110,110),"Well done !");
}
if(!mode) dprint_opt(330, 0, C_RGB(255,190,0), C_BLACK, DTEXT_LEFT, DTEXT_TOP, "Coin : %d", coin);
if (!mode)
draw_timer(frame);
else
draw_timer(framelevel);
if (*id_level == 0 && !mode) {
dprint(85, 180, C_RGB(245, 245, 0), "SHIFT");
dprint(120, 3, C_RGB(220, 220, 220),
"Keys has effects on blocks");
dprint(15, 67, C_RGB(220, 220, 220),
"Red blocks = death");
dprint(30, 211, C_RGB(220, 220, 220),
"^ special blocks");
dprint(290, 131, C_RGB(110, 110, 110),
"Well done !");
}
if (!mode)
dprint_opt(330, 0, C_RGB(255, 190, 0), C_BLACK,
DTEXT_LEFT, DTEXT_TOP, "Coin : %d",
coin);
dupdate();
}
pollevent();
if(keydown(KEY_OPTN))
{
level[((player_x+6)/16)+((player_y+6)/16)*25] = 'd';
if (keydown(KEY_OPTN)) {
level[((player_x + 6) / 16) +
((player_y + 6) / 16) * 25] = 'd';
death_count--;
}
//Right collision
if(keydown(KEY_RIGHT))
{
// Right collision
if (keydown(KEY_RIGHT)) {
hspd *= 1 - FRICTION;
hspd += (keydown(KEY_RIGHT)-keydown(KEY_LEFT)) * HACCELERATION;
if(!collide_solid(player_x+round(hspd)+1, player_y, level)) player_x += round(hspd);
else if(!collide_solid(player_x+1, player_y, level)) player_x+=1;
if(player_x>=388) player_x=-4;
hspd += (keydown(KEY_RIGHT) - keydown(KEY_LEFT)) *
HACCELERATION;
if (!collide_solid(player_x + round(hspd) + 1, player_y,
level))
player_x += round(hspd);
else if (!collide_solid(player_x + 1, player_y, level))
player_x += 1;
if (player_x >= 388)
player_x = -4;
}
//Left collision
else if(keydown(KEY_LEFT))
{
// Left collision
else if (keydown(KEY_LEFT)) {
hspd *= 1 - FRICTION;
hspd += (keydown(KEY_RIGHT)-keydown(KEY_LEFT)) * HACCELERATION;
if(!collide_solid(player_x+round(hspd)-1, player_y, level)) player_x += round(hspd);
else if(!collide_solid(player_x-1, player_y, level)) player_x-=1;
if(player_x<-9) player_x=384;
}
else hspd=0;
//Action key
if(keydown(KEY_SHIFT) && !check && ((collide_solid(player_x, player_y-1, level) && gravity) || (collide_solid(player_x, player_y+1, level) && !gravity)))
{
hspd += (keydown(KEY_RIGHT) - keydown(KEY_LEFT)) *
HACCELERATION;
if (!collide_solid(player_x + round(hspd) - 1, player_y,
level))
player_x += round(hspd);
else if (!collide_solid(player_x - 1, player_y, level))
player_x -= 1;
if (player_x < -9)
player_x = 384;
} else
hspd = 0;
// Action key
if (keydown(KEY_SHIFT) && !check &&
((collide_solid(player_x, player_y - 1, level) &&
gravity) ||
(collide_solid(player_x, player_y + 1, level) &&
!gravity))) {
vspd = 1;
if(!gravity) gravity=1;
else gravity=0;
check=1;
}
else if(!keydown(KEY_SHIFT) && check) check=0;
//Gravity
if(!gravity)
{
if(!collide_solid(player_x, player_y+(int)vspd+1, level))
{
if (vspd<MAX_VSPD) vspd+=VACCELERATION;
if(collide(player_x+1, player_y, level, 'i')) vspd+=0.15;
if(collide(player_x-1, player_y, level, 'i')) vspd+=0.15;
player_y+=(int)vspd;
}
else if(!collide_solid(player_x, player_y+(int)vspd, level))
{
vspd-=VACCELERATION;
player_y+=(int)vspd;
}
else if(!collide_solid(player_x, player_y+1, level))
{
if (!gravity)
gravity = 1;
else
gravity = 0;
check = 1;
} else if (!keydown(KEY_SHIFT) && check)
check = 0;
// Gravity
if (!gravity) {
if (!collide_solid(player_x, player_y + (int)vspd + 1,
level)) {
if (vspd < MAX_VSPD)
vspd += VACCELERATION;
if (collide(player_x + 1, player_y, level, 'i'))
vspd += 0.15;
if (collide(player_x - 1, player_y, level, 'i'))
vspd += 0.15;
player_y += (int)vspd;
} else if (!collide_solid(
player_x, player_y + (int)vspd, level)) {
vspd -= VACCELERATION;
player_y += (int)vspd;
} else if (!collide_solid(player_x, player_y + 1,
level)) {
vspd = 1;
player_y+=1;
}
else vspd = 1;
}
else
{
if(!collide_solid(player_x, player_y-(int)vspd-1, level))
{
if (vspd<MAX_VSPD) vspd+=VACCELERATION;
if(collide(player_x+1, player_y, level, 'i')) vspd+=0.15;
if(collide(player_x-1, player_y, level, 'i')) vspd+=0.15;
player_y-=(int)vspd;
}
else if(!collide_solid(player_x, player_y-(int)vspd, level))
{
vspd-=VACCELERATION;
player_y-=(int)vspd;
}
else if(!collide_solid(player_x, player_y-1, level))
{
player_y += 1;
} else
vspd = 1;
} else {
if (!collide_solid(player_x, player_y - (int)vspd - 1,
level)) {
if (vspd < MAX_VSPD)
vspd += VACCELERATION;
if (collide(player_x + 1, player_y, level, 'i'))
vspd += 0.15;
if (collide(player_x - 1, player_y, level, 'i'))
vspd += 0.15;
player_y -= (int)vspd;
} else if (!collide_solid(
player_x, player_y - (int)vspd, level)) {
vspd -= VACCELERATION;
player_y -= (int)vspd;
} else if (!collide_solid(player_x, player_y - 1,
level)) {
vspd = 1;
player_y -= 1;
} else
vspd = 1;
player_y-=1;
}
else vspd = 1;
}
//Collide with red block
if(collide_dead(player_x, player_y, level))
{
// Collide with red block
if (collide_dead(player_x, player_y, level)) {
vspd = 1;
player_x = start_x;
player_y = start_y;
if(check_coin) coin--;
if (check_coin)
coin--;
check_coin = 0;
set_level(*id_level, level, &start_x, &start_y, &gravity, &appear, &disappear);
set_level(*id_level, level, &start_x, &start_y,
&gravity, &appear, &disappear);
blackout = 0;
death_count++;
double_check = 1;
framelevel = 0;
if(*id_level == 1 && !mode)
frame = 0;
if (*id_level == 1 && !mode)
frame = 0;
}
//Collide with the end
if(collide_end(player_x, player_y, level))
{
if(!mode && *id_level !=0) *id_level+=1;
else break;
// Collide with the end
if (collide_end(player_x, player_y, level)) {
if (!mode && *id_level != 0)
*id_level += 1;
else
break;
check_coin = 0;
set_level(*id_level, level, &start_x, &start_y, &gravity, &appear, &disappear);
set_level(*id_level, level, &start_x, &start_y,
&gravity, &appear, &disappear);
player_x = start_x;
player_y = start_y;
blackout = 0;
double_check = 1;
framelevel=0;
if(*id_level==10 && *type==1) *type = 2;
else if(*type!=3) *type = 1;
if(*id_level==LEVEL_MAX+1)
{
framelevel = 0;
if (*id_level == 10 && *type == 1)
*type = 2;
else if (*type != 3)
*type = 1;
if (*id_level == LEVEL_MAX + 1) {
timer_stop(timer);
end(frame);
}
}
if(collide(player_x, player_y, level, 'k')) //Collide with key1 = disappearance of blocks
if (collide(player_x, player_y, level,
'k')) // Collide with key1 = disappearance of blocks
{
for (int i = 0; level[i]!='\0' ; i++)
{
if(level[i]=='3') level[i]='0';
if(level[i]=='k') level[i]='0';
for (int i = 0; level[i] != '\0'; i++) {
if (level[i] == '3')
level[i] = '0';
if (level[i] == 'k')
level[i] = '0';
}
}
if(collide(player_x, player_y, level, 'K')) //Collide with key2 = appearance of blocks
if (collide(player_x, player_y, level,
'K')) // Collide with key2 = appearance of blocks
{
for (int i = 0; level[i]!='\0' ; i++)
{
if(level[i]=='a') level[i]='4';
if(level[i]=='K') level[i]='0';
for (int i = 0; level[i] != '\0'; i++) {
if (level[i] == 'a')
level[i] = '4';
if (level[i] == 'K')
level[i] = '0';
}
}
if(collide(player_x, player_y, level, 't') && !check_coin) //Collide with coin
if (collide(player_x, player_y, level, 't') &&
!check_coin) // Collide with coin
{
for (int i = 0; level[i]!='\0' ; i++)
{
if(level[i]=='t')
{
level[i]='0';
for (int i = 0; level[i] != '\0'; i++) {
if (level[i] == 't') {
level[i] = '0';
break;
}
}
check_coin=1;
check_coin = 1;
coin++;
}
if(collide(player_x, player_y, level, 'b')) //Collide with blackout block
if (collide(player_x, player_y, level,
'b')) // Collide with blackout block
{
for (int i = 0; level[i]!='\0' ; i++)
{
if(level[i]=='b')
{
level[i]='0';
for (int i = 0; level[i] != '\0'; i++) {
if (level[i] == 'b') {
level[i] = '0';
break;
}
}
blackout=1;
blackout = 1;
}
if(level[((player_x+6)/16)+((player_y+6)/16)*25] == 'l') //Collide with change block
if (level[((player_x + 6) / 16) + ((player_y + 6) / 16) * 25] ==
'l') // Collide with change block
{
int x = 0;
int y = 0;
char level2[351] = { 0 };
char level2[351] = {0};
int j = 0;
level[((player_x+6)/16)+((player_y+6)/16)*25] = 'P';
for (int i = 349; i!=-1 ; i--)
{
level2[j]=level[i];
level[((player_x + 6) / 16) +
((player_y + 6) / 16) * 25] = 'P';
for (int i = 349; i != -1; i--) {
level2[j] = level[i];
j++;
}
del_level(level);
strncpy(level,level2,351);
strncpy(level, level2, 351);
del_level(level2);
int i = 0;
while (i!=350)
{
switch(level[i])
{
case 'P':
player_x = x;
player_y = y;
level[i]='0';
break;
while (i != 350) {
switch (level[i]) {
case 'P':
player_x = x;
player_y = y;
level[i] = '0';
break;
}
x+=16;
if(x==16*25)
{
x=0;
y+=16;
x += 16;
if (x == 16 * 25) {
x = 0;
y += 16;
}
i++;
}
if(!gravity) gravity=1;
else gravity=0;
if (!gravity)
gravity = 1;
else
gravity = 0;
}
if(collide(player_x, player_y+(int)vspd+2, level, 'B') && vspd>=5) //Damaged block
if (collide(player_x, player_y + (int)vspd + 2, level, 'B') &&
vspd >= 5) // Damaged block
{
if(level[((player_x)/16)+((player_y+25)/16)*25]=='B') level[((player_x)/16)+((player_y+25)/16)*25]='0';
if(level[((player_x+12)/16)+((player_y+25)/16)*25]=='B' && collide_point(player_x+12, player_y+22, level, 'B')) level[((player_x+12)/16)+((player_y+25)/16)*25]='0';
vspd=1.0;
if (level[((player_x) / 16) +
((player_y + 25) / 16) * 25] == 'B')
level[((player_x) / 16) +
((player_y + 25) / 16) * 25] = '0';
if (level[((player_x + 12) / 16) +
((player_y + 25) / 16) * 25] == 'B' &&
collide_point(player_x + 12, player_y + 22, level,
'B'))
level[((player_x + 12) / 16) +
((player_y + 25) / 16) * 25] = '0';
vspd = 1.0;
}
if(collide(player_x, player_y-(int)vspd-2, level, 'B') && vspd>=5) //Damaged block
if (collide(player_x, player_y - (int)vspd - 2, level, 'B') &&
vspd >= 5) // Damaged block
{
if(level[((player_x)/16)+((player_y-(int)vspd-2)/16)*25]=='B') level[((player_x)/16)+((player_y-(int)vspd-2)/16)*25]='0';
if(level[((player_x+12)/16)+((player_y-(int)vspd-2)/16)*25]=='B' && collide_point(player_x+12, player_y-12, level, 'B')) level[((player_x+12)/16)+((player_y-(int)vspd-2)/16)*25]='0';
vspd=1.0;
if (level[((player_x) / 16) +
((player_y - (int)vspd - 2) / 16) * 25] ==
'B')
level[((player_x) / 16) +
((player_y - (int)vspd - 2) / 16) * 25] =
'0';
if (level[((player_x + 12) / 16) +
((player_y - (int)vspd - 2) / 16) * 25] ==
'B' &&
collide_point(player_x + 12, player_y - 12, level,
'B'))
level[((player_x + 12) / 16) +
((player_y - (int)vspd - 2) / 16) * 25] =
'0';
vspd = 1.0;
}
collide_replace(player_x, player_y, level, 'h', 'y'); //Appear block
if(!collide(player_x, player_y, level, 'y') && double_check) //Appear block
collide_replace(player_x, player_y, level, 'h',
'y'); // Appear block
if (!collide(player_x, player_y, level, 'y') &&
double_check) // Appear block
{
for (int i = 0; level[i]!='\0' ; i++)
{
if(level[i]=='y')
{
for (int i = 0; level[i] != '\0'; i++) {
if (level[i] == 'y') {
double_check = 1;
break;
}
else if(level[i]=='h')
{
} else if (level[i] == 'h') {
double_check = 1;
break;
}
else double_check = 0; //This loop is executed only when an h or y is on the level
} else
double_check =
0; // This loop is executed only
// when an h or y is on the level
}
for (int i = 0; level[i]!='\0'; ++i)
{
if(level[i]=='y')
{
level[i]='H';
for (int i = 0; level[i] != '\0'; ++i) {
if (level[i] == 'y') {
level[i] = 'H';
}
}
}
}
if(level[((player_x+6)/16)+((player_y+6)/16)*25] == 'S') //Switch block
if (level[((player_x + 6) / 16) + ((player_y + 6) / 16) * 25] ==
'S') // Switch block
{
level[((player_x+6)/16)+((player_y+6)/16)*25] = '0';
vspd=1.0;
if(!gravity) gravity=1;
else gravity=0;
level[((player_x + 6) / 16) +
((player_y + 6) / 16) * 25] = '0';
vspd = 1.0;
if (!gravity)
gravity = 1;
else
gravity = 0;
}
if((framelevel/FPS)>disappear) for (int i = 0; level[i]!='\0' ; i++) if(level[i]=='c') level[i]='0'; //after x seconds blocks disappear
if((framelevel/FPS)>appear) for (int i = 0; level[i]!='\0' ; i++) if(level[i]=='m') level[i]='C'; //after x seconds blocks appear
if(player_y>=212) player_y=-4;
if(player_y<-6) player_y=212;
//Menu
if(keydown_any(KEY_EXIT, KEY_MENU, 0))
{
if ((framelevel / FPS) > disappear)
for (int i = 0; level[i] != '\0'; i++)
if (level[i] == 'c')
level[i] = '0'; // after x seconds
// blocks disappear
if ((framelevel / FPS) > appear)
for (int i = 0; level[i] != '\0'; i++)
if (level[i] == 'm')
level[i] = 'C'; // after x seconds
// blocks appear
if (player_y >= 212)
player_y = -4;
if (player_y < -6)
player_y = 212;
// Menu
if (keydown_any(KEY_EXIT, KEY_MENU, 0)) {
char menu_loop = 1;
char selected = 0;
int Y_POS = 18;
char buffer = 1;
while(menu_loop)
{
while (menu_loop) {
clearevents();
dclear(C_WHITE);
draw_level(level);
draw_player(player_x,player_y, *type);
dimage(0,0,&img_speedrun);
draw_player(player_x, player_y, *type);
dimage(0, 0, &img_speedrun);
selected += keydown(KEY_DOWN) - keydown(KEY_UP);
if (selected == 2) selected = 0;
else if (selected == -1) selected = 1;
if (selected == 2)
selected = 0;
else if (selected == -1)
selected = 1;
dtext(32, Y_POS, C_BLACK, "CONTINUE");
if(!mode) dtext(32, Y_POS + 12, C_BLACK, "MENU");
else dtext(32, Y_POS + 12, C_BLACK, "SPEEDRUN MENU");
dtext(16, Y_POS + (selected * 12), C_BLACK, ">");
dprint(180, 45, C_RGB(83,255,0), "LEVEL : %d", *id_level);
dprint(320, 3, C_RGB(255,178,0), "COIN : %d", coin);
dprint(311, 17, C_RGB(150,16,16), "DEATH : %d", death_count);
if (!mode)
dtext(32, Y_POS + 12, C_BLACK, "MENU");
else
dtext(32, Y_POS + 12, C_BLACK,
"SPEEDRUN MENU");
dtext(16, Y_POS + (selected * 12), C_BLACK,
">");
dprint(180, 45, C_RGB(83, 255, 0), "LEVEL : %d",
*id_level);
dprint(320, 3, C_RGB(255, 178, 0), "COIN : %d",
coin);
dprint(311, 17, C_RGB(150, 16, 16),
"DEATH : %d", death_count);
dupdate();
if (keydown_any(KEY_SHIFT, KEY_EXE, 0))
{
switch (selected)
{
case 0:
menu_loop = 0;
break;
case 1:
menu_loop = 0;
game_loop = 0;
break;
}
}
if(keydown_any(KEY_EXIT, KEY_MENU, 0))
{
if(!buffer)
{
if (keydown_any(KEY_SHIFT, KEY_EXE, 0)) {
switch (selected) {
case 0:
menu_loop = 0;
break;
case 1:
menu_loop = 0;
game_loop = 0;
break;
}
}
else buffer = 0;
while (keydown_any(KEY_UP, KEY_DOWN, 0)) clearevents();
if (keydown_any(KEY_EXIT, KEY_MENU, 0)) {
if (!buffer) {
menu_loop = 0;
game_loop = 0;
break;
}
} else
buffer = 0;
while (keydown_any(KEY_UP, KEY_DOWN, 0))
clearevents();
}
}
}
timer_stop(timer);
//when a level is quit
if(mode)
{
if(*id_level==0) *id_level=1;
if(game_loop) //end of a level with level selection
// when a level is quit
if (mode) {
if (*id_level == 0)
*id_level = 1;
if (game_loop) // end of a level with level selection
{
float framefloat = framelevel;
draw_end(framelevel, *id_level, 0);
savetimes(framefloat, *id_level);
sleep_ms(3000);
}
if(!speed_menu(id_level))
{
if (!speed_menu(id_level)) {
mode = 1;
death_count = 0;
game(id_level, mode, type);
}
else main();
}
else main();
} else
main();
} else
main();
}
void end(unsigned int frame)
@ -418,28 +483,23 @@ void end(unsigned int frame)
}
int main(void)
{
{
char mode = 0;
char type = 1;
char valeur = start_menu(&type);
if(!valeur) //normal game (level selection)
if (!valeur) // normal game (level selection)
{
int id_level = 1;
if(!speed_menu(&id_level))
{
if (!speed_menu(&id_level)) {
mode = 1;
game(&id_level, mode, &type);
}
else main();
}
else if(valeur==1)
{
} else
main();
} else if (valeur == 1) {
int id_level = 1;
mode = 0;
game(&id_level, mode, &type);
}
else if(valeur==2)
{
} else if (valeur == 2) {
int id_level = 0;
game(&id_level, mode, &type);
}

112
src/menu.c Executable file → Normal file
View File

@ -1,16 +1,16 @@
#include "define.h"
#include "drawlevel.h"
#include <gint/display.h>
#include <gint/keyboard.h>
#include "save.h"
#include "setlevel.h"
#include "times.h"
#include "define.h"
#include "save.h"
#include <gint/display.h>
#include <gint/gint.h>
#include <gint/keyboard.h>
int round(float num) //round(2.5) = 3 round(-3.2) = -3
{
return num < 0 ? num - 0.5 : num + 0.5;
}
int round(float num) // round(2.5) = 3 round(-3.2) = -3
{
return num < 0 ? num - 0.5 : num + 0.5;
}
char start_menu(char *type)
{
@ -21,14 +21,15 @@ char start_menu(char *type)
char buffer2 = 1;
int Y_POS = 85;
gint_switch(restore);
while(menu_loop)
{
while (menu_loop) {
clearevents();
dclear(C_WHITE);
dimage(0,0,&img_menu);
dimage(0, 0, &img_menu);
selection += keydown(KEY_DOWN) - keydown(KEY_UP);
if (selection == 4) selection = 0;
else if (selection == -1) selection = 3;
if (selection == 4)
selection = 0;
else if (selection == -1)
selection = 3;
dtext(32, Y_POS, C_BLACK, "PLAY");
dtext(32, Y_POS + 12, C_BLACK, "ALL MODE");
dtext(32, Y_POS + 24, C_BLACK, "TUTORIAL");
@ -36,15 +37,19 @@ char start_menu(char *type)
dtext(16, Y_POS + (selection * 12), C_BLACK, ">");
dupdate();
if (keydown_any(KEY_SHIFT, KEY_EXE, 0)) {
if(!buffer2) return selection;
}
else buffer2 = 0;
if(keydown_any(KEY_EXIT, KEY_MENU, 0)) {
if(!buffer) return -1;
}
else buffer = 0;
if(keydown_all(KEY_5,KEY_6)) *type = 3;
while (keydown_any(KEY_UP, KEY_DOWN, 0)) clearevents();
if (!buffer2)
return selection;
} else
buffer2 = 0;
if (keydown_any(KEY_EXIT, KEY_MENU, 0)) {
if (!buffer)
return -1;
} else
buffer = 0;
if (keydown_all(KEY_5, KEY_6))
*type = 3;
while (keydown_any(KEY_UP, KEY_DOWN, 0))
clearevents();
}
return selection;
}
@ -52,54 +57,61 @@ char start_menu(char *type)
char speed_menu(int *id_level)
{
char level[351];
char gravity = 0; //0 down 1 up
char gravity = 0; // 0 down 1 up
int start_x;
int start_y;
char buffer = 1;
int appear = 10;
int disappear = 13;
int sto = loadtime(*id_level-1);
int sto = loadtime(*id_level - 1);
char menu_loop = 1;
char check = 1;
extern bopti_image_t img_speedrun;
while(menu_loop)
{
while (menu_loop) {
clearevents();
dclear(C_WHITE);
*id_level += keydown(KEY_RIGHT) - keydown(KEY_LEFT);
if (*id_level == LEVEL_MAX+1) *id_level = 1;
else if (*id_level == 0) *id_level = LEVEL_MAX;
if(keydown(KEY_RIGHT) || keydown(KEY_LEFT)) sto = loadtime(*id_level-1);
set_level(*id_level, level, &start_x, &start_y, &gravity, &appear, &disappear);
if (*id_level == LEVEL_MAX + 1)
*id_level = 1;
else if (*id_level == 0)
*id_level = LEVEL_MAX;
if (keydown(KEY_RIGHT) || keydown(KEY_LEFT))
sto = loadtime(*id_level - 1);
set_level(*id_level, level, &start_x, &start_y, &gravity,
&appear, &disappear);
draw_level(level);
dimage(0,0,&img_speedrun);
if(sto != 0) check_medal(round(sto*0.01*FPS), *id_level, 335, 8);
dimage(0, 0, &img_speedrun);
if (sto != 0)
check_medal(round(sto * 0.01 * FPS), *id_level, 335, 8);
dtext(340, 214, C_BLACK, "TIMES");
dtext(190, 45, C_BLACK, "Time : ");
dprint(80,20,C_BLACK,"Level : %d",*id_level);
if(sto != 0) dprint(194,60,C_RED, "%.2j", sto);
else dprint(202,60,C_RED, "/");
if(*id_level == 14) dprint_opt(180, 8, C_RGB(0,255,255), C_BLACK, DTEXT_LEFT, DTEXT_TOP, "VVVVVV");
dprint(80, 20, C_BLACK, "Level : %d", *id_level);
if (sto != 0)
dprint(194, 60, C_RED, "%.2j", sto);
else
dprint(202, 60, C_RED, "/");
if (*id_level == 14)
dprint_opt(180, 8, C_RGB(0, 255, 255), C_BLACK,
DTEXT_LEFT, DTEXT_TOP, "VVVVVV");
dupdate();
if (keydown_any(KEY_SHIFT, KEY_EXE, 0))
{
if(!check)
{
if (keydown_any(KEY_SHIFT, KEY_EXE, 0)) {
if (!check) {
del_level(level);
return 0;
}
}
else check = 0;
if (keydown(KEY_F6))
{
} else
check = 0;
if (keydown(KEY_F6)) {
draw_time(*id_level);
}
if(keydown_any(KEY_EXIT, KEY_MENU, 0)) {
if(!buffer) return 1;
}
else buffer = 0;
while (keydown_any(KEY_RIGHT, KEY_LEFT, 0)) clearevents();
if (keydown_any(KEY_EXIT, KEY_MENU, 0)) {
if (!buffer)
return 1;
} else
buffer = 0;
while (keydown_any(KEY_RIGHT, KEY_LEFT, 0))
clearevents();
}
return 0;
}

20
src/save.c Executable file → Normal file
View File

@ -1,7 +1,7 @@
#include <gint/bfile.h>
#include <gint/gint.h>
#include "define.h"
#include "drawlevel.h"
#include <gint/bfile.h>
#include <gint/gint.h>
#include <gint/keyboard.h>
int retcode;
@ -16,7 +16,7 @@ static const uint16_t *filepath = u"\\\\fls0\\AST3.sav";
void savefile(void)
{
int descriptor;
descriptor = BFile_Open(filepath, BFile_WriteOnly);
BFile_Write(descriptor, times, sizeof(times));
BFile_Close(descriptor);
@ -30,8 +30,8 @@ void loadfile(void)
{
int descriptor;
descriptor = BFile_Open(filepath, BFile_ReadOnly);
BFile_Read(descriptor, &retcode,
sizeof(times[0]), sizeof(times[0]) * id_leveltab);
BFile_Read(descriptor, &retcode, sizeof(times[0]),
sizeof(times[0]) * id_leveltab);
BFile_Close(descriptor);
}
@ -40,9 +40,8 @@ void loadfile(void)
* savefile() else, nothing append to avoid loading time. */
void savetimes(float framelevel, int id_level)
{
if(times[id_level - 1] > (int)(framelevel / FPS * 100) ||
times[id_level - 1] == 0 || keydown(KEY_7))
{
if (times[id_level - 1] > (int)(framelevel / FPS * 100) ||
times[id_level - 1] == 0 || keydown(KEY_7)) {
times[id_level - 1] = (int)(framelevel / FPS * 100);
draw_end((int)framelevel, id_level, 1);
gint_switch(savefile);
@ -59,9 +58,10 @@ void restore(void)
uint16_t foundpath[30];
int size = sizeof(times);
int descriptor;
char checkfile = BFile_FindFirst(filepath, &handle, foundpath, &fileInfo);
char checkfile =
BFile_FindFirst(filepath, &handle, foundpath, &fileInfo);
BFile_FindClose(handle);
if(checkfile == -1)
if (checkfile == -1)
BFile_Create(filepath, BFile_File, &size);
else {
descriptor = BFile_Open(filepath, BFile_ReadOnly);