312 lines
11 KiB
C
312 lines
11 KiB
C
//
|
||
// Created by bruno on 4/24/25.
|
||
//
|
||
|
||
#include "item.h"
|
||
#include "../player/player.h"
|
||
#include "../util/font.h"
|
||
#include <dirent.h>
|
||
|
||
Item ItemRegistry[ITEMREGISTRY_SIZE];
|
||
|
||
uint16_t itemRegistryIndex = 0;
|
||
|
||
float speed = 0.002f; // fraction of tile per tick
|
||
|
||
void updateItems() {
|
||
const int dirDx[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
|
||
const int dirDy[8] = {1, 0, -1, -1, -1, 0, 1, 1};
|
||
|
||
const float epsilon = 0.999f; // if we can't move, back it off just below 1
|
||
|
||
for (int y = 0; y < MAP_HEIGHT; y++) {
|
||
for (int x = 0; x < MAP_WIDTH; x++) {
|
||
Tile *t = &tileMap[y][x];
|
||
if (t->type != TYPE_BELT) continue;
|
||
int dir = t->direction;
|
||
|
||
bool horz = (dir == ORIENT_LEFT || dir == ORIENT_RIGHT);
|
||
bool vert = (dir == ORIENT_UP || dir == ORIENT_DOWN);
|
||
|
||
for (uint8_t lane = 0; lane < 2; lane++) {
|
||
for (uint8_t slot = 0; slot < 2; slot++) {
|
||
ItemOnBelt *itm = &t->items[lane][slot];
|
||
if (!itm->active) continue;
|
||
|
||
// 1) Advance
|
||
itm->offset += speed;
|
||
|
||
// 2) Time to hop?
|
||
if (itm->offset >= 0.5f) {
|
||
itm->offset -= 1.0f;
|
||
|
||
// target coords
|
||
int nx = x + dirDx[dir];
|
||
int ny = y + dirDy[dir];
|
||
|
||
// bounds & belt?
|
||
if (nx < 0 || nx >= MAP_WIDTH || ny < 0 || ny >= MAP_HEIGHT) {
|
||
itm->active = false;
|
||
continue;
|
||
}
|
||
Tile *next = &tileMap[ny][nx];
|
||
if (next->type != TYPE_BELT) {
|
||
itm->active = false;
|
||
continue;
|
||
}
|
||
|
||
// Decide new lane
|
||
int newLane = lane;
|
||
int newDir = next->direction;
|
||
bool nH = (newDir == ORIENT_LEFT || newDir == ORIENT_RIGHT);
|
||
bool nV = (newDir == ORIENT_UP || newDir == ORIENT_DOWN);
|
||
|
||
if ((horz && nH) || (vert && nV)) {
|
||
// same axis → keep lane
|
||
} else if (horz && nV) {
|
||
// came off a horizontal: lane0=top→vertical.left, lane1=bottom→vertical.right
|
||
newLane = (dir == ORIENT_RIGHT ? 1 : 0);
|
||
itm->offset = 0.0f;
|
||
} else if (vert && nH) {
|
||
// came off vertical: lane0=left→horizontal.top, lane1=right→horizontal.bottom
|
||
newLane = (dir == ORIENT_UP ? 0 : 1);
|
||
itm->offset = 0.0f;
|
||
}
|
||
// (diagonals fall back to same-lane)
|
||
|
||
// Find a free slot in newLane
|
||
int destSlot = -1;
|
||
if (!next->items[newLane][0].active) destSlot = 0;
|
||
else if (!next->items[newLane][1].active) destSlot = 1;
|
||
|
||
if (destSlot >= 0) {
|
||
// MOVE it
|
||
ItemOnBelt moved = *itm;
|
||
moved.tileX = nx;
|
||
moved.tileY = ny;
|
||
next->items[newLane][destSlot] = moved;
|
||
next->items[newLane][destSlot].active = true;
|
||
|
||
// clear this one
|
||
itm->active = false;
|
||
} else {
|
||
// both slots full → wait at end
|
||
itm->offset = epsilon;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
void registerItem(char name[20], SDL_Renderer *renderer) {
|
||
const char *dot = strchr(name, '.');
|
||
memcpy(ItemRegistry[itemRegistryIndex].name, name, dot - name);
|
||
char texturePath[80];
|
||
snprintf(texturePath, 80, "./assets/items/%s", name);
|
||
ItemRegistry[itemRegistryIndex].texture[ORIENT_LEFT] = IMG_LoadTexture(renderer, texturePath);
|
||
SDL_SetTextureBlendMode(ItemRegistry[itemRegistryIndex].texture[0], SDL_BLENDMODE_BLEND);
|
||
ItemRegistry[itemRegistryIndex].textureOnBelt[ORIENT_LEFT] = ScaleTexture(renderer, ItemRegistry[itemRegistryIndex].texture[ORIENT_LEFT],
|
||
TILE_SIZE / 2, TILE_SIZE / 2);
|
||
SDL_SetTextureBlendMode(ItemRegistry[itemRegistryIndex].textureOnBelt[ORIENT_LEFT], SDL_BLENDMODE_BLEND);
|
||
ItemRegistry[itemRegistryIndex].type = itemRegistryIndex;
|
||
|
||
itemRegistryIndex++;
|
||
}
|
||
|
||
// easing function: cosine ease‐in‐out
|
||
static float ease_in_out(float t) {
|
||
if (t < -1.0f) t = -1.0f;
|
||
if (t > 1.0f) t = 1.0f;
|
||
|
||
// Even symmetric easing: reflected across t = 0
|
||
return (t < 0.0f)
|
||
? -0.5f * (1.0f - cosf(M_PI * -t)) // negative side
|
||
: 0.5f * (1.0f - cosf(M_PI * t)); // positive side
|
||
}
|
||
|
||
uint8_t laneTarget = 0;
|
||
|
||
void renderItem(ItemOnBelt item, SDL_Renderer *renderer, int lane) {
|
||
SDL_Rect rect = {0};
|
||
rect.x = item.tileX * TILE_SIZE;
|
||
rect.y = item.tileY * TILE_SIZE;
|
||
|
||
// get raw direction code
|
||
int dir = tileMap[item.tileY][item.tileX].direction;
|
||
|
||
//--- 1) build a unit vector (dxf, dyf) for this orientation
|
||
float dxf = 0.0f, dyf = 0.0f;
|
||
const float D = M_SQRT1_2; // 1/√2 ≈ 0.7071
|
||
switch (dir) {
|
||
case ORIENT_LEFT_DOWN:
|
||
dxf = -D;
|
||
dyf = +D;
|
||
break;
|
||
case ORIENT_LEFT:
|
||
dxf = -1.0f;
|
||
dyf = 0.0f;
|
||
break;
|
||
case ORIENT_LEFT_UP:
|
||
dxf = -D;
|
||
dyf = -D;
|
||
break;
|
||
case ORIENT_UP:
|
||
dxf = 0.0f;
|
||
dyf = -1.0f;
|
||
break;
|
||
case ORIENT_RIGHT_UP:
|
||
dxf = +D;
|
||
dyf = -D;
|
||
break;
|
||
case ORIENT_RIGHT:
|
||
dxf = +1.0f;
|
||
dyf = 0.0f;
|
||
break;
|
||
case ORIENT_RIGHT_DOWN:
|
||
dxf = +D;
|
||
dyf = +D;
|
||
break;
|
||
case ORIENT_DOWN:
|
||
dxf = 0.0f;
|
||
dyf = +1.0f;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
//--- 2) ease the offset and compute forward distance
|
||
float t = ease_in_out(item.offset); // 0..1
|
||
float dist = t * TILE_SIZE; // 0..TILE_SIZE pixels
|
||
|
||
float xOffset = dxf * dist;
|
||
float yOffset = dyf * dist;
|
||
|
||
switch (dir) {
|
||
case ORIENT_LEFT_DOWN:
|
||
xOffset += 0.0f * TILE_SIZE;
|
||
yOffset += 0.0f * TILE_SIZE;
|
||
break;
|
||
case ORIENT_LEFT:
|
||
xOffset += 0.0f * TILE_SIZE;
|
||
yOffset += 0.26f * TILE_SIZE;
|
||
break;
|
||
case ORIENT_LEFT_UP:
|
||
xOffset += 0.0f * TILE_SIZE;
|
||
yOffset += 0.0f * TILE_SIZE;
|
||
break;
|
||
case ORIENT_UP:
|
||
xOffset += 0.22f * TILE_SIZE; //GOTO HEHREHRHE
|
||
yOffset += 0.0f * TILE_SIZE;
|
||
break;
|
||
case ORIENT_RIGHT_UP:
|
||
xOffset += 0.0f * TILE_SIZE;
|
||
yOffset += 0.0f * TILE_SIZE;
|
||
break;
|
||
case ORIENT_RIGHT:
|
||
xOffset += 0.0f * TILE_SIZE;
|
||
yOffset += 0.18f * TILE_SIZE; //FIX THIS
|
||
break;
|
||
case ORIENT_RIGHT_DOWN:
|
||
xOffset += 0.0f * TILE_SIZE;
|
||
yOffset += 0.0f * TILE_SIZE;
|
||
break;
|
||
case ORIENT_DOWN:
|
||
xOffset += 0.18f * TILE_SIZE;
|
||
yOffset += 0.0f * TILE_SIZE;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
//--- 3) compute perpendicular unit vector (perpX, perpY) = (-dy, dx)
|
||
float perpX = -dyf;
|
||
float perpY = dxf;
|
||
// perp is already unit length because (dxf,dyf) is unit
|
||
|
||
bool horz = (dir == ORIENT_LEFT || dir == ORIENT_RIGHT);
|
||
bool vert = (dir == ORIENT_UP || dir == ORIENT_DOWN);
|
||
|
||
//--- 4) lane offset
|
||
// total lane spacing = TILE_SIZE/2, so half of that each side = TILE_SIZE/4
|
||
float laneSign = (lane == laneTarget ? +1.0f : -1.0f);
|
||
float laneOffset = TILE_SIZE * (horz ? 0.12f : 0.14f); // = TILE_SIZE/4
|
||
xOffset += perpX * laneSign * laneOffset;
|
||
yOffset += perpY * laneSign * laneOffset;
|
||
|
||
//--- 5) apply to rect
|
||
rect.x += (int) roundf(xOffset);
|
||
rect.y += (int) roundf(yOffset);
|
||
|
||
rect.w = TILE_SIZE / 2;
|
||
rect.h = TILE_SIZE / 2;
|
||
|
||
adjustRect(&rect);
|
||
|
||
// (Optional debug overlay)
|
||
// SDL_Rect tileArea = {item.tileX * TILE_SIZE, item.tileY * TILE_SIZE,
|
||
// TILE_SIZE, TILE_SIZE};
|
||
// SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
|
||
// SDL_SetRenderDrawColor(renderer, 255, 0, 0, 32);
|
||
// adjustRect(&tileArea);
|
||
// SDL_RenderFillRect(renderer, &tileArea);
|
||
|
||
char tempStr[50];
|
||
|
||
// SDL_Rect rectA = {0};
|
||
// rectA.x = item.tileX * TILE_SIZE;
|
||
// rectA.y = item.tileY * TILE_SIZE;
|
||
// rectA.w = TILE_SIZE;
|
||
// rectA.h = TILE_SIZE;
|
||
// sprintf(tempStr, "L%d\n%f\n%f\n%f", lane, item.offset, xOffset, yOffset);
|
||
// SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
|
||
// SDL_SetRenderDrawColor(renderer, 255, 0, 0, 32);
|
||
// adjustRect(&rectA);
|
||
// SDL_RenderFillRect(renderer, &rectA);
|
||
SDL_RenderCopy(renderer, ItemRegistry[item.type].textureOnBelt[ORIENT_LEFT], NULL, &rect);
|
||
// renderText(renderer, fonts[3], tempStr, rectA.x, rectA.y);
|
||
}
|
||
|
||
void renderBeltItems(SDL_Renderer *renderer) {
|
||
|
||
}
|
||
|
||
void putItem(int x, int y, uint16_t itemType, uint8_t lane, uint8_t itemIndex) {
|
||
tileMap[y][x].items[lane][itemIndex].type = itemType;
|
||
tileMap[y][x].items[lane][itemIndex].offset = 0;
|
||
tileMap[y][x].items[lane][itemIndex].active = true;
|
||
tileMap[y][x].items[lane][itemIndex].tileX = x;
|
||
tileMap[y][x].items[lane][itemIndex].tileY = y;
|
||
}
|
||
|
||
void loadItems(SDL_Renderer *renderer) {
|
||
for(int i = 0; i < tileTypeIndex; i++) {
|
||
TileType tile = TileRegistry[i];
|
||
|
||
strcpy(ItemRegistry[itemRegistryIndex].name, tile.name);
|
||
memcpy(ItemRegistry[itemRegistryIndex].texture, tile.textures, sizeof (tile.textures));
|
||
for (int a = 0; a < ORIENT_DIRECTION_COUNT; a++) {
|
||
SDL_SetTextureBlendMode(ItemRegistry[itemRegistryIndex].texture[a], SDL_BLENDMODE_BLEND);
|
||
ItemRegistry[itemRegistryIndex].textureOnBelt[a] = ScaleTexture(renderer, tile.textures[a],
|
||
TILE_SIZE / 2, TILE_SIZE / 2);
|
||
SDL_SetTextureBlendMode(ItemRegistry[itemRegistryIndex].textureOnBelt[a], SDL_BLENDMODE_BLEND);
|
||
}
|
||
ItemRegistry[itemRegistryIndex].type = itemRegistryIndex;
|
||
|
||
itemRegistryIndex++;
|
||
}
|
||
|
||
|
||
DIR *dir = opendir("./assets/items");
|
||
if (dir) {
|
||
struct dirent *entry;
|
||
while ((entry = readdir(dir)) != NULL) {
|
||
if (entry->d_name[0] == '.') {
|
||
continue;
|
||
}
|
||
registerItem(entry->d_name, renderer);
|
||
}
|
||
}
|
||
} |