Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
#include <SDL.h>
#include "language_layer.h"
#include "memory_arena.h"
#define STB_TRUETYPE_IMPLEMENTATION
#include "stb_truetype.h"
#define WINDOW_WIDTH 1920
#define WINDOW_HEIGHT 1080
#define TOP_BAR_SIZE 100
#define TILES_PER_WINDOW_WIDTH 20
#define FONT_FILE_NAME "manaspc.ttf"
// Map structure
#define MAP_TILE_TYPE_ground '_'
#define MAP_TILE_TYPE_wall 'X'
#define MAP_TILE_TYPE_water '~'
// Text rendering
#define RENDER_TEXT_X_CENTERED (1 << 0)
#define RENDER_TEXT_Y_CENTERED (1 << 1)
const char* Dialog[] = {
"You awaken in a dungeon\n\nThe air is humid...\n\nNearby you hear something shuffle across\nthe cold floor",
0
};
typedef struct font_t {
u8* Data;
stbtt_fontinfo Font;
i32 Ascent;
i32 Descent;
i32 LineGap;
} font;
typedef enum direction_t {
DIRECTION_right,
DIRECTION_up,
DIRECTION_left,
DIRECTION_down,
DIRECTION_MAX
} direction;
typedef struct map_t {
v2i Dim;
char Tiles[20][20];
} map;
// Anything with a key press:
// Up => Down => Repeat => Up
// The transition from Up => Down adds 1 to HalfTransitionCount
// The transition from Down => Up adds 1 to HalfTransitionCount
//
// State | HalfTransitionCount | Meaning
// ==================================================
// Up | 0 | Still unpressed
// Up | 1 | Was pressed
// Down | 0 | Still pressed
// Down | 1 | Just pressed
typedef struct key_state_t {
b32 EndedDown;
u32 HalfTransitionCount;
} key_state;
typedef struct enemy_t {
i32 HP;
i32 MaxHP;
v2i Pos;
v4 Rect;
f32 MoveTimeSecs;
f32 MoveTimer;
} enemy;
typedef struct app_t {
v2 Window;
b32 Running;
memory_arena PermArena;
memory_arena TempArena;
struct {
v2 Pos;
v2 Rem;
v4 Color;
v4 WeaponColor;
v2 WeaponDim;
direction Dir;
} Player;
u32 NumEnemies;
enemy Enemies[10];
v2i TileSize;
map Map;
u32 NumCollisionRects;
v4 CollisionRects[150];
font Font;
f32 FadeInSecs;
f32 TotalFadeInSecs;
u32 DialogIndex;
} app;
typedef struct input_t {
f32 DeltaTimeSecs;
union {
struct {
key_state MoveLeft;
key_state MoveRight;
key_state MoveUp;
key_state MoveDown;
key_state ActionDown;
key_state ActionRight;
key_state Shift;
};
key_state Keys[6];
};
} input;
internal bool FontLoad(const char* FileName, memory_arena* Arena, font* Result) {
FILE* TTFFile = fopen(FileName, "r");
if (!TTFFile) {
return(false);
}
fseek(TTFFile, 0, SEEK_END);
long FileSize = ftell(TTFFile);
fseek(TTFFile, 0, SEEK_SET);
Result->Data = (u8*)ArenaAlloc(Arena, FileSize);
fread(Result->Data, 1, FileSize, TTFFile);
fclose(TTFFile);
stbtt_InitFont(&Result->Font, Result->Data, stbtt_GetFontOffsetForIndex(Result->Data, 0));
stbtt_GetFontVMetrics(&Result->Font, &Result->Ascent, &Result->Descent, &Result->LineGap);
return(true);
}
internal f32 FontLineHeight(app* App, f32 FontSizePixels) {
// Calculate line height
float Scale = stbtt_ScaleForPixelHeight(&App->Font.Font, FontSizePixels);
return(Scale * App->Font.Ascent);
}
internal f32 FontTextWidthPixels(app* App, f32 FontSizePixels, const char* Text, u32 StartCh, u32 EndCh) {
char* Ch = (char*)Text + StartCh;
float XPos = 0;
int Advance, LSB;
float Scale = stbtt_ScaleForPixelHeight(&App->Font.Font, FontSizePixels);
while (*Ch && StartCh < EndCh) {
stbtt_GetCodepointHMetrics(&App->Font.Font, *Ch, &Advance, &LSB);
XPos += (Advance * Scale);
if (StartCh + 1 < EndCh) {
XPos += Scale * stbtt_GetCodepointKernAdvance(&App->Font.Font, *Ch, *(Ch+1));
}
++StartCh;
++Ch;
}
return(XPos);
}
internal f32 FontTextWidthPixels(app* App, f32 FontSizePixels, const char* Text) {
char* Ch = (char*)Text;
float XPos = 0;
int Advance, LSB;
float Scale = stbtt_ScaleForPixelHeight(&App->Font.Font, FontSizePixels);
while (*Ch) {
stbtt_GetCodepointHMetrics(&App->Font.Font, *Ch, &Advance, &LSB);
XPos += (Advance * Scale);
if (*(Ch + 1)) {
XPos += Scale * stbtt_GetCodepointKernAdvance(&App->Font.Font, *Ch, *(Ch+1));
}
Ch++;
}
return(XPos);
}
inline direction RandomDirection() {
switch (rand() % 4)
{
case 0:
return(DIRECTION_right);
case 1:
return(DIRECTION_left);
case 2:
return(DIRECTION_up);
case 3:
return(DIRECTION_down);
default:
return(DIRECTION_right);
}
}
inline b32 IsPressed(key_state State)
{
return (State.EndedDown);
}
inline b32 WasPressed(key_state State)
{
return (!State.EndedDown && State.HalfTransitionCount > 0);
}
internal void LinuxProcessKeyDown(key_state* State, b32 IsDown)
{
Assert(IsDown != State->EndedDown);
State->EndedDown = IsDown;
++State->HalfTransitionCount;
}
void SetDrawColor(SDL_Renderer* Renderer, v4 Color)
{
SDL_SetRenderDrawColor(Renderer, 255 * Color.R, 255 * Color.G, 255 * Color.B, 255 * Color.A);
}
void DrawTextRevised(SDL_Renderer* Renderer, app* App, const char* Text, float FontSizePixels, v2i Pos) {
// Iterate through the text and find all of the newlines.
u32 NewlineCount = 0;
u32 NewlinePos[100]; // NOTE(eric): No more than 100 newlines
for (u32 I = 0; I < strlen(Text); ++I)
{
if (Text[I] == '\n') {
NewlinePos[NewlineCount++] = I;
}
}
// Add one final virtual newline for the end of the text.
NewlinePos[NewlineCount++] = strlen(Text);
// Set up rendering constants
f32 Scale = stbtt_ScaleForPixelHeight(&App->Font.Font, FontSizePixels);
int BitmapHeight = FontSizePixels - (Scale * App->Font.Descent);
int Ascent = (int)round(Scale * App->Font.Ascent);
u32 StartPos = 0;
for (u32 I = 0; I < NewlineCount; ++I)
{
int BitmapWidth = (int)FontTextWidthPixels(App, FontSizePixels, Text, StartPos, NewlinePos[I]);
u8* Bitmap = (u8*)calloc(1, BitmapWidth * BitmapHeight);
// Render characters into bitmap
int FinalWidth = 0;
for (u32 Pos = StartPos; Pos < NewlinePos[I]; ++Pos) {
int CX1, CY1, CX2, CY2;
stbtt_GetCodepointBitmapBox(&App->Font.Font, Text[Pos], Scale, Scale, &CX1, &CY1, &CX2, &CY2);
int ChY = Ascent + CY1;
int ByteOffset = FinalWidth + (ChY * BitmapWidth);
stbtt_MakeCodepointBitmap(&App->Font.Font, Bitmap + ByteOffset, CX2 - CX1, CY2 - CY1, BitmapWidth, Scale, Scale, Text[Pos]);
int XOffs;
stbtt_GetCodepointHMetrics(&App->Font.Font, Text[Pos], &XOffs, 0);
FinalWidth += Scale * XOffs;
int Kern;
Kern = stbtt_GetCodepointKernAdvance(&App->Font.Font, Text[Pos], Text[Pos + 1]);
FinalWidth += Scale * Kern;
}
// Copy bitmap into SDL-appropriate bmp
u8* Pixels = (u8*)calloc(1, sizeof(u32) * BitmapWidth * BitmapHeight);
u8* Src = Bitmap;
u8* DstRow = Pixels;
for (i32 Y = 0; Y < BitmapHeight; ++Y) {
u32* Dest = (u32*)DstRow;
for (i32 X = 0; X < BitmapWidth; ++X) {
u8 Alpha = *Src++;
*Dest++ = ((Alpha << 24) | (Alpha << 16) | (Alpha << 8) | Alpha);
}
DstRow += (sizeof(u32) * FinalWidth);
}
// Copy to SDL texture and render
SDL_Texture* FontTexture = SDL_CreateTexture(
Renderer,
SDL_PIXELFORMAT_RGBA32,
SDL_TEXTUREACCESS_STREAMING,
BitmapWidth,
BitmapHeight
);
SDL_UpdateTexture(FontTexture, NULL, Pixels, 4 * FinalWidth);
SDL_SetTextureBlendMode(FontTexture, SDL_BLENDMODE_BLEND);
SDL_Rect SrcR = { .x = 0, .y = 0, .w = FinalWidth, .h = BitmapHeight };
SDL_Rect DstR = { .x = Pos.X, .y = Pos.Y, .w = FinalWidth, .h = BitmapHeight };
SDL_RenderCopy(Renderer, FontTexture, &SrcR, &DstR);
SDL_DestroyTexture(FontTexture);
free(Pixels);
free(Bitmap);
StartPos = NewlinePos[I] + 1;
Pos.Y += BitmapHeight;
}
}
// Largely based on this code:
// https://github.com/justinmeiners/stb-truetype-example/blob/master/main.c
void DrawText(SDL_Renderer* Renderer, app* App, const char* Text, float FontSizePixels, v2i Pos) {
float scale = stbtt_ScaleForPixelHeight(&App->Font.Font, FontSizePixels);
// NOTE(eric): Total height in pixels will be the selected pixel font size
// plus additional room for chars that descend below the line.
int bitmap_height = FontSizePixels - (scale * App->Font.Descent);
int bitmap_width = FontTextWidthPixels(App, FontSizePixels, Text);
uint8_t* bitmap = (unsigned char*)malloc(bitmap_height * bitmap_width);
memset(bitmap, 0, bitmap_height * bitmap_width);
int ascent = (int)round(scale * App->Font.Ascent);
int final_width = 0;
for (char* at = (char*)Text; *at; ++at) {
int c_x1, c_y1, c_x2, c_y2;
stbtt_GetCodepointBitmapBox(&App->Font.Font, *at, scale, scale, &c_x1, &c_y1, &c_x2, &c_y2);
int ch_y = ascent + c_y1;
int byte_offset = final_width + (ch_y * bitmap_width);
stbtt_MakeCodepointBitmap(&App->Font.Font, bitmap + byte_offset, c_x2 - c_x1, c_y2 - c_y1, bitmap_width, scale, scale, *at);
int ax;
stbtt_GetCodepointHMetrics(&App->Font.Font, *at, &ax, 0);
final_width += scale * ax;
int kern;
kern = stbtt_GetCodepointKernAdvance(&App->Font.Font, *at, *(at + 1));
final_width += kern * scale;
}
uint8_t pixels[sizeof(uint32_t) * bitmap_width * bitmap_height];
uint8_t* src = bitmap;
uint8_t* dst_row = pixels;
for (int by = 0; by < bitmap_height; ++by) {
uint32_t* dest = (uint32_t*)dst_row;
for (int bx = 0; bx < bitmap_width; ++bx) {
u8 alpha = *src++;
*dest++ = ((alpha << 24) | (alpha << 16) | (alpha << 8) | alpha);
}
dst_row += (sizeof(uint32_t) * final_width);
}
SDL_Texture* font_texture = SDL_CreateTexture(
Renderer,
SDL_PIXELFORMAT_RGBA32,
SDL_TEXTUREACCESS_STREAMING,
bitmap_width,
bitmap_height
);
SDL_UpdateTexture(font_texture, NULL, pixels, 4 * final_width);
SDL_SetTextureBlendMode(font_texture, SDL_BLENDMODE_BLEND);
SDL_Rect srcr = { .x = 0, .y = 0, .w = final_width, .h = bitmap_height };
SDL_Rect dstr = { .x = Pos.X, .y = Pos.Y, .w = final_width, .h = bitmap_height };
SDL_RenderCopy(Renderer, font_texture, &srcr, &dstr);
SDL_DestroyTexture(font_texture);
free(bitmap);
}
void DrawText(SDL_Renderer* Renderer, app* App, const char* Text, unsigned int Flags, float FontSizePixels, v2i Pos) {
float LineHeight = FontLineHeight(App, FontSizePixels);
if (Flags & RENDER_TEXT_Y_CENTERED) {
Pos.Y += LineHeight / 2;
}
if (Flags & RENDER_TEXT_X_CENTERED) {
float TextWidthPixels = FontTextWidthPixels(App, FontSizePixels, Text);
Pos.X -= TextWidthPixels / 2;
}
DrawText(Renderer, App, Text, FontSizePixels, Pos);
}
void DrawPlayer(SDL_Renderer* Renderer, app* App)
{
SDL_Rect PlayerRect = {};
PlayerRect.x = App->Window.Width/2 - App->TileSize.Width/2;//App->Player.Pos.X;
PlayerRect.y = App->Window.Height/2 - App->TileSize.Height/2;//App->Player.Pos.Y;
PlayerRect.w = App->TileSize.Width;
PlayerRect.h = App->TileSize.Height;
// Player weapon
SetDrawColor(Renderer, App->Player.WeaponColor);
SDL_Rect WeaponRect = {};
WeaponRect.w = App->Player.WeaponDim.Width;
WeaponRect.h = App->Player.WeaponDim.Height;
switch (App->Player.Dir)
{
case DIRECTION_right:
{
WeaponRect.x = PlayerRect.x + App->TileSize.Width / 2;
WeaponRect.y = PlayerRect.y + App->TileSize.Height / 2 - App->Player.WeaponDim.Height / 2;
}
break;
case DIRECTION_left:
{
WeaponRect.x = PlayerRect.x - App->TileSize.Width / 2;
WeaponRect.y = PlayerRect.y + App->TileSize.Height / 2 - App->Player.WeaponDim.Height / 2;
}
break;
case DIRECTION_up:
{
WeaponRect.h = App->Player.WeaponDim.Width;
WeaponRect.w = App->Player.WeaponDim.Height;
WeaponRect.x = PlayerRect.x + App->TileSize.Width / 2 - App->Player.WeaponDim.Height / 2;
WeaponRect.y = PlayerRect.y - App->TileSize.Height / 2;
}
break;
case DIRECTION_down:
{
WeaponRect.h = App->Player.WeaponDim.Width;
WeaponRect.w = App->Player.WeaponDim.Height;
WeaponRect.x = PlayerRect.x + App->TileSize.Width / 2 - App->Player.WeaponDim.Height / 2;
WeaponRect.y = PlayerRect.y + App->TileSize.Height / 2;
}
break;
default: break;
}
SDL_RenderFillRect(
Renderer,
&WeaponRect
);
// Player body
SetDrawColor(Renderer, App->Player.Color);
SDL_RenderFillRect(
Renderer,
&PlayerRect
);
}
internal void PrintRect(v4* Rect)
{
printf("(%f, %f, %f, %f)\n", Rect->X, Rect->Y, Rect->Width, Rect->Height);
}
void DrawMap(SDL_Renderer* Renderer, app* App)
{
SDL_Rect TileRect = {};
TileRect.w = App->TileSize.Width;
TileRect.h = App->TileSize.Height;
for (u32 Y = 0; Y < App->Map.Dim.H; ++Y)
{
TileRect.y = Y * App->TileSize.H - App->Player.Pos.Y;
for (u32 X = 0; X < App->Map.Dim.W; ++X)
{
TileRect.x = X * App->TileSize.W - App->Player.Pos.X;
switch (App->Map.Tiles[Y][X])
{
case MAP_TILE_TYPE_wall:
SetDrawColor(Renderer, V4(0.3, 0.3, 0.3, 1));
break;
case MAP_TILE_TYPE_ground:
SetDrawColor(Renderer, V4(0.6, 0.6, 0.6, 1));
break;
case MAP_TILE_TYPE_water:
SetDrawColor(Renderer, V4(0, 0, 1, 1));
break;
default:
SetDrawColor(Renderer, V4(1.0, 0.8, 0.9, 1));
break;
}
SDL_RenderFillRect(
Renderer,
&TileRect
);
}
}
}
void DrawRect(SDL_Renderer* Renderer, v4 InRect, v4 Color = V4(1, 1, 1, 1))
{
SDL_Rect Rect = {};
Rect.x = InRect.X;
Rect.y = InRect.Y;
Rect.w = InRect.Width;
Rect.h = InRect.Height;
SetDrawColor(Renderer, Color);
#if 0
SDL_RenderDrawLine(
Renderer,
Rect.x,
Rect.y,
Rect.x + Rect.w,
Rect.y
);
SDL_RenderDrawLine(
Renderer,
Rect.x + Rect.w,
Rect.y,
Rect.x + Rect.w,
Rect.y + Rect.h
);
SDL_RenderDrawLine(
Renderer,
Rect.x + Rect.w,
Rect.y + Rect.h,
Rect.x,
Rect.y + Rect.h
);
SDL_RenderDrawLine(
Renderer,
Rect.x,
Rect.y + Rect.h,
Rect.x,
Rect.y
);
#else
SDL_RenderFillRect(
Renderer,
&Rect
);
#endif
}
void DrawEnemies(SDL_Renderer* Renderer, app* App)
{
for (u32 I = 0; I < App->NumEnemies; ++I)
{
enemy* Enemy = App->Enemies + I;
SDL_Rect EnemyRect = {};
EnemyRect.w = App->TileSize.W;
EnemyRect.h = App->TileSize.H;
f32 FilledPercent = Enemy->HP / (f32)Enemy->MaxHP;
EnemyRect.x = Enemy->Pos.X * EnemyRect.w - App->Player.Pos.X;
EnemyRect.y = Enemy->Pos.Y * EnemyRect.h - App->Player.Pos.Y;
// Enemy health background
SetDrawColor(Renderer, V4(0.3, 0.0, 0.0, 1));
SDL_Rect BGRect = EnemyRect;
SDL_RenderFillRect(
Renderer,
&BGRect
);
// Enemy health
SetDrawColor(Renderer, V4(1, 0, 0, 1));
EnemyRect.y += (1.0f - FilledPercent) * EnemyRect.h;
EnemyRect.h -= (1.0f - FilledPercent) * EnemyRect.h;
SDL_RenderFillRect(
Renderer,
&EnemyRect
);
}
}
void DrawTopBar(SDL_Renderer* Renderer, app* App)
{
SDL_Rect BarRect = {};
BarRect.w = App->Window.Width;
BarRect.h = TOP_BAR_SIZE;
BarRect.x = 0;
BarRect.y = 0;
SetDrawColor(Renderer, V4(0, 0, 0, 0.5));
SDL_RenderFillRect(
Renderer,
&BarRect
);
char* Text = "abcdefghijklmnopqrstuvwxyz\nHello";//"HPj[()]";
DrawTextRevised(Renderer, App, Text, 30, V2I(0, 0));
SetDrawColor(Renderer, V4(1, 1, 1, 1));
SDL_RenderDrawLine(Renderer, 0, TOP_BAR_SIZE, App->Window.Width, TOP_BAR_SIZE);
}
i32 Sign(f32 Value)
{
return (Value > 0) ? 1 : -1;
}
b32 HasCollision(app* App, v4 Rect)
{
for (u32 I = 0; I < App->NumCollisionRects; ++I)
{
if (RectRectIntersect(Rect, App->CollisionRects[I]))
{
#if 0
printf(
"%f,%f,%f,%f - %f,%f,%f,%f\n",
Rect.X, Rect.Y, Rect.Z, Rect.W,
App->CollisionRects[I].X, App->CollisionRects[I].Y, App->CollisionRects[I].Z, App->CollisionRects[I].W
);
#endif
return(true);
}
}
for (u32 I = 0; I < App->NumEnemies; ++I)
{
if (RectRectIntersect(Rect, App->Enemies[I].Rect))
{
return(true);
}
}
return(false);
}
internal enemy* WeaponHitEnemy(app* App)
{
v4 WeaponRect = {};
switch (App->Player.Dir)
{
case DIRECTION_right:
{
WeaponRect = V4(
App->Window.Width/2 - App->TileSize.Width / 2 + App->Player.Pos.X + App->TileSize.W,
App->Window.Height/2 + App->Player.Pos.Y - App->Player.WeaponDim.Height / 2,
App->Player.WeaponDim.Width,
App->Player.WeaponDim.Height
);
}
break;
case DIRECTION_left:
{
WeaponRect = V4(
App->Window.Width/2 - App->TileSize.Width / 2 + App->Player.Pos.X - App->Player.WeaponDim.Width,
App->Window.Height/2 + App->Player.Pos.Y - App->Player.WeaponDim.Height / 2,
App->Player.WeaponDim.Width,
App->Player.WeaponDim.Height
);
}
break;
case DIRECTION_up:
{
WeaponRect = V4(
App->Window.Width/2 - App->TileSize.Width / 2 + App->Player.Pos.X + App->TileSize.W/2 - App->Player.WeaponDim.Height/2,
App->Window.Height/2 - App->TileSize.Height / 2 + App->Player.Pos.Y - App->Player.WeaponDim.Width,
App->Player.WeaponDim.Height,
App->Player.WeaponDim.Width
);
}
break;
case DIRECTION_down:
{
WeaponRect = V4(
App->Window.Width/2 - App->TileSize.Width / 2 + App->Player.Pos.X + App->TileSize.W/2 - App->Player.WeaponDim.Height/2,
App->Window.Height/2 + App->TileSize.Height / 2 + App->Player.Pos.Y,
App->Player.WeaponDim.Height,
App->Player.WeaponDim.Width
);
}
break;
default: break;
}
// NOTE(eric): Draw ephemeral debug rects for weapon and character. Will need
// to pass renderer to this method if you want to use.
#if 0
DrawRect(Renderer, WeaponRect, V4(0, 1, 1, 1));
DrawRect(
Renderer,
V4(
App->Window.Width/2 - App->TileSize.Width / 2 + App->Player.Pos.X,
App->Window.Height/2 - App->TileSize.Height/2 + App->Player.Pos.Y,
App->TileSize.Width,
App->TileSize.Height
),
V4(1, 0, 0, 1)
);
#endif
for (u32 I = 0; I < App->NumEnemies; ++I)
{
enemy* Enemy = App->Enemies + I;
if (Enemy->HP <= 0)
{
continue;
}
#if 0
DrawRect(Renderer, Enemy->Rect, V4(0, 1, 1, 1));
#endif
if (RectRectIntersect(WeaponRect, Enemy->Rect))
{
return(Enemy);
}
}
return(0);
}
void MovePlayerX(app* App, f32 DeltaX)
{
App->Player.Rem.X += DeltaX;
i32 Move = (i32)round(App->Player.Rem.X);
if (Move != 0)
{
App->Player.Rem.X -= Move;
int Sgn = Sign(Move);
v4 PlayerRect = V4(
App->Window.Width/2 - App->TileSize.W/2,
App->Window.Height/2 - App->TileSize.H/2 + 3*App->TileSize.H/4,
App->TileSize.W,
App->TileSize.H/4
);
while (Move != 0)
{
v4 ScreenSpaceAdjust = V4(
App->Player.Pos.X + Sgn,
App->Player.Pos.Y,
0, 0
);
if (!HasCollision(App, PlayerRect + ScreenSpaceAdjust))
{
App->Player.Pos.X += Sgn;
Move -= Sgn;
}
else
{
break;
}
}
}
}
void MovePlayerY(app* App, f32 DeltaY)
{
App->Player.Rem.Y += DeltaY;
i32 Move = (i32)round(App->Player.Rem.Y);
if (Move != 0)
{
App->Player.Rem.Y -= Move;
int Sgn = Sign(Move);
while (Move != 0)
{
v4 PlayerRect = V4(
App->Window.Width/2 - App->TileSize.Width/2,
App->Window.Height/2 - App->TileSize.Height/2,
App->TileSize.W,
App->TileSize.H/4
);
v4 ScreenSpaceAdjust = V4(
App->Player.Pos.X,
App->Player.Pos.Y + 3*App->TileSize.H/4 + Sgn,
0, 0
);
if (!HasCollision(App, PlayerRect + ScreenSpaceAdjust))
{
App->Player.Pos.Y += Sgn;
Move -= Sgn;
}
else
{
break;
}
}
}
}
inline direction DirectionLeft(direction CurrentDir)
{
switch (CurrentDir)
{
case DIRECTION_right:
return(DIRECTION_up);
break;
case DIRECTION_up:
return(DIRECTION_left);
break;
case DIRECTION_left:
return(DIRECTION_down);
break;
case DIRECTION_down:
return(DIRECTION_right);
break;
default: break;
}
return(DIRECTION_MAX);
}
inline direction DirectionRight(direction CurrentDir)
{
switch (CurrentDir)
{
case DIRECTION_right:
return(DIRECTION_down);
break;
case DIRECTION_up:
return(DIRECTION_right);
break;
case DIRECTION_left:
return(DIRECTION_up);
break;
case DIRECTION_down:
return(DIRECTION_left);
break;
default: break;
}
return(DIRECTION_MAX);
}
void TickEnemies(app* App, input* Input)
{
for (u32 I = 0; I < App->NumEnemies; ++I)
{
enemy* Enemy = App->Enemies + I;
if (Enemy->HP <= 0)
{
continue;
}
Enemy->MoveTimer -= Input->DeltaTimeSecs;
if (Enemy->MoveTimer <= 0)
{
Enemy->MoveTimer = Enemy->MoveTimeSecs;
direction MoveDir = RandomDirection();
v2i NewPos = {};
// Calculate new pos
switch (MoveDir)
{
case DIRECTION_right:
{
NewPos = Enemy->Pos + V2I(1, 0);
}
break;
case DIRECTION_left:
{
NewPos = Enemy->Pos - V2I(1, 0);
}
break;
case DIRECTION_up:
{
NewPos = Enemy->Pos - V2I(0, 1);
}
break;
case DIRECTION_down:
{
NewPos = Enemy->Pos + V2I(0, 1);
}
default: break;
}
// Throw away new pos if out of bounds
if (NewPos.X < 0 || NewPos.X >= App->Map.Dim.Width || NewPos.Y < 0 || NewPos.Y >= App->Map.Dim.Height)
{
continue;
}
v4 NewRect = V4(NewPos.X * App->TileSize.W, NewPos.Y * App->TileSize.H, App->TileSize.W, App->TileSize.H);
v4 PlayerRect = V4(
App->Window.Width/2 - App->TileSize.Width/2 + App->Player.Pos.X,
App->Window.Height/2 - App->TileSize.Height/2 + App->Player.Pos.Y,
App->TileSize.W,
App->TileSize.H
);
// Throw away new pos if collision on map
if (App->Map.Tiles[NewPos.Y][NewPos.X] == MAP_TILE_TYPE_wall || App->Map.Tiles[NewPos.Y][NewPos.X] == MAP_TILE_TYPE_water)
{
continue;
}
// Throw away new pos if collision with another enemy
b32 WasIntersection = false;
for (u32 J = 0; J < App->NumEnemies; ++J)
{
// Skip self-collision check
if (I == J)
{
continue;
}
if (RectRectIntersect(NewRect, App->Enemies[J].Rect))
{
WasIntersection = true;
break;
}
}
if (WasIntersection)
{
continue;
}
// Throw away new pos if collision with character
if (RectRectIntersect(PlayerRect, NewRect))
{
continue;
}
Enemy->Pos = NewPos;
Enemy->Rect = NewRect;
}
}
}
void UpdateDialogBox(SDL_Renderer* Renderer, app* App, input* Input)
{
f32 DialogBoxWidth = 800.0f;
f32 DialogBoxHeight = 400.0f;
if (App->DialogIndex >= ArrayCount(Dialog) || Dialog[App->DialogIndex] == 0) {
return;
}
v4 DialogBoxRect = V4(
App->Window.Width / 2 - DialogBoxWidth/2,
App->Window.Height/2 - DialogBoxHeight/8,
DialogBoxWidth,
DialogBoxHeight
);
DrawRect(
Renderer,
DialogBoxRect,
V4(0, 0, 0, 0.5)
);
SetDrawColor(Renderer, V4(1, 1, 1, 1));
SDL_RenderDrawLine(Renderer, DialogBoxRect.X, DialogBoxRect.Y, DialogBoxRect.X + DialogBoxRect.Width, DialogBoxRect.Y);
SDL_RenderDrawLine(Renderer, DialogBoxRect.X + DialogBoxRect.Width, DialogBoxRect.Y, DialogBoxRect.X + DialogBoxRect.Width, DialogBoxRect.Y + DialogBoxRect.Height);
SDL_RenderDrawLine(Renderer, DialogBoxRect.X + DialogBoxRect.Width, DialogBoxRect.Y + DialogBoxRect.Height, DialogBoxRect.X, DialogBoxRect.Y + DialogBoxRect.Height);
SDL_RenderDrawLine(Renderer, DialogBoxRect.X, DialogBoxRect.Y + DialogBoxRect.Height, DialogBoxRect.X, DialogBoxRect.Y);
DrawTextRevised(Renderer, App, Dialog[App->DialogIndex], 30, V2I(DialogBoxRect.X + 10, DialogBoxRect.Y + 10));
if (WasPressed(Input->ActionRight))
{
if (App->DialogIndex < ArrayCount(Dialog))
{
App->DialogIndex++;
}
}
}
void Update(SDL_Renderer* Renderer, app* App, input* Input)
{
// NOTE(eric): Player movement
f32 PlayerVel = 500.0f;
v2 dP = {};
if (App->FadeInSecs <= 0) {
if (IsPressed(Input->Shift))
{
if (WasPressed(Input->MoveLeft))
{
App->Player.Dir = DirectionLeft(App->Player.Dir);
}
else if (WasPressed(Input->MoveRight))
{
App->Player.Dir = DirectionRight(App->Player.Dir);
}
}
else
{
if (IsPressed(Input->MoveLeft))
{
dP.X = -Input->DeltaTimeSecs * PlayerVel;
}
else if (IsPressed(Input->MoveRight))
{
dP.X = Input->DeltaTimeSecs * PlayerVel;
}
if (IsPressed(Input->MoveUp))
{
dP.Y = -Input->DeltaTimeSecs * PlayerVel;
}
else if (IsPressed(Input->MoveDown))
{
dP.Y = Input->DeltaTimeSecs * PlayerVel;
}
}
}
MovePlayerX(App, dP.X);
MovePlayerY(App, dP.Y);
TickEnemies(App, Input);
if (WasPressed(Input->ActionDown) && App->FadeInSecs <= 0)
{
enemy* HitEnemy = WeaponHitEnemy(App);
if (HitEnemy)
{
HitEnemy->HP -= 2;
}
}
DrawMap(Renderer, App);
DrawEnemies(Renderer, App);
DrawPlayer(Renderer, App);
//DrawTopBar(Renderer, App);
if (App->FadeInSecs >= 0.0f) {
DrawRect(Renderer, V4(0, 0, App->Window.Width, App->Window.Height), V4(0, 0, 0, Lerp(0.0f, 1.0f, App->FadeInSecs / App->TotalFadeInSecs)));
App->FadeInSecs -= Input->DeltaTimeSecs;
}
if (App->FadeInSecs <= 0) {
UpdateDialogBox(Renderer, App, Input);
}
// NOTE(eric): Draw collision rects
#if 0
v2 Pos = V2(
App->Window.Width/2 - App->TileSize.W/2,
App->Window.Height/2 - App->TileSize.H/2
);
DrawRect(Renderer, V4(Pos.X, Pos.Y + 3*App->TileSize.H/4, App->TileSize.W, App->TileSize.H/4));
for (u32 I = 0; I < App->NumCollisionRects; ++I)
{
v4 UpdatedRect = App->CollisionRects[I];
UpdatedRect.X -= App->Player.Pos.X;
UpdatedRect.Y -= App->Player.Pos.Y;
DrawRect(Renderer, UpdatedRect);
}
for (u32 I = 0; I < App->NumEnemies; ++I)
{
v4 EnemyRect = App->Enemies[I].Rect;
EnemyRect.X -= App->Player.Pos.X;
EnemyRect.Y -= App->Player.Pos.Y;
DrawRect(Renderer, EnemyRect);
}
#endif
}
void BuildMapCollisionRects(char* Map, v2i MapDim) {
v4 Rects[100];
u32 NumRects = 0;
for (i32 Y = 0; Y < MapDim.Height; ++Y) {
v4 CurrentRect = V4(-1, -1, -1, -1);
for (i32 X = 0; X < MapDim.Width; ++X) {
if (Map[X + Y*MapDim.Width] == 'X') {
if (CurrentRect.X == -1) {
CurrentRect.X = X;
CurrentRect.Y = Y;
CurrentRect.Height = 1;
CurrentRect.Width = 1;
} else {
CurrentRect.Width += 1;
}
} else if (CurrentRect.X != -1) {
Rects[NumRects++] = CurrentRect;
CurrentRect = V4(-1, -1, -1, -1);
}
}
if (CurrentRect.X != -1) {
Rects[NumRects++] = CurrentRect;
}
}
}
void AppInit(app* App)
{
// NOTE(eric): Tile size derived from window size
i32 TileDim = App->Window.Width / TILES_PER_WINDOW_WIDTH;
App->TileSize = V2I(TileDim, TileDim);
App->FadeInSecs = 1.0f;
App->TotalFadeInSecs = 1.0f;
App->DialogIndex = 0;
// NOTE(eric): Load font
if (!FontLoad(//"Inconsolata-Regular.ttf",
FONT_FILE_NAME,
&App->PermArena, &App->Font)) {
fprintf(stderr, "error: Unable to load font '%s'\n", FONT_FILE_NAME);
}
App->Player.Pos = V2(240, 1236);//V2(0, 0);// {{App->Window.Width/2 - TileDim/2, App->Window.Height/2 - TileDim/2}};
App->Player.Color = V4(1, 0, 1, 1);
App->Player.WeaponColor = V4(1, 1, 1, 1);
App->Player.WeaponDim = V2(App->TileSize.Width, App->TileSize.Height / 4);
App->Player.Dir = DIRECTION_right;
// NOTE(eric): Build out our map
App->Map.Dim = V2I(20, 20);
char Array[20][20] = {
{'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X'},
{'X', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', 'X', '_', '_', '_', 'X'},
{'X', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', 'X', '_', '_', '_', 'X'},
{'X', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', 'X', '_', '_', '_', 'X'},
{'X', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', 'X', 'X', 'X', '_', 'X', '_', '_', '_', 'X'},
{'X', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '~', '~', '~', '_', 'X', 'X', 'X', '_', 'X'},
{'X', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '~', '~', '~', '_', '_', '_', '_', '_', 'X'},
{'X', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', 'X'},
{'X', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', 'X'},
{'X', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', 'X'},
{'X', '_', '_', '_', '_', '_', '_', 'X', '_', '_', 'X', '_', '_', '_', '_', '_', '_', '_', '_', 'X'},
{'X', '_', '_', '_', '_', '_', '_', 'X', '_', '_', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X'},
{'X', '_', '_', '_', '_', '_', '_', 'X', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', 'X'},
{'X', '_', '_', '_', '_', '_', '_', 'X', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', 'X'},
{'X', '_', '_', '_', '_', '_', '_', 'X', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', 'X'},
{'X', '_', '_', '_', '_', '_', '_', 'X', '_', '_', '_', 'X', '_', '_', 'X', 'X', '_', '_', '_', 'X'},
{'X', '_', '_', '_', '_', '_', '_', 'X', '_', '_', '_', 'X', '_', '_', '_', 'X', '_', '_', '_', 'X'},
{'X', '_', '_', '_', '_', '_', '_', 'X', '_', '_', '_', 'X', '_', '_', '_', 'X', '_', '_', '_', 'X'},
{'X', '_', '_', '_', '_', '_', '_', 'X', '_', '_', '_', 'X', '_', '_', '_', 'X', '_', '_', '_', 'X'},
{'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X'},
};
memcpy(&App->Map.Tiles, Array, sizeof(char)*App->Map.Dim.X*App->Map.Dim.Y);
BuildMapCollisionRects((char*)App->Map.Tiles, App->Map.Dim);
// NOTE(eric): Place enemies
for (u32 I = 0; I < 5; ++I)
{
enemy* Enemy = App->Enemies + App->NumEnemies;
// HP Initialization
Enemy->HP = 10;
Enemy->MaxHP = 10;
Enemy->MoveTimeSecs = 5;
Enemy->MoveTimer = 5;
// Find random position
b32 ValidPos = false;
v4 PlayerRect = V4(
App->Window.Width/2 - App->TileSize.Width/2 + App->Player.Pos.X,
App->Window.Height/2 - App->TileSize.Height/2 + App->Player.Pos.Y + 3*App->TileSize.H/4,
App->TileSize.W,
App->TileSize.H/4
);
do {
Enemy->Pos = V2I(RandomI32(0, App->Map.Dim.W), RandomI32(0, App->Map.Dim.H));
Enemy->Rect = V4(Enemy->Pos.X * App->TileSize.W, Enemy->Pos.Y * App->TileSize.H, App->TileSize.W, App->TileSize.H);
if (App->Map.Tiles[Enemy->Pos.Y][Enemy->Pos.X] == MAP_TILE_TYPE_ground)
{
b32 AnotherEntityAtPos = false;
// Check enemy collision
for (u32 J = 0; J < App->NumEnemies; ++J)
{
if (App->Enemies[J].Pos == Enemy->Pos)
{
AnotherEntityAtPos = true;
}
}
// Check player collision
if (RectRectIntersect(Enemy->Rect, PlayerRect))
{
AnotherEntityAtPos = true;
}
ValidPos = !AnotherEntityAtPos;
}
} while (!ValidPos);
++App->NumEnemies;
}
// NOTE(eric): Build collision rects
for (u32 Y = 0; Y < App->Map.Dim.Height; ++Y)
{
for (u32 X = 0; X < App->Map.Dim.Width; ++X)
{
if (App->Map.Tiles[Y][X] == MAP_TILE_TYPE_wall || App->Map.Tiles[Y][X] == MAP_TILE_TYPE_water)
{
App->CollisionRects[App->NumCollisionRects++] = {{
(f32)X * App->TileSize.Width,
(f32)Y * App->TileSize.Height,
(f32)App->TileSize.Width,
(f32)App->TileSize.Height
}};
}
}
}
printf("Collision Rects: %d\n", App->NumCollisionRects);
}
int main()
{
{
SDL_Init(SDL_INIT_EVERYTHING);
SDL_Window* Window = SDL_CreateWindow(
"Tiler",
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
WINDOW_WIDTH,
WINDOW_HEIGHT,
SDL_WINDOW_ALLOW_HIGHDPI
);
SDL_Renderer* Renderer = SDL_CreateRenderer(Window, -1, SDL_RENDERER_ACCELERATED|SDL_RENDERER_PRESENTVSYNC);
// NOTE(eric): Handle High DPI displays where drawable size is possibly
// larger than window size.
int Width, Height;
SDL_GetRendererOutputSize(Renderer, &Width, &Height);
// NOTE(eric): Allocate storage arenas
u32 PermanentStorageSize = Megabytes(64);
u8* PermanentStorage = (u8*)malloc(PermanentStorageSize);
u32 TemporaryStorageSize = Megabytes(64);
u8* TemporaryStorage = (u8*)malloc(TemporaryStorageSize);
// NOTE(eric): Seed RNG before app initialization. Maybe move this into
// AppInit?
SeedRandomNumberGenerator();
app App = {};
App.Running = true;
App.Window = {{(f32)Width, (f32)Height}};
App.PermArena = ArenaInit(PermanentStorage, PermanentStorageSize);
App.TempArena = ArenaInit(TemporaryStorage, TemporaryStorageSize);
AppInit(&App);
input Input = {};
SDL_SetRenderDrawBlendMode(Renderer, SDL_BLENDMODE_BLEND);
SDL_Event Event;
u32 LastTime = SDL_GetTicks();
while (App.Running)
{
while (SDL_PollEvent(&Event))
{
if (Event.type == SDL_QUIT)
{
App.Running = false;
}
else if (Event.type == SDL_KEYDOWN || Event.type == SDL_KEYUP)
{
SDL_Keycode KeyCode = Event.key.keysym.sym;
b32 IsDown = (Event.key.state == SDL_PRESSED);
b32 WasDown = (Event.key.state == SDL_RELEASED && Event.key.repeat == 0);
if (KeyCode == SDLK_ESCAPE)
{
App.Running = false;
}
else if (IsDown != WasDown)
{
switch (KeyCode)
{
case SDLK_LEFT:
LinuxProcessKeyDown(&Input.MoveLeft, IsDown);
break;
case SDLK_RIGHT:
LinuxProcessKeyDown(&Input.MoveRight, IsDown);
break;
case SDLK_UP:
LinuxProcessKeyDown(&Input.MoveUp, IsDown);
break;
case SDLK_DOWN:
LinuxProcessKeyDown(&Input.MoveDown, IsDown);
break;
case SDLK_RETURN:
LinuxProcessKeyDown(&Input.ActionRight, IsDown);
break;
case SDLK_SPACE:
LinuxProcessKeyDown(&Input.ActionDown, IsDown);
break;
case SDLK_LSHIFT:
case SDLK_RSHIFT:
LinuxProcessKeyDown(&Input.Shift, IsDown);
break;
default: break;
}
}
}
}
SDL_SetRenderDrawColor(Renderer, 0, 0, 0, SDL_ALPHA_OPAQUE);
SDL_RenderClear(Renderer);
u32 CurrentTime = SDL_GetTicks();
//Input.DeltaTimeSecs = (CurrentTime - LastTime) / 1000.0f;
Input.DeltaTimeSecs = 1/60.0f;
Update(Renderer, &App, &Input);
LastTime = CurrentTime;
for (u32 I = 0; I < ArrayCount(Input.Keys); ++I)
{
Input.Keys[I].HalfTransitionCount = 0;
}
SDL_RenderPresent(Renderer);
}
free(TemporaryStorage);
free(PermanentStorage);
SDL_DestroyRenderer(Renderer);
SDL_DestroyWindow(Window);
SDL_Quit();
}
return(0);
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.