BRNSystems/factorygame
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Some more hopefully working progress

Browse Source
This commit is contained in:
Bruno Rybársky
2025-05-31 23:54:55 +02:00
parent 0c9698879b
commit 6b6e7df035
26 changed files with 659 additions and 393 deletions
Download Patch File Download Diff File Expand all files Collapse all files

67
tiles/belt.c
View File

@@ -9,16 +9,14 @@
#include "../player/player.h"
#include "../items/item.h"
static int scrollFrame = 0;
unsigned long beltFrames = 0;
void renderBelt(int x, int y, int w, int h, OrientDirection dir, SDL_Renderer *renderer) {
void renderBelt(int x, int y, int w, int h, OrientDirection dir, SDL_Rect playerRect, SDL_Renderer *renderer) {
int px = x * TILE_SIZE;
int py = y * TILE_SIZE;
uint16_t tileType = tileMap[y][x].type;
Tile *t = &tileMap[y][x];
uint16_t tileType = t->type;
SDL_Rect src1, src2, dst1, dst2;
@@ -35,8 +33,8 @@ void renderBelt(int x, int y, int w, int h, OrientDirection dir, SDL_Renderer *r
src2 = (SDL_Rect) {0, 0, offset, TILE_SIZE};
dst2 = (SDL_Rect) {px + (w - offset), py, offset, h};
adjustRect(&dst1);
adjustRect(&dst2);
adjustRect(&dst1, playerRect);
adjustRect(&dst2, playerRect);
SDL_RenderCopy(renderer, TileRegistry[tileType].textures[dir], &src1, &dst1);
SDL_RenderCopy(renderer, TileRegistry[tileType].textures[dir], &src2, &dst2);
@@ -53,60 +51,19 @@ void renderBelt(int x, int y, int w, int h, OrientDirection dir, SDL_Renderer *r
src2 = (SDL_Rect) {0, 0, TILE_SIZE, offset};
dst2 = (SDL_Rect) {px, py + (h - offset), w, offset};
adjustRect(&dst1);
adjustRect(&dst2);
adjustRect(&dst1, playerRect);
adjustRect(&dst2, playerRect);
// Rotate to make the belt vertical
SDL_RenderCopy(renderer, TileRegistry[tileType].textures[dir], &src1, &dst1);
SDL_RenderCopy(renderer, TileRegistry[tileType].textures[dir], &src2, &dst2);
}
}
void renderAllBelts(SDL_Renderer *renderer) {
int scrollSpeed = 1; // pixels per step
int scrollDelay = 1; // frames between steps
if (beltFrames++ % scrollDelay == 0) {
scrollFrame += scrollSpeed;
}
int tileSize = TILE_SIZE;
for (int y = (playerY / TILE_SIZE) - (DISPLAY_MAP_HEIGHT / 2) - 1;
y < (playerY / TILE_SIZE) + (DISPLAY_MAP_HEIGHT / 2) + 1; y++) {
if (y < 0 || y >= MAP_HEIGHT) {
continue;
}
for (int x = (playerX / TILE_SIZE) - (DISPLAY_MAP_WIDTH / 2) - 1;
x < (playerX / TILE_SIZE) + (DISPLAY_MAP_WIDTH / 2) + 1; x++) {
if (x < 0 || x >= MAP_WIDTH) {
continue;
}
Tile t = tileMap[y][x];
if (t.type != TYPE_BELT) continue;
renderBelt(x, y, tileSize, tileSize, t.direction, renderer);
}
}
for (int y = (playerY / TILE_SIZE) - (DISPLAY_MAP_HEIGHT / 2) - 1;
y < (playerY / TILE_SIZE) + (DISPLAY_MAP_HEIGHT / 2) + 1; y++) {
if (y < 0 || y >= MAP_HEIGHT) {
continue;
}
for (int x = (playerX / TILE_SIZE) - (DISPLAY_MAP_WIDTH / 2) - 1;
x < (playerX / TILE_SIZE) + (DISPLAY_MAP_WIDTH / 2) + 1; x++) {
if (x < 0 || x >= MAP_WIDTH) {
continue;
}
Tile t = tileMap[y][x];
if (t.type != TYPE_BELT) continue;
for (uint8_t lane = 0; lane < 2; lane++) {
for (uint8_t itemIndex = 0; itemIndex < 2; itemIndex++) {
if (t.items[lane][itemIndex].active) {
renderItem(t.items[lane][itemIndex], renderer, lane);
}
}
}
SDL_SetRenderTarget(renderer, itemsTexture);
for (uint8_t lane = 0; lane < 2; lane++) {
if (t->items[lane].type != 0) {
renderItem(t->items[lane], renderer, lane, playerRect);
}
}
}

5
tiles/belt.h
View File

@@ -4,13 +4,12 @@
#ifndef FACTORYGAME_BELT_H
#define FACTORYGAME_BELT_H
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include "tile.h"
#include "../util/util.h"
void renderBelt(int px, int py, int w, int h, OrientDirection dir, SDL_Renderer * renderer);
void renderAllBelts(SDL_Renderer * renderer);
void renderBelt(int x, int y, int w, int h, OrientDirection dir, SDL_Rect playerRect, SDL_Renderer *renderer);
#endif //FACTORYGAME_BELT_H

14
tiles/furnace.c Normal file
View File

@@ -0,0 +1,14 @@
//
// Created by bruno on 31.5.2025.
//
#include "furnace.h"
#include "tile.h"
uint16_t getFurnaceNewItem(uint16_t sourceItem) {
uint16_t realItemIndex = sourceItem - tileTypeIndex - 1;
if (realItemIndex < 8) {
return sourceItem + 1;
}
return 0;
}

10
tiles/furnace.h Normal file
View File

@@ -0,0 +1,10 @@
//
// Created by bruno on 31.5.2025.
//
#ifndef FACTORYGAME_FURNACE_H
#define FACTORYGAME_FURNACE_H
#include "stdint.h"
#endif //FACTORYGAME_FURNACE_H

103
tiles/tile.c
View File

@@ -4,10 +4,17 @@
#include <dirent.h>
#include "tile.h"
#include "../player/player.h"
int scrollFrame = 0;
unsigned long beltFrames = 0;
SDL_Texture *tilesTexture;
SDL_Texture *itemsTexture;
Tile tileMap[MAP_HEIGHT][MAP_WIDTH];
uint16_t tileTypeIndex = 1;
uint16_t tileTypeIndex = 0;
TileType TileRegistry[TILEREGISTRY_SIZE];
@@ -31,6 +38,13 @@ void generateTestMap() {
tileMap[y][x].direction = (rand() % 4 * 2) + 1;
}
}
uint8_t type = 0;
for (int x = 142; x < 154; x += 3) {
for (int y = 80; y < 94; y += 3) {
putItem(x, y, type++ % ITEMREGISTRY_SIZE, 0);
}
}
}
@@ -45,23 +59,25 @@ void registerTile(char name[20], SDL_Renderer *renderer) {
TileRegistry[tileTypeIndex].textures[ORIENT_UP] = createRotatedTexture(renderer, texture, 90);
TileRegistry[tileTypeIndex].textures[ORIENT_DOWN] = createRotatedTexture(renderer, texture, 270);
TileRegistry[tileTypeIndex].type = tileTypeIndex;
TileRegistry[tileTypeIndex].breakTime = 30;
TileRegistry[tileTypeIndex].breakTime = 15;
tileTypeIndex++;
}
void loadTiles(SDL_Renderer *renderer) {
DIR *dir = opendir("./assets/tiles");
if (dir) {
struct dirent *entry;
while ((entry = readdir(dir)) != NULL) {
if (entry->d_name[0] == '.') {
continue;
}
registerTile(entry->d_name, renderer);
}
}
iterateSortedDir("./assets/tiles", (DirEntryCallback) registerTile, renderer);
// DIR *dir = opendir("./assets/tiles");
// if (dir) {
// struct dirent *entry;
// while ((entry = readdir(dir)) != NULL) {
// if (entry->d_name[0] == '.') {
// continue;
// }
// registerTile(entry->d_name, mainRenderer);
// }
// }
TileRegistry[0].breakTime = 0;
}
uint16_t getBreakTime(int type) {
@@ -69,4 +85,67 @@ uint16_t getBreakTime(int type) {
return 0;
}
return TileRegistry[type].breakTime;
}
void initTiles() {
itemsTexture = SDL_CreateTexture(mainRenderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, screenRect.w,
screenRect.h);
tilesTexture = SDL_CreateTexture(mainRenderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, screenRect.w,
screenRect.h);
SDL_SetTextureBlendMode(itemsTexture, SDL_BLENDMODE_BLEND);
SDL_SetTextureBlendMode(tilesTexture, SDL_BLENDMODE_BLEND);
}
void renderAllTiles(SDL_Renderer *renderer, SDL_Rect playerRect) {
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
SDL_Texture *oldTarget = SDL_GetRenderTarget(renderer);
SDL_SetRenderTarget(renderer, itemsTexture);
SDL_RenderClear(renderer);
SDL_SetRenderTarget(renderer, tilesTexture);
SDL_RenderClear(renderer);
int scrollSpeed = 1; // pixels per step
int scrollDelay = 1; // frames between steps
if (beltFrames++ % scrollDelay == 0) {
scrollFrame += scrollSpeed;
}
int tileSize = TILE_SIZE;
for (int y = (playerRect.y / TILE_SIZE) - (DISPLAY_MAP_HEIGHT / 2) - 1;
y < (playerRect.y / TILE_SIZE) + (DISPLAY_MAP_HEIGHT / 2) + 1; y++) {
if (y < 0 || y >= MAP_HEIGHT) {
continue;
}
for (int x = (playerRect.x / TILE_SIZE) - (DISPLAY_MAP_WIDTH / 2) - 1;
x < (playerRect.x / TILE_SIZE) + (DISPLAY_MAP_WIDTH / 2) + 1; x++) {
if (x < 0 || x >= MAP_WIDTH) {
continue;
}
Tile t = tileMap[y][x];
SDL_SetRenderTarget(renderer, tilesTexture);
switch (t.type) {
case TYPE_BELT:
renderBelt(x, y, tileSize, tileSize, t.direction, playerRect, renderer);
break;
default:
SDL_Rect dstRect;
dstRect.x = x * TILE_SIZE;
dstRect.y = y * TILE_SIZE;
dstRect.w = TILE_SIZE;
dstRect.h = TILE_SIZE;
adjustRect(&dstRect, playerRect);
SDL_Texture *tex = TileRegistry[t.type].textures[t.direction];
if (tex == NULL) {
tex = TileRegistry[t.type].textures[ORIENT_LEFT];
}
if (tex != NULL) {
SDL_RenderCopy(renderer, tex, NULL, &dstRect);
}
}
if (t.type == TYPE_BELT) {
}
}
}
SDL_SetRenderTarget(renderer, oldTarget);
}

18
tiles/tile.h
View File

@@ -12,14 +12,20 @@
#define MAP_WIDTH 600
#define MAP_HEIGHT 340
#define DISPLAY_MAP_WIDTH 30
#define DISPLAY_MAP_HEIGHT 16
#define DISPLAY_MAP_WIDTH 44
#define DISPLAY_MAP_HEIGHT 22
#define TILE_SIZE 32
#define DISPLAY_WIDTH DISPLAY_MAP_WIDTH * TILE_SIZE
#define DISPLAY_HEIGHT DISPLAY_MAP_HEIGHT * TILE_SIZE
extern SDL_Texture *tilesTexture;
extern SDL_Texture *itemsTexture;
extern int scrollFrame;
extern unsigned long beltFrames;
typedef struct {
uint16_t type;
char name[20];
@@ -32,13 +38,15 @@ typedef struct {
extern TileType TileRegistry[TILEREGISTRY_SIZE];
#define TYPE_AIR 0
#define TYPE_BELT 1
#define TYPE_BELT 2
void renderAllTiles(SDL_Renderer * renderer, SDL_Rect playerRect);
typedef struct {
OrientDirection direction;
uint16_t type;
int frameOffset;
ItemOnBelt items[2][2];
ItemOnBelt items[2];
int x;
int y;
} Tile;
@@ -52,4 +60,6 @@ extern uint16_t tileTypeIndex;
uint16_t getBreakTime(int type);
void initTiles();
#endif //FACTORYGAME_TILE_H