alexandre
/
MarioPartyMaker
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
MarioPartyMaker/src/edit.c

535 lines
19 KiB
C
Raw Blame History

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <math.h>
#include <stdbool.h>
#include <ncurses.h>
#include <unistd.h>
#include <termios.h>
#include <limits.h>
#include <time.h>
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include "consts.h"
#include "base.h"
#include "display.h"
#include "edit.h"
int edit_cell_count = 2;
cell** all_loaded_cells;
int n_loaded = -1;
int zoom_factor = 200 ;
void link_cells(cell* parent, cell* child) {
if(parent != NULL) {
if(parent->next_1 == NULL) {
parent->next_1 = child;
} else if(parent->next_2 == NULL) {
parent->next_2 = child;
} else if(parent->next_3 == NULL) {
parent->next_3 = child;
} else if(parent->next_4 == NULL) {
parent->next_4 = child;
} else {
fprintf(stderr, "Unable to link cell : parent is at full capacity.\n");
}
};
if(child != NULL) {
if(child->prev_1 == NULL) {
child->prev_1 = parent;
} else if(child->prev_2 == NULL) {
child->prev_2 = parent;
} else if(child->prev_3 == NULL) {
child->prev_3 = parent;
} else if(child->prev_4 == NULL) {
child->prev_4 = parent;
} else {
fprintf(stderr, "Unable to link cell : child is at full capacity.\n");
}
}
}
void unlink_cells(cell* parent, cell* child) {
if(parent != NULL) {
if(parent->next_1 == child) {
parent->next_1 = NULL;
} else if(parent->next_2 == child) {
parent->next_2 = NULL;
} else if(parent->next_3 == child) {
parent->next_3 = NULL;
} else if(parent->next_4 == child) {
parent->next_4 = NULL;
} else {
fprintf(stderr, "Unable to unlink cell : no link found.\n");
}
};
if(child != NULL) {
if(child->prev_1 == parent) {
child->prev_1 = NULL;
} else if(child->prev_2 == parent) {
child->prev_2 = NULL;
} else if(child->prev_3 == parent) {
child->prev_3 = NULL;
} else if(child->prev_4 == parent) {
child->prev_4 = NULL;
} else {
fprintf(stderr, "Unable to unlink cell : no link found.\n");
}
};
}
cell* redirect_cell(cell* cl) {
if(cl != NULL) {
if(cl->prev_1 != NULL) {
return cl->prev_1;
} else if(cl->prev_2 != NULL) {
return cl->prev_2;
} else if(cl->prev_3 != NULL) {
return cl->prev_3;
} else if(cl->prev_4 != NULL) {
return cl->prev_4;
} else {
fprintf(stderr, "Unable to redirect cell : no parent.\n");
}
}
}
void append_cell(int cell_type, int X, int Y, cell* parent) {
cell* new = malloc(sizeof(cell));
new->id = parent->id; // mostly for parkour
new->unique_id = edit_cell_count;
new->coord_x = X;
new->coord_y = Y;
new->star_allowed = is_star_allowed(cell_type);
new->type = (CELLTYPE)cell_type ;
new->prev_1 = NULL ;
new->prev_2 = NULL;
new->prev_3 = NULL;
new->prev_4 = NULL;
new->next_1 = NULL;
new->next_2 = NULL;
new->next_3 = NULL;
new->next_4 = NULL;
char* meta = "none";
edit_cell_count += 1;
link_cells(parent, new);
cell_count[cell_type] += 1;
}
void append_cell_orthogonal(int cell_type, char dir, cell* parent) {
if(dir == 'N' || dir == 'n') {
append_cell(cell_type, parent->coord_x, parent->coord_y + tile_size * 2, parent);
} else if(dir == 'E' || dir == 'e') {
append_cell(cell_type, parent->coord_x + tile_size * 2, parent->coord_y, parent);
} else if(dir == 'W' || dir == 'w') {
append_cell(cell_type, parent->coord_x - tile_size * 2, parent->coord_y, parent);
} else if(dir == 'S' || dir == 's') {
append_cell(cell_type, parent->coord_x, parent->coord_y - tile_size * 2, parent);
} else {
fprintf(stderr, "ERROR : invalid direction (%d)", dir);
}
}
void destroy_cell() {
cell* new_current = redirect_cell(current);
unlink_cells(current, current->next_1);
unlink_cells(current, current->next_2);
unlink_cells(current, current->next_3);
unlink_cells(current, current->next_4);
unlink_cells(current->prev_1, current);
unlink_cells(current->prev_2, current);
unlink_cells(current->prev_3, current);
unlink_cells(current->prev_4, current);
cell_count[(int)current->type] -= 1;
free(current);
current = new_current ;
}
bool isAdding = false ;
int editBuffer = 0 ;
int phase = 0 ;
int editCellType = 0 ;
int editDirection = 0 ;
// -------------------------------- //
bool isLinking = false ;
cell* par ;
cell* chd ;
// -------------------------------- //
bool confirmRemove = false ;
bool cooldownRemove = false ;
void playerEditActions(bool* finished) {
SDL_Event event;
while(SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_QUIT:
break;
case SDL_KEYDOWN:
if(cooldownRemove) {
cooldownRemove = false;
} else {
confirmRemove = false ;
};
switch (event.key.keysym.sym) {
case SDLK_1:
if(!isAdding && current->next_1 != NULL) {
current = current->next_1;
} else if (isAdding) {
editBuffer *= 10;
editBuffer += 1;
};
break;
case SDLK_2:
if(!isAdding && current->next_2 != NULL) {
current = current->next_2;
} else if (isAdding) {
editBuffer *= 10;
editBuffer += 2;
};
break;
case SDLK_3:
if(!isAdding && current->next_3 != NULL) {
current = current->next_3;
} else if (isAdding) {
editBuffer *= 10;
editBuffer += 3;
};
break;
case SDLK_4:
if(!isAdding && current->next_4 != NULL) {
current = current->next_4;
} else if (isAdding) {
editBuffer *= 10;
editBuffer += 4;
};
break;
case SDLK_0:
if(!isAdding && current->prev_1 != NULL) {
current = current->prev_1;
} else if (isAdding) {
editBuffer *= 10;
};
break;
case SDLK_9:
if(!isAdding && current->prev_2 != NULL) {
current = current->prev_2;
} else if (isAdding) {
editBuffer *= 10;
editBuffer += 9;
};
break;
case SDLK_8:
if(!isAdding && current->prev_3 != NULL) {
current = current->prev_3;
} else if (isAdding) {
editBuffer *= 10;
editBuffer += 8;
};
break;
case SDLK_7:
if(!isAdding && current->prev_4 != NULL) {
current = current->prev_4;
} else if (isAdding) {
editBuffer *= 10;
editBuffer += 7;
};
break;
case SDLK_6:
if (isAdding) {
editBuffer *= 10;
editBuffer += 6;
};
break;
case SDLK_5:
if (isAdding) {
editBuffer *= 10;
editBuffer += 5;
};
break;
case SDLK_BACKSPACE:
if (isAdding) {
editBuffer = editBuffer / 10;
};
break;
case SDLK_SPACE:
if(isAdding) {
if(phase == 0) {
editCellType = editBuffer%n_cell_type;
} else if(phase == 1) {
editDirection = editBuffer%4;
phase = -1;
isAdding = false;
char dir ;
if(editDirection == 0) {
dir = 's';
} else if(editDirection == 1) {
dir = 'e';
} else if(editDirection == 2) {
dir = 'n';
} else if(editDirection == 3) {
dir = 'w';
};
append_cell_orthogonal(editCellType, dir, current);
};
phase += 1;
editBuffer = 0;
}
else if(isLinking) {
if(phase == 0) {
par = current ;
} else if(phase == 1) {
if(current != par) {
chd = current;
link_cells(par, chd);
phase = -1;
isLinking = false;
} else {
phase -= 1;
}
};
phase += 1;
};
break;
case SDLK_p:
if(!isLinking) {
isAdding = true ;
phase = 0 ;
printf("now adding...\n");
};
break;
case SDLK_l:
if(!isAdding) {
isLinking = true;
phase = 0 ;
printf("now linking...\n");
};
break;
case SDLK_r:
if(!confirmRemove) {
confirmRemove = true ;
cooldownRemove = true ;
} else {
destroy_cell();
confirmRemove = false ;
cooldownRemove = false ;
};
break;
case SDLK_TAB:
if(isAdding || isLinking || confirmRemove) {
isAdding = false;
isLinking = false;
confirmRemove = false;
cooldownRemove = false ;
} else {
*finished = true;
};
break;
case SDLK_s:
save("level.csv");
printf("Saved level\n");
break;
case SDLK_q:
load("level.csv");
printf("loaded level\n");
break;
case SDLK_F2:
zoom_factor = min(zoom_factor + 50, 1250) ;
break;
case SDLK_F3:
zoom_factor = max(zoom_factor - 50, 50) ;
break;
case SDLK_e:
current->type = (CELLTYPE)(((int)current->type +1)%n_cell_type);
break;
}
}
}
}
void draw_types(SDL_Renderer* renderer) {
drawStringToRenderer(renderer, letters, "start", __width__ - 6 * 75/2, 50, 75/2, 105/2);
drawStringToRenderer(renderer, letters, "blue", __width__ - 5 * 75/2, 100, 75/2, 105/2);
drawStringToRenderer(renderer, letters, "red", __width__ - 4 * 75/2, 150, 75/2, 105/2);
drawStringToRenderer(renderer, letters, "event", __width__ - 6 * 75/2, 200, 75/2, 105/2);
drawStringToRenderer(renderer, letters, "vs", __width__ - 3 * 75/2, 250, 75/2, 105/2);
drawStringToRenderer(renderer, letters, "bowser", __width__ - 7 * 75/2, 300, 75/2, 105/2);
drawStringToRenderer(renderer, letters, "chance", __width__ - 7 * 75/2, 350, 75/2, 105/2);
drawStringToRenderer(renderer, letters, "boo", __width__ - 4 * 75/2, 400, 75/2, 105/2);
drawStringToRenderer(renderer, letters, "star", __width__ - 5 * 75/2, 450, 75/2, 105/2);
drawStringToRenderer(renderer, letters, "bank", __width__ - 5 * 75/2, 500, 75/2, 105/2);
drawStringToRenderer(renderer, letters, "shop", __width__ - 5 * 75/2, 550, 75/2, 105/2);
}
void draw_directions(SDL_Renderer* renderer) {
drawStringToRenderer(renderer, letters, "north", __width__ - 6 * 75/2, 50, 75/2, 105/2);
drawStringToRenderer(renderer, letters, "east", __width__ - 5 * 75/2, 100, 75/2, 105/2);
drawStringToRenderer(renderer, letters, "south", __width__ - 6 * 75/2, 150, 75/2, 105/2);
drawStringToRenderer(renderer, letters, "west", __width__ - 5 * 75/2, 200, 75/2, 105/2);
}
void edit_main(SDL_Renderer* renderer) {
bool finished = false;
while(!finished) {
resetRenderer(renderer);
draw_board(renderer, current->coord_x - zoom_factor, current->coord_x + zoom_factor, current->coord_y - zoom_factor, current->coord_y + zoom_factor, current);
if(isAdding) {
drawStringToRenderer(renderer, letters, "add cell", 50, __height__ - 50, 75/2, 105/2);
if(phase == 0) {
drawStringToRenderer(renderer, letters, "choose type", 50, 50, 75/2, 105/2);
draw_types(renderer);
} else {
drawStringToRenderer(renderer, letters, "choose direction", 50, 50, 75/2, 105/2);
draw_directions(renderer);
};
drawNumberToRenderer(renderer, digits, editBuffer, 50, 150, 75/2, 105/2, 0);
}
else if(isLinking) {
drawStringToRenderer(renderer, letters, "link cells", 50, __height__ - 50, 75/2, 105/2);
if(phase == 0) {
drawStringToRenderer(renderer, letters, "choose parent", 50, 50, 75/2, 105/2);
} else {
drawStringToRenderer(renderer, letters, "choose child", 50, 50, 75/2, 105/2);
}
} else if(confirmRemove) {
drawStringToRenderer(renderer, letters, "press r again to remove", 50, __height__ - 50, 75/2, 105/2);
};
updateRenderer(renderer);
playerEditActions(&finished);
usleep(20000);
}
}
// save/load level
void reassign_id_cell(cell* cl, int* current, int common) {
if(cl != NULL && cl->id != 60000) {
cl->unique_id = *current;
*current += 1;
cl->id = 60000;
reassign_id_cell(cl->next_1, current, common);
reassign_id_cell(cl->next_2, current, common);
reassign_id_cell(cl->next_3, current, common);
reassign_id_cell(cl->next_4, current, common);
}
}
void reassign_ids() {
int p = 1 ;
reassign_id_cell(start, &p, start->id);
}
void write_cell(FILE* ptr, cell* cl, int global_id) {
if(cl != NULL && cl->id == global_id) {
printf("saving cell %d\n", cl->unique_id);
cl->id = global_id+1;
fprintf(ptr, "%d,%d,%d,%d,%d[", cl->unique_id, (int)cl->type, cl->coord_x, cl->coord_y, (int)cl->star_allowed);
printf("%d,%d,%d,%d,%d[", cl->unique_id, (int)cl->type, cl->coord_x, cl->coord_y, (int)cl->star_allowed);
if(cl->next_1 != NULL) {
fprintf(ptr, "%d,", cl->next_1->unique_id);
printf("%d,", cl->next_1->unique_id);
};
if(cl->next_2 != NULL) {
fprintf(ptr, "%d,", cl->next_2->unique_id);
printf("%d,", cl->next_2->unique_id);
};
if(cl->next_3 != NULL) {
fprintf(ptr, "%d,", cl->next_3->unique_id);
printf("%d,", cl->next_3->unique_id);
};
if(cl->next_4 != NULL) {
fprintf(ptr, "%d,", cl->next_4->unique_id);
printf("%d,", cl->next_4->unique_id);
};
fprintf(ptr, "]\n");
printf("]\n");
write_cell(ptr, cl->next_1, global_id);
write_cell(ptr, cl->next_2, global_id);
write_cell(ptr, cl->next_3, global_id);
write_cell(ptr, cl->next_4, global_id);
}
}
void save(char* filename) {
reassign_ids();
FILE* ptr = fopen(filename, "w");
write_cell(ptr, start, start->id);
fclose(ptr);
}
// fprintf(ptr, "%d,%d,%d,%d,%d[", cl->unique_id, (int)cl->type, cl->coord_x, cl->coord_y, (int)cl->star_allowed);
void load(char* filename) {
n_loaded = line_count(filename) -1;
all_loaded_cells = malloc(sizeof(cell*)*n_loaded);
all_loaded_cells[0] = start;
for(int i = 0; i < n_loaded; i++) {
if(i != 0) {
all_loaded_cells[i] = malloc(sizeof(cell));
};
all_loaded_cells[i]->next_1 = NULL;
all_loaded_cells[i]->next_2 = NULL;
all_loaded_cells[i]->next_3 = NULL;
all_loaded_cells[i]->next_4 = NULL;
all_loaded_cells[i]->prev_1 = NULL;
all_loaded_cells[i]->prev_2 = NULL;
all_loaded_cells[i]->prev_3 = NULL;
all_loaded_cells[i]->prev_4 = NULL;
};
FILE* ptr = fopen(filename, "r");
char burn;
printf("Loading %d lines...\n", n_loaded);
for(int i = 0; i < n_loaded; i++) {
printf("%d\n", i);
int unique = get_integer(ptr);
int a_type = get_integer(ptr);
int cx = get_integer(ptr);
int cy = get_integer(ptr);
int ok_star = get_integer(ptr);
//printf(" %d, %d, %d, %d, %d\n", unique, a_type, cx, cy, ok_star);
all_loaded_cells[i]->unique_id = unique;
all_loaded_cells[i]->type = (CELLTYPE)a_type;
all_loaded_cells[i]->coord_x = cx;
all_loaded_cells[i]->coord_y = cy;
all_loaded_cells[i]->star_allowed = (bool)ok_star;
int current_link = get_integer(ptr);
while(current_link > 0) {
link_cells(all_loaded_cells[i], all_loaded_cells[current_link-1]);
//printf(" linking %d <--> %d", i, current_link -1);
current_link = get_integer(ptr);
};
if(i != n_loaded -1) {
terminate_line(ptr);
}
};
current = start;
edit_cell_count = n_loaded;
fclose(ptr);
}
Reference in New Issue View Git Blame Copy Permalink