sadpmpk
/
SqaureGame
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Put linked list for separate object

master
En Yi 2020-03-20 20:26:54 +08:00 committed by En Yi
parent 11e7084586
commit 3d277b887d
6 changed files with 149 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
include/header.h
View File

@ -1,5 +1,6 @@
#include <raylib.h>
#include <stdio.h>
#include <stdlib.h>
// Global Constants
#define BEZIER_POINTS 5
@ -93,6 +94,12 @@ struct target_obj
double radius;
struct kinematic_obj kinematic;
};
struct target_obj_node
{
struct target_obj *obj;
struct target_obj_node *next;
};
// Object functions, kinematics.c
struct kinematic_obj init_kinematic_obj(int width, int height);
void move(struct kinematic_obj *obj, Vector2 acceleration);
@ -100,6 +107,9 @@ void set_position(struct kinematic_obj *obj, int x, int y);
bool place_meeting(struct kinematic_obj *obj, Vector2 dir);
void scale_rect(struct kinematic_obj *obj);
void adjust_hitbox(struct kinematic_obj *obj);
void add_kinematic_node(struct kinematic_obj *obj, struct kinematic_obj_node **HEAD);
//struct kinematic_obj_node **get_list();
void free_kinematic_list(struct kinematic_obj_node **HEAD);
// Math functions, math.c
double mag(Vector2 vec);
@ -110,12 +120,6 @@ Vector2 center(Rectangle rect);
// Linked list, linked_list.c
void create_list(void);
void add_node(struct kinematic_obj *obj, struct kinematic_obj_node **HEAD);
//struct kinematic_obj_node **get_list();
void free_list(struct kinematic_obj_node **HEAD);
void create_afterimage(struct player_obj *player, Color color);
void remove_last_afterimage(struct player_obj *player);
void free_afterimages(struct player_obj *player);
// Squishy Square functions, squishy.c
struct squishy_square init_squishy_square(struct kinematic_obj *parent, Color color);
@ -127,9 +131,15 @@ void draw_afterimages(struct player_obj *player);
//Player stuff, player.c
struct player_obj init_player_obj();
void player_input_check(struct player_obj *player);
void create_afterimage(struct player_obj *player, Color color);
void remove_last_afterimage(struct player_obj *player);
void free_afterimages(struct player_obj *player);
//Target stuff, target.c
struct target_obj init_target();
void free_target_list(struct target_obj_node **HEAD);
void add_target_node(struct target_obj *obj, struct target_obj_node **HEAD);
bool collide_target(struct kinematic_obj *obj, struct target_obj *target);
//Debug stuff, debug.c
void state_string(char *str, enum PLAYER_STATE state);

37
main.c
View File

