746 lines
26 KiB
C
746 lines
26 KiB
C
#include <SDL2/SDL.h>
|
|
#include <stdio.h>
|
|
#include <time.h>
|
|
#include "util/font.h"
|
|
#include "util/audio.h"
|
|
#include "tiles/tile.h"
|
|
#include "items/item.h"
|
|
#include "stdlib.h"
|
|
#include "player/player.h"
|
|
#include "util/perlin.h"
|
|
#include "util/atlas.h"
|
|
#include "entity/entity.h"
|
|
|
|
typedef struct GameState {
|
|
Player player;
|
|
Tile tileMap[MAP_HEIGHT][MAP_WIDTH];
|
|
BackgroundTile backgroundTileMap[MAP_HEIGHT][MAP_WIDTH];
|
|
AudioData audioData;
|
|
TileArray neededUpdates;
|
|
EntityArray entities;
|
|
Node openList[MAX_OPEN_NODES];
|
|
int openCount;
|
|
} GameState;
|
|
GameState gameState;
|
|
|
|
int loadGameState(char *filename, Player *plr) {
|
|
printf("hello from load\n");
|
|
fflush(stdout);
|
|
FILE *gameSave = fopen(filename, "rb");
|
|
if (gameSave) {
|
|
fseek(gameSave, 0L, SEEK_END);
|
|
long sz = ftell(gameSave);
|
|
if (sz != sizeof(gameState)) {
|
|
return 1;
|
|
}
|
|
rewind(gameSave);
|
|
fread(&gameState, sizeof(gameState), 1, gameSave);
|
|
fclose(gameSave);
|
|
memcpy(plr, &gameState.player, sizeof(gameState.player));
|
|
memcpy(tileMap, gameState.tileMap, sizeof(tileMap));
|
|
memcpy(backgroundMap, gameState.backgroundTileMap, sizeof(backgroundMap));
|
|
SDL_Rect *tmp = audioData.playerRect;
|
|
memcpy(&audioData, &gameState.audioData, sizeof(gameState.audioData));
|
|
audioData.playerRect = tmp;
|
|
audioData.totalSamples = 0;
|
|
memcpy(&neededUpdates, &gameState.neededUpdates, sizeof(gameState.neededUpdates));
|
|
memcpy(&entities, &gameState.entities, sizeof(gameState.entities));
|
|
openCount = gameState.openCount;
|
|
memcpy(&openList, &gameState.openList, sizeof(gameState.openList));
|
|
plr->cursor.targetTile = NULL;
|
|
plr->cursor.prevTargetTile = NULL;
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void saveGameState(char *filename, Player *plr) {
|
|
memcpy(&gameState.player, plr, sizeof(gameState.player));
|
|
memcpy(gameState.tileMap, tileMap, sizeof(gameState.tileMap));
|
|
memcpy(gameState.backgroundTileMap, backgroundMap, sizeof(gameState.backgroundTileMap));
|
|
memcpy(&gameState.audioData, &audioData, sizeof(gameState.audioData));
|
|
memcpy(&gameState.neededUpdates, &neededUpdates, sizeof(neededUpdates));
|
|
memcpy(&gameState.entities, &entities, sizeof(entities));
|
|
memcpy(&gameState.openList, &openList, sizeof(openList));
|
|
gameState.openCount = openCount;
|
|
|
|
FILE *gameSave = fopen(filename, "wb");
|
|
if (!gameSave) {
|
|
perror("Failed to open file for saving");
|
|
return;
|
|
}
|
|
|
|
fwrite(&gameState, sizeof(gameState), 1, gameSave);
|
|
fclose(gameSave);
|
|
}
|
|
|
|
Player player;
|
|
|
|
//Screen dimension constants
|
|
const int targetFPS = 60;
|
|
const int delayNeeded = 1000 / targetFPS;
|
|
|
|
#define biggerFont fonts[0]
|
|
#define smallFont fonts[1]
|
|
#define smallerFont fonts[2]
|
|
#define smallestFont fonts[3]
|
|
|
|
char *autosaveName = "autosave.dat";
|
|
|
|
|
|
unsigned long frames = 0;
|
|
bool cursor = true;
|
|
|
|
void msleep(unsigned int milliseconds) {
|
|
struct timespec ts;
|
|
ts.tv_sec = milliseconds / 1000;
|
|
ts.tv_nsec = (milliseconds % 1000) * 1000000;
|
|
nanosleep(&ts, NULL);
|
|
}
|
|
|
|
SDL_GLContext glContext;
|
|
|
|
void genInitMap();
|
|
|
|
int init() {
|
|
//Initialize SDL
|
|
|
|
|
|
screenRect.x = 0;
|
|
screenRect.y = 0;
|
|
screenRect.w = DISPLAY_WIDTH;
|
|
screenRect.h = DISPLAY_HEIGHT;
|
|
|
|
srand(time(NULL));
|
|
|
|
memset(tileMap, 0, sizeof(tileMap));
|
|
memset(&neededUpdates, 0, sizeof(neededUpdates));
|
|
|
|
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, NULL);
|
|
SDL_SetHint(SDL_HINT_VIDEO_HIGHDPI_DISABLED, "1");
|
|
SDL_SetHint(SDL_HINT_RENDER_BATCHING, "1");
|
|
SDL_SetHint(SDL_HINT_RENDER_DRIVER, "opengl");
|
|
SDL_SetHint(SDL_HINT_MOUSE_RELATIVE_CURSOR_VISIBLE, "1");
|
|
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0) {
|
|
printf("SDL could not initialize! SDL_Error: %s\n", SDL_GetError());
|
|
return 1;
|
|
}
|
|
|
|
//Initialize SDL_ttf
|
|
if (TTF_Init() == -1) {
|
|
printf("SDL_ttf could not initialize! SDL_ttf Error: %s\n", TTF_GetError());
|
|
return 1;
|
|
}
|
|
|
|
//Create window
|
|
window = SDL_CreateWindow("Factory game", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, DISPLAY_WIDTH,
|
|
DISPLAY_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
|
|
|
|
if (window == NULL) {
|
|
printf("Window could not be created! SDL_Error: %s\n", SDL_GetError());
|
|
return 1;
|
|
}
|
|
//Get window surface
|
|
mainRenderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
|
|
if (mainRenderer == NULL) {
|
|
printf("Renderer could not be created SDL_Error: %s\n", SDL_GetError());
|
|
return 1;
|
|
}
|
|
|
|
initAtlas(mainRenderer);
|
|
|
|
loadBackgroundTiles(mainRenderer);
|
|
loadTiles(mainRenderer);
|
|
loadItems(mainRenderer);
|
|
loadEntities(mainRenderer);
|
|
|
|
Entity entTest;
|
|
memset(&entTest, 0, sizeof(Entity));
|
|
entTest.tileRect.x = 4;
|
|
entTest.tileRect.y = 5;
|
|
entTest.renderRect.w = TILE_SIZE;
|
|
entTest.renderRect.h = TILE_SIZE;
|
|
entTest.target.x = 0;
|
|
entTest.target.y = 0;
|
|
entTest.health = 100;
|
|
entTest.type = GHOST;
|
|
add_entity(&entities, entTest);
|
|
|
|
setupTiles();
|
|
|
|
// for (ItemType i = 0; i < ITEMREGISTRY_SIZE; i++) {
|
|
// if (strlen(ItemRegistry[i].name)) {
|
|
// printf("%d -> %s\n", i, ItemRegistry[i].name);
|
|
// }
|
|
// }
|
|
// Create OpenGL context
|
|
glContext = SDL_GL_CreateContext(window);
|
|
if (!glContext) {
|
|
fprintf(stderr, "SDL_GL_CreateContext failed: %s\n", SDL_GetError());
|
|
exit(1);
|
|
}
|
|
|
|
// Use OpenGL context
|
|
SDL_GL_MakeCurrent(window, glContext); // Make sure OpenGL context is current before any OpenGL rendering
|
|
|
|
audioData.playerRect = &player.rect;
|
|
audioData.maxPanDistance = DISPLAY_WIDTH / 2;
|
|
|
|
SDL_AudioSpec spec = {0};
|
|
spec.freq = SAMPLE_RATE;
|
|
spec.format = AUDIO_F32;
|
|
spec.channels = 2;
|
|
spec.samples = 4096;
|
|
spec.callback = audio_callback;
|
|
spec.userdata = &audioData;
|
|
|
|
SDL_AudioDeviceID dev = SDL_OpenAudioDevice(NULL, 0, &spec, NULL, 0);
|
|
if (dev == 0) {
|
|
printf("Failed to open audio: %s\n", SDL_GetError());
|
|
SDL_Quit();
|
|
}
|
|
|
|
for (int t = 0; t < MIDI_TRACK_MAX; t++) {
|
|
midiEventCount[t] = 0;
|
|
nextMidiEvent[t] = 0;
|
|
}
|
|
|
|
|
|
load_midi_file("assets/audio/testaid.mid");
|
|
load_midi_file("assets/audio/bg.mid");
|
|
|
|
SDL_PauseAudioDevice(dev, 0);
|
|
|
|
|
|
SDL_SetRenderDrawColor(mainRenderer, 0, 0, 0, 255);
|
|
SDL_RenderClear(mainRenderer);
|
|
|
|
SDL_Rect viewport = {0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT};
|
|
SDL_RenderSetViewport(mainRenderer, &viewport);
|
|
|
|
SDL_SetRenderDrawBlendMode(mainRenderer, SDL_BLENDMODE_BLEND);
|
|
biggerFont = prepText(mainRenderer, 16, "assets/PublicPixel.ttf", 255, 255, 255, 255);
|
|
smallFont = prepText(mainRenderer, 12, "assets/PublicPixel.ttf", 255, 255, 255, 255);
|
|
smallerFont = prepText(mainRenderer, 8, "assets/PublicPixel.ttf", 255, 255, 255, 255);
|
|
smallestFont = prepText(mainRenderer, 4, "assets/PublicPixel.ttf", 255, 255, 255, 255);
|
|
SDL_RenderSetLogicalSize(mainRenderer, DISPLAY_WIDTH, DISPLAY_HEIGHT);
|
|
|
|
initPlayer(&player);
|
|
|
|
for (ItemType i = 0; i < 13; i++) {
|
|
player.inventory.hotKeySlots[i] = i;
|
|
}
|
|
|
|
initTiles();
|
|
|
|
//generateTestMap();
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int render() {
|
|
SDL_SetRenderDrawColor(mainRenderer, 32, 32, 32, 255);
|
|
SDL_RenderClear(mainRenderer);
|
|
|
|
SDL_Rect rect2;
|
|
rect2.x = 0;
|
|
rect2.y = 0;
|
|
rect2.w = ATLAS_SIZE;
|
|
rect2.h = ATLAS_SIZE;
|
|
|
|
renderAllTiles(mainRenderer, player.rect);
|
|
renderEntities(mainRenderer, player.rect);
|
|
renderPlayer(&player);
|
|
|
|
|
|
if (!renderAtlas) {
|
|
SDL_RenderCopy(mainRenderer, backgroundTexture, &screenRect, &screenRect);
|
|
SDL_RenderCopy(mainRenderer, tilesTexture, &screenRect, &screenRect);
|
|
SDL_RenderCopy(mainRenderer, itemsTexture, &screenRect, &screenRect);
|
|
SDL_RenderCopy(mainRenderer, entityTexture, &screenRect, &screenRect);
|
|
SDL_RenderCopy(mainRenderer, hudTexture, &screenRect, &screenRect);
|
|
|
|
} else {
|
|
SDL_RenderCopy(mainRenderer, atlasTexture, &rect2, &rect2);
|
|
}
|
|
|
|
|
|
SDL_RenderPresent(mainRenderer);
|
|
frames++;
|
|
if (!(frames % 60)) {
|
|
cursor = !cursor;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
int processEvent(SDL_Event e) {
|
|
if (e.type == SDL_QUIT) { return 0; }
|
|
else if (e.type == SDL_WINDOWEVENT && e.window.event == SDL_WINDOWEVENT_RESIZED) {
|
|
int newWidth = e.window.data1;
|
|
int newHeight = e.window.data2;
|
|
|
|
// Adjust the viewport to match the new window size;
|
|
SDL_Rect viewport = {0, 0, newWidth, newHeight};
|
|
SDL_RenderSetViewport(mainRenderer, &viewport);
|
|
} else if (e.type == SDL_KEYDOWN) {
|
|
SDL_KeyCode keySym = e.key.keysym.sym;
|
|
SDL_Scancode scanCode = e.key.keysym.scancode;
|
|
SDL_Keymod keyMod = e.key.keysym.mod;
|
|
cursor = true;
|
|
switch (keySym) {
|
|
case SDLK_p:
|
|
speed = speed == 0 ? 0.004f : 0;
|
|
break;
|
|
case SDLK_r:
|
|
if (player.inventory.activeSlotIndex == 0 && player.cursor.canReach &&
|
|
player.cursor.targetTile->type != TYPE_AIR) {
|
|
player.cursor.direction = player.cursor.targetTile->direction;
|
|
}
|
|
player.cursor.direction = (player.cursor.direction + 2) % ORIENT_DIRECTION_COUNT;
|
|
if (player.inventory.activeSlotIndex == 0 && player.cursor.canReach) {
|
|
player.cursor.targetTile->direction = player.cursor.direction;
|
|
}
|
|
break;
|
|
case SDLK_u:
|
|
laneTarget = !laneTarget;
|
|
break;
|
|
case SDLK_F3:
|
|
debugMode = !debugMode;
|
|
break;
|
|
case SDLK_F10:
|
|
renderAtlas = !renderAtlas;
|
|
break;
|
|
case SDLK_F4:
|
|
Tile *tile = &tileMap[playerTileY][playerTileX];
|
|
break;
|
|
case SDLK_LALT:
|
|
itemViewing = !itemViewing;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
} else if (e.type == SDL_MOUSEWHEEL) {
|
|
int dAmount = 0;
|
|
if (e.wheel.y > 0) {
|
|
dAmount = 1;
|
|
} else if (e.wheel.y < 0) {
|
|
dAmount = -1;
|
|
}
|
|
const Uint8 *keyboardState = SDL_GetKeyboardState(NULL);
|
|
if (keyboardState[SDL_SCANCODE_LCTRL] || keyboardState[SDL_SCANCODE_RCTRL]) {
|
|
// currentScale += dAmount / 10.0f;
|
|
// if (currentScale > 4) {
|
|
// currentScale = 4;
|
|
// } else if (currentScale < 0.5f) {
|
|
// currentScale = 0.5f;
|
|
// }
|
|
//setZoom(currentScale);
|
|
|
|
|
|
} else {
|
|
moveActivePlayerSlot(&player, dAmount == -1,
|
|
!(keyboardState[SDL_SCANCODE_LSHIFT] || keyboardState[SDL_SCANCODE_RSHIFT]));
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void processMousePosition() {
|
|
SDL_Rect viewport;
|
|
SDL_RenderGetViewport(mainRenderer, &viewport);
|
|
|
|
uint32_t mouseButtons = SDL_GetMouseState(&player.cursor.windowX, &player.cursor.windowY);
|
|
if (mouseButtons & SDL_BUTTON_LMASK) {
|
|
if (player.cursor.canReach && player.cursor.targetTile->type == TYPE_AIR &&
|
|
player.inventory.activeSlotIndex < tileTypeIndex) {
|
|
if (player.inventory.slotCounts[player.inventory.activeSlotIndex] > 0) {
|
|
player.inventory.slotCounts[player.inventory.activeSlotIndex]--;
|
|
player.cursor.targetTile->type = player.inventory.activeSlotIndex;
|
|
player.cursor.targetTile->health = TileRegistry[player.inventory.activeSlotIndex].maxHealth;
|
|
player.cursor.targetTile->rect.x = player.cursor.tileX;
|
|
player.cursor.targetTile->rect.y = player.cursor.tileY;
|
|
if (TileRegistry[player.inventory.activeSlotIndex].needsTicks) {
|
|
player.cursor.targetTile->neededUpdateIndex = add_tile(&neededUpdates,
|
|
player.cursor.targetTile->rect);
|
|
}
|
|
player.cursor.targetTile->direction = player.cursor.direction;
|
|
}
|
|
} else if (player.cursor.targetTile->type == player.inventory.activeSlotIndex) {
|
|
player.cursor.targetTile->direction = player.cursor.direction;
|
|
}
|
|
}
|
|
if (player.cursor.canReach && mouseButtons & SDL_BUTTON_RMASK) {
|
|
int tileIndex = player.cursor.targetTile->type;
|
|
uint16_t targetBreakTime = TileRegistry[tileIndex].breakTime;
|
|
if (targetBreakTime) {
|
|
if (player.cursor.breakingProgress >= targetBreakTime) {
|
|
if (player.cursor.targetTile->type < tileTypeIndex) {
|
|
player.inventory.slotCounts[player.cursor.targetTile->type]++;
|
|
}
|
|
for (int lane = 0; lane < 2; lane++) {
|
|
if (player.cursor.targetTile->items[lane].type != 0) {
|
|
int itemType = player.cursor.targetTile->items[lane].type;
|
|
if (itemType < itemRegistryIndex) {
|
|
player.inventory.slotCounts[itemType]++;
|
|
}
|
|
player.cursor.targetTile->items[lane].type = 0;
|
|
}
|
|
}
|
|
audioData.synthVoices[player.cursor.targetTile->audioCh].volume = 0;
|
|
int neededIndex = player.cursor.targetTile->neededUpdateIndex;
|
|
if (TileRegistry[player.cursor.targetTile->type].needsTicks &&
|
|
neededUpdates.tiles[neededIndex].x == player.cursor.targetTile->rect.x &&
|
|
neededUpdates.tiles[neededIndex].y == player.cursor.targetTile->rect.y) {
|
|
remove_tile(&neededUpdates, neededIndex);
|
|
}
|
|
player.cursor.targetTile->type = TYPE_AIR;
|
|
player.cursor.breakingProgress = 0;
|
|
} else {
|
|
player.cursor.breakingProgress++;
|
|
}
|
|
//printf("Player breaking %d\n", player.cursor.breakingProgress);
|
|
}
|
|
|
|
} else {
|
|
player.cursor.breakingProgress = 0;
|
|
}
|
|
if (player.cursor.targetTile != player.cursor.prevTargetTile) {
|
|
player.cursor.breakingProgress = 0;
|
|
}
|
|
if (mouseButtons & SDL_BUTTON_MMASK) {
|
|
if (player.cursor.targetTile->type > 0) {
|
|
setActivePlayerSlot(&player, player.cursor.targetTile->type);
|
|
}
|
|
|
|
}
|
|
// Translate mouseRect coordinates to viewport space
|
|
|
|
player.cursor.windowX = ((player.cursor.windowX - viewport.x) * DISPLAY_WIDTH) / viewport.w;
|
|
player.cursor.windowY = (player.cursor.windowY - viewport.y) * DISPLAY_HEIGHT / viewport.h;
|
|
player.cursor.tileX = (player.cursor.windowX + player.rect.x) / TILE_SIZE - (DISPLAY_WIDTH / TILE_SIZE / 2);
|
|
player.cursor.tileY = (player.cursor.windowY + player.rect.y) / TILE_SIZE - (DISPLAY_HEIGHT / TILE_SIZE / 2);
|
|
if (player.cursor.tileX < 0) {
|
|
player.cursor.tileX = 0;
|
|
}
|
|
if (player.cursor.tileY < 0) {
|
|
player.cursor.tileY = 0;
|
|
}
|
|
if (player.cursor.tileX >= MAP_WIDTH) {
|
|
player.cursor.tileX = MAP_WIDTH - 1;
|
|
}
|
|
if (player.cursor.tileY >= MAP_HEIGHT) {
|
|
player.cursor.tileY = MAP_HEIGHT - 1;
|
|
}
|
|
player.cursor.prevTargetTile = player.cursor.targetTile;
|
|
player.cursor.targetTile = &tileMap[player.cursor.tileY][player.cursor.tileX];
|
|
|
|
player.cursor.targetTileRect.x = player.cursor.tileX * TILE_SIZE;
|
|
player.cursor.targetTileRect.y = player.cursor.tileY * TILE_SIZE;
|
|
player.cursor.tileDiffX = player.cursor.tileX - playerTileX;
|
|
player.cursor.tileDiffY = player.cursor.tileY - playerTileY;
|
|
player.cursor.tileDiff = floorf(sqrtf(powf(player.cursor.tileDiffX, 2) + powf(player.cursor.tileDiffY, 2)));
|
|
player.cursor.canReach = player.cursor.tileDiff <= playerReach;
|
|
adjustRect(&player.cursor.targetTileRect, player.rect);
|
|
}
|
|
|
|
void processKeyboardHeld() {
|
|
const Uint8 *keyboardState = SDL_GetKeyboardState(NULL);
|
|
|
|
int cameraSpeed = playerSpeed;
|
|
|
|
if (keyboardState[SDL_SCANCODE_LSHIFT] || keyboardState[SDL_SCANCODE_RSHIFT]) {
|
|
cameraSpeed *= 8;
|
|
}
|
|
if (keyboardState[SDL_SCANCODE_LCTRL] || keyboardState[SDL_SCANCODE_RCTRL]) {
|
|
cameraSpeed /= 2;
|
|
}
|
|
|
|
if (keyboardState[SDL_SCANCODE_F8]) {
|
|
if (player.cursor.targetTile->health) {
|
|
player.cursor.targetTile->health--;
|
|
}
|
|
}
|
|
|
|
if (player.cursor.breakingProgress == 0) {
|
|
SDL_Rect newRect = player.rect;
|
|
|
|
if (keyboardState[SDL_SCANCODE_W]) {
|
|
newRect.y -= cameraSpeed;
|
|
if (newRect.y >= 0 && canMoveWithRadius(newRect)) {
|
|
player.rect = newRect;
|
|
}
|
|
}
|
|
|
|
if (keyboardState[SDL_SCANCODE_S]) {
|
|
newRect = player.rect;
|
|
newRect.y += cameraSpeed;
|
|
if (newRect.y + newRect.h <= MAP_HEIGHT * TILE_SIZE && canMoveWithRadius(newRect)) {
|
|
player.rect = newRect;
|
|
}
|
|
}
|
|
|
|
if (keyboardState[SDL_SCANCODE_A]) {
|
|
newRect = player.rect;
|
|
newRect.x -= cameraSpeed;
|
|
if (newRect.x >= 0 && canMoveWithRadius(newRect)) {
|
|
player.rect = newRect;
|
|
}
|
|
}
|
|
|
|
if (keyboardState[SDL_SCANCODE_D]) {
|
|
newRect = player.rect;
|
|
newRect.x += cameraSpeed;
|
|
if (newRect.x + newRect.w <= MAP_WIDTH * TILE_SIZE && canMoveWithRadius(newRect)) {
|
|
player.rect = newRect;
|
|
}
|
|
}
|
|
|
|
|
|
// Update tileRect only after actual movement
|
|
player.tileRect.x = player.rect.x / TILE_SIZE;
|
|
player.tileRect.y = player.rect.y / TILE_SIZE;
|
|
}
|
|
|
|
|
|
if (keyboardState[SDL_SCANCODE_F]) {
|
|
for (int x = playerTileX - 2; x < playerTileX + 2; x++) {
|
|
if (x < 0) {
|
|
continue;
|
|
}
|
|
if (x >= MAP_WIDTH) {
|
|
continue;
|
|
}
|
|
for (int y = playerTileY - 2; y < playerTileY + 2; y++) {
|
|
if (y < 0) {
|
|
continue;
|
|
}
|
|
if (y >= MAP_HEIGHT) {
|
|
continue;
|
|
}
|
|
Tile *t = &tileMap[y][x];
|
|
if (t->type == TYPE_BELT) {
|
|
for (uint8_t lane = 0; lane < 2; lane++) {
|
|
ItemOnBelt *item = &t->items[lane];
|
|
if (item->type != 0) {
|
|
player.inventory.slotCounts[item->type]++;
|
|
item->type = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (keyboardState[SDL_SCANCODE_Q]) {
|
|
if (player.cursor.targetTile->type > 0 && player.inventory.activeSlotIndex == 0) {
|
|
setActivePlayerSlot(&player, player.cursor.targetTile->type);
|
|
} else {
|
|
setActivePlayerSlot(&player, 0);
|
|
}
|
|
}
|
|
if (keyboardState[SDL_SCANCODE_F9]) {
|
|
player.inventory.slotCounts[player.inventory.activeSlotIndex]++;
|
|
}
|
|
if (keyboardState[SDL_SCANCODE_Y]) {
|
|
if (player.cursor.canReach && player.cursor.targetTile->type == TYPE_BELT &&
|
|
player.inventory.slotCounts[player.inventory.activeSlotIndex] > 0) {
|
|
for (uint8_t lane = 0; lane < 1; lane++) {
|
|
if (player.cursor.targetTile->items[lane].type == 0) {
|
|
putItem(player.cursor.tileX, player.cursor.tileY, player.inventory.activeSlotIndex, lane);
|
|
player.inventory.slotCounts[player.inventory.activeSlotIndex]--;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
unsigned int slot = 0;
|
|
if (keyboardState[SDL_SCANCODE_GRAVE]) {
|
|
slot = 1;
|
|
} else if (keyboardState[SDL_SCANCODE_1]) {
|
|
slot = 2;
|
|
} else if (keyboardState[SDL_SCANCODE_2]) {
|
|
slot = 3;
|
|
} else if (keyboardState[SDL_SCANCODE_3]) {
|
|
slot = 4;
|
|
} else if (keyboardState[SDL_SCANCODE_4]) {
|
|
slot = 5;
|
|
} else if (keyboardState[SDL_SCANCODE_5]) {
|
|
slot = 6;
|
|
} else if (keyboardState[SDL_SCANCODE_6]) {
|
|
slot = 7;
|
|
} else if (keyboardState[SDL_SCANCODE_7]) {
|
|
slot = 8;
|
|
} else if (keyboardState[SDL_SCANCODE_8]) {
|
|
slot = 9;
|
|
} else if (keyboardState[SDL_SCANCODE_9]) {
|
|
slot = 10;
|
|
} else if (keyboardState[SDL_SCANCODE_0]) {
|
|
slot = 11;
|
|
} else if (keyboardState[SDL_SCANCODE_MINUS]) {
|
|
slot = 12;
|
|
} else if (keyboardState[SDL_SCANCODE_EQUALS]) {
|
|
slot = 13;
|
|
}
|
|
if (slot > 0 && slot < sizeof(player.inventory.hotKeySlots) / sizeof(player.inventory.hotKeySlots[0])) {
|
|
setActivePlayerSlot(&player, player.inventory.hotKeySlots[slot]);
|
|
}
|
|
}
|
|
|
|
int main(__attribute__((unused)) int argc, __attribute__((unused)) char *args[]) {
|
|
int status = init();
|
|
if (status) {
|
|
return status;
|
|
}
|
|
if (loadGameState(autosaveName, &player)) {
|
|
genInitMap();
|
|
}
|
|
|
|
// audioData.synthVoices[0].frequency = 1000;
|
|
// audioData.synthVoices[0].phase = 0;
|
|
// audioData.synthVoices[0].sourceRect.w = TILE_SIZE;
|
|
// audioData.synthVoices[0].sourceRect.h = TILE_SIZE;
|
|
// audioData.synthVoices[0].sourceRect.x = 100 * TILE_SIZE;
|
|
// audioData.synthVoices[0].sourceRect.y = 100 * TILE_SIZE;
|
|
// audioData.synthVoices[0].volume = 255;
|
|
// audioData.synthVoices[0].waveform = WAVE_SINE;
|
|
|
|
//Hack to get window to stay up
|
|
SDL_Event e;
|
|
Uint64 start;
|
|
Uint64 end;
|
|
while (running) {
|
|
start = SDL_GetTicks64();
|
|
|
|
processMousePosition();
|
|
processKeyboardHeld();
|
|
|
|
while (SDL_PollEvent(&e)) {
|
|
running = processEvent(e);
|
|
}
|
|
|
|
entities.entities[0].target = player.tileRect;
|
|
|
|
updateItems();
|
|
updateEntities();
|
|
updatePlayer(&player);
|
|
updateTiles();
|
|
animationStep++;
|
|
status = render();
|
|
if (status) {
|
|
return status;
|
|
}
|
|
|
|
end = SDL_GetTicks64();
|
|
const unsigned long timeNeeded = end - start;
|
|
if (timeNeeded < delayNeeded) {
|
|
SDL_Delay(delayNeeded - timeNeeded);
|
|
}
|
|
}
|
|
|
|
saveGameState(autosaveName, &player);
|
|
|
|
for (uint8_t i = 0; i < fontCount; i++) {
|
|
destroyFont(&fonts[i]);
|
|
}
|
|
puts(SDL_GetError());
|
|
if (mainRenderer) SDL_DestroyRenderer(mainRenderer);
|
|
if (window) SDL_DestroyWindow(window);
|
|
if (glContext) SDL_GL_DeleteContext(glContext);
|
|
|
|
SDL_Quit();
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Main generator:
|
|
void genInitMap() {
|
|
const double terrainScale = 2;
|
|
const double humidityScale = 1;
|
|
const double oreScale = 2;
|
|
const int terrainOct = 4;
|
|
const int humidityOct = 4;
|
|
const int oreOct = 4;
|
|
|
|
int seedX = rand();
|
|
int seedY = rand();
|
|
int seedN = rand();
|
|
|
|
// Min/max trackers
|
|
double terrainMin = 1e9, terrainMax = -1e9;
|
|
double humidityMin = 1e9, humidityMax = -1e9;
|
|
double oreNrmMin = 1e9, oreNrmMax = -1e9;
|
|
for (uint16_t y = 0; y < MAP_HEIGHT; y++) {
|
|
for (uint16_t x = 0; x < MAP_WIDTH; x++) {
|
|
double terrain = pnoise2d(x + 1000 + seedX,
|
|
y + 1000 + seedY,
|
|
terrainScale, terrainOct, seedN);
|
|
double humidity = pnoise2d(x + seedX,
|
|
y + seedY,
|
|
humidityScale, humidityOct, seedN);
|
|
double oreNrm = pnoise2d(x + 9999 + seedX,
|
|
y + 1111 + seedY,
|
|
oreScale, oreOct, seedN);
|
|
|
|
// Track min/max
|
|
if (terrain < terrainMin) terrainMin = terrain;
|
|
if (terrain > terrainMax) terrainMax = terrain;
|
|
|
|
if (humidity < humidityMin) humidityMin = humidity;
|
|
if (humidity > humidityMax) humidityMax = humidity;
|
|
|
|
if (oreNrm < oreNrmMin) oreNrmMin = oreNrm;
|
|
if (oreNrm > oreNrmMax) oreNrmMax = oreNrm;
|
|
|
|
// [Same as your original terrain generation logic...]
|
|
BackgroundType baseType = BGType_COBBLE0;
|
|
if (terrain < 0.30) {
|
|
baseType = (humidity < 0.5) ? BGType_WATER_SHALLOW : BGType_WATER_DEEP;
|
|
} else if (terrain < 0.35) {
|
|
if (humidity < 0.3) baseType = BGType_SAND4;
|
|
else if (humidity < 0.6) baseType = BGType_SAND2;
|
|
else baseType = BGType_SAND7;
|
|
} else if (terrain < 0.7) {
|
|
double grassVal = (terrain - 0.35) / (0.70 - 0.35);
|
|
int idx = (int) (grassVal * 3.0);
|
|
if (idx >= 4) idx = 3;
|
|
if (humidity > 0.6 && ((rand() & 0xFF) < 10)) {
|
|
int flowerIdx = rand() % 4;
|
|
baseType = (BackgroundType) (BGType_GRASS_FLOWER0 + flowerIdx);
|
|
} else {
|
|
baseType = (BackgroundType) (BGType_GRASS0 + idx);
|
|
}
|
|
} else if (terrain < 0.85) {
|
|
int idx = rand() % 4;
|
|
baseType = (BackgroundType) (BGType_COBBLE0 + idx);
|
|
} else {
|
|
int idx = rand() % 4;
|
|
baseType = (BackgroundType) (BGType_TILES0 + idx);
|
|
}
|
|
|
|
BackgroundType finalType = baseType;
|
|
if (baseType != BGType_WATER_SHALLOW && baseType != BGType_WATER_DEEP) {
|
|
if (oreNrm > 0.86) {
|
|
double sub = (oreNrm - 0.86) / (1.0 - 0.86);
|
|
if (sub < 0.25) finalType = BGType_PLATINUM_ORE;
|
|
else if (sub < 0.50) finalType = BGType_GOLD_ORE;
|
|
else if (sub < 0.80) finalType = BGType_SILVER_ORE;
|
|
else finalType = BGType_IRON_ORE;
|
|
}
|
|
}
|
|
|
|
if (finalType > BGType_END) {
|
|
finalType = BGType_COBBLE0;
|
|
}
|
|
backgroundMap[y][x].type = finalType;
|
|
}
|
|
}
|
|
|
|
// Debug printout
|
|
printf("Terrain Noise: min = %f, max = %f\n", terrainMin, terrainMax);
|
|
printf("Humidity Noise: min = %f, max = %f\n", humidityMin, humidityMax);
|
|
printf("Ore Normalized: min = %f, max = %f\n", oreNrmMin, oreNrmMax);
|
|
}
|
|
|