@ -24,7 +24,7 @@
#include "header.h"
struct kinematic_obj_node *kinematic_HEAD = NULL;
struct kinematic_obj_node *target_HEAD = NULL;
struct target_obj_node *target_HEAD = NULL;
int PLAYER_ACCEL = 1500;
int JUMP_ACCEL = 15000;
int JUMP_SPD = 350;
@ -72,23 +72,22 @@ int main()
struct squishy_square sqr = init_squishy_square(&player.kinematic, RED);
player.image = &sqr;
add_node(&tile, &kinematic_HEAD);
add_node(&tile2, &kinematic_HEAD);
add_node(&tile3, &kinematic_HEAD);
add_node(&tile4, &kinematic_HEAD);
add_node(&tile5, &kinematic_HEAD);
add_node(&tile6, &kinematic_HEAD);
add_node(&tile7, &kinematic_HEAD);
add_node(&player.kinematic, &kinematic_HEAD);
add_kinematic_node(&tile, &kinematic_HEAD);
add_kinematic_node(&tile2, &kinematic_HEAD);
add_kinematic_node(&tile3, &kinematic_HEAD);
add_kinematic_node(&tile4, &kinematic_HEAD);
add_kinematic_node(&tile5, &kinematic_HEAD);
add_kinematic_node(&tile6, &kinematic_HEAD);
add_kinematic_node(&tile7, &kinematic_HEAD);
add_kinematic_node(&player.kinematic, &kinematic_HEAD);
struct target_obj target = init_target(50, 300);
set_position(&target.kinematic, 150, 380);
add_node(&target.kinematic, &target_HEAD);
add_target_node(&target, &target_HEAD);
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
struct kinematic_obj_node *current;
// Main game loop
while (!WindowShouldClose()) // Detect window close button or ESC key
{
@ -107,17 +106,19 @@ int main()
ClearBackground(RAYWHITE);
draw_afterimages(&player);
draw_squishy(&sqr);
struct kinematic_obj_node *current;
struct target_obj_node *target_current;
BeginMode2D(camera);
current = kinematic_HEAD;
while(current){
DrawRectangleLinesEx(current->obj->rect, 1, BLACK);
current = current->next;
}
current = target_HEAD;
while(current){
DrawCircle(current->obj->pos.x, current->obj->pos.y, current->obj->ori_width, BLACK);
current = current->next;
target_current = target_HEAD;
while(target_current){
DrawCircle(target_current->obj->kinematic.pos.x, target_current->obj->kinematic.pos.y,
target_current->obj->kinematic.ori_width, BLACK);
target_current = target_current->next;
}
DrawFPS(0,0);
state_string(current_state, player.state);
@ -135,8 +136,8 @@ int main()
// De-Initialization
//--------------------------------------------------------------------------------------
free_list(&kinematic_HEAD);
free_list(&target_HEAD);
free_kinematic_list(&kinematic_HEAD);
free_target_list(&target_HEAD);
free_afterimages(&player);
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------

31
obj/kinematics.c
View File

@ -109,3 +109,34 @@ void adjust_hitbox(struct kinematic_obj *obj){
approach(&obj->dim_reduction[2], obj->set_dim_reduction[2], 0.2);
approach(&obj->dim_reduction[3], obj->set_dim_reduction[3], 0.2);
}
// Placeholder collision checking structure. Use linked list for now
// Need to implement some sort of tree structure for efficient collision checking
void add_kinematic_node(struct kinematic_obj *obj, struct kinematic_obj_node **HEAD){
struct kinematic_obj_node *node = malloc(sizeof(struct kinematic_obj_node));
if (node){
node->obj = obj;
node->next = NULL;
}
if (*HEAD != NULL)
node->next = *HEAD;
*HEAD = node;
}
/**struct kinematic_obj_node **get_list(){
return &kinematic_HEAD;
}*/
void free_kinematic_list(struct kinematic_obj_node **HEAD){
struct kinematic_obj_node *current = *HEAD;
struct kinematic_obj_node *next;
while(current){
next = current->next;
current->next = NULL;
free(current);
current = next;
}
*HEAD = NULL;
}

60
obj/player.c
View File

@ -321,4 +321,62 @@ void player_input_check(struct player_obj *player){
player->image->color.b = 255;
else
player->image->color.b = 0;
}
}
void create_afterimage(struct player_obj *player, Color color){
struct afterImage *img = malloc(sizeof(struct afterImage));
if (img){
for (int i=0;i<=BEZIER_POINTS;++i){
img->top_vertices[i] = player->image->top_vertices[i];
img->bottom_vertices[i] = player->image->bottom_vertices[i];
img->left_vertices[i] = player->image->left_vertices[i];
img->right_vertices[i] = player->image->right_vertices[i];
}
img->pos = (Vector2){player->image->center.x, player->image->center.y};
img->velocity = (Vector2){player->kinematic.velocity.x, player->kinematic.velocity.y};
img->opacity = 1.0;
img->color = color;
img->prev = NULL;
if (player->after_img_head == NULL){
img->next = NULL;
player->after_img_head = img;
player->after_img_tail = img;
}else{
img->next = player->after_img_head;
player->after_img_head->prev = img;
player->after_img_head = img;
}
}
}
void remove_last_afterimage(struct player_obj *player){
struct afterImage *last;
if (player->after_img_tail != NULL){
if (player->after_img_tail->opacity <= 0){
last = player->after_img_tail;
player->after_img_tail = player->after_img_tail->prev;
last->prev = NULL;
free(last);
}
// This happens if the last tail is the head
if (player->after_img_tail == NULL){
player->after_img_head = NULL;
}else{
player->after_img_tail->next = NULL;
}
}
}
void free_afterimages(struct player_obj *player){
struct afterImage *current = player->after_img_head;
struct afterImage *next;
while(current != NULL){
next = current->next;
current->next = NULL;
current->prev = NULL;
free(current);
current = next;
}
player->after_img_head = NULL;
player->after_img_tail = NULL;
}

24
obj/target.c
View File

@ -44,4 +44,28 @@ bool collide_target(struct kinematic_obj *obj, struct target_obj *target){
if (!(max_proj < target_proj - target->radius) && !(min_proj > target_proj + target->radius))
return true;
return false;
}
void add_target_node(struct target_obj *obj, struct target_obj_node **HEAD){
struct target_obj_node *node = malloc(sizeof(struct target_obj_node));
if (node){
node->obj = obj;
node->next = NULL;
}
if (*HEAD != NULL)
node->next = *HEAD;
*HEAD = node;
}
void free_target_list(struct target_obj_node **HEAD){
struct target_obj_node *current = *HEAD;
struct target_obj_node *next;
while(current){
next = current->next;
current->next = NULL;
free(current);
current = next;
}
*HEAD = NULL;
}

91
utilities/linked_list.c
View File

@ -1,91 +0,0 @@
#include "header.h"
#include <stdlib.h>
// Placeholder collision checking structure. Use linked list for now
// Need to implement some sort of tree structure for efficient collision checking
void add_node(struct kinematic_obj *obj, struct kinematic_obj_node **HEAD){
struct kinematic_obj_node *node = malloc(sizeof(struct kinematic_obj_node));
if (node){
node->obj = obj;
node->next = NULL;
}
if (*HEAD != NULL)
node->next = *HEAD;
*HEAD = node;
}
/**struct kinematic_obj_node **get_list(){
return &kinematic_HEAD;
}*/
void free_list(struct kinematic_obj_node **HEAD){
struct kinematic_obj_node *current = *HEAD;
struct kinematic_obj_node *next;
while(current){
next = current->next;
current->next = NULL;
free(current);
current = next;
}
*HEAD = NULL;
}
void create_afterimage(struct player_obj *player, Color color){
struct afterImage *img = malloc(sizeof(struct afterImage));
if (img){
for (int i=0;i<=BEZIER_POINTS;++i){
img->top_vertices[i] = player->image->top_vertices[i];
img->bottom_vertices[i] = player->image->bottom_vertices[i];
img->left_vertices[i] = player->image->left_vertices[i];
img->right_vertices[i] = player->image->right_vertices[i];
}
img->pos = (Vector2){player->image->center.x, player->image->center.y};
img->velocity = (Vector2){player->kinematic.velocity.x, player->kinematic.velocity.y};
img->opacity = 1.0;
img->color = color;
img->prev = NULL;
if (player->after_img_head == NULL){
img->next = NULL;
player->after_img_head = img;
player->after_img_tail = img;
}else{
img->next = player->after_img_head;
player->after_img_head->prev = img;
player->after_img_head = img;
}
}
}
void remove_last_afterimage(struct player_obj *player){
struct afterImage *last;
if (player->after_img_tail != NULL){
if (player->after_img_tail->opacity <= 0){
last = player->after_img_tail;
player->after_img_tail = player->after_img_tail->prev;
last->prev = NULL;
free(last);
}
// This happens if the last tail is the head
if (player->after_img_tail == NULL){
player->after_img_head = NULL;
}else{
player->after_img_tail->next = NULL;
}
}
}
void free_afterimages(struct player_obj *player){
struct afterImage *current = player->after_img_head;
struct afterImage *next;
while(current != NULL){
next = current->next;
current->next = NULL;
current->prev = NULL;
free(current);
current = next;
}
player->after_img_head = NULL;
player->after_img_tail = NULL;
}