YourWishes/Dawn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Begin refactor.

Browse Source
This commit is contained in:
Dominic Masters
2021-09-18 23:13:05 -07:00
parent 98daedced9
commit 6904a46bec
143 changed files with 1706 additions and 2345 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -74,7 +74,6 @@ file(COPY ${CMAKE_CURRENT_LIST_DIR}/assets DESTINATION ${CMAKE_CURRENT_BINARY_DI
##################################### LIBS #####################################
include_directories(${CMAKE_SOURCE_DIR}/lib/stb)
include_directories(${CMAKE_SOURCE_DIR}/include)
# RG351
if(${SETTING_TARGET} EQUAL ${SETTING_TARGET_RG351})

100
include/dawn/dawn.h
View File

@ -1,100 +0,0 @@
// Copyright (c) 2021 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "libs.h"
// Display / Rendering
#include "display/animation/easing.h"
#include "display/animation/queue.h"
#include "display/animation/timeline.h"
#include "display/bitmapfont.h"
#include "display/camera.h"
#include "display/font.h"
#include "display/framebuffer.h"
#include "display/matrix.h"
#include "display/primitive.h"
#include "display/render.h"
#include "display/renderlist.h"
#include "display/scene.h"
#include "display/shader.h"
#include "display/spritebatch.h"
#include "display/texture.h"
#include "display/tileset.h"
// Game Engine
#include "engine/engine.h"
// Time Management
#include "epoch/epoch.h"
// File / Asset Management
#include "file/asset.h"
#include "file/csv.h"
#include "file/xml.h"
// Game Logic
#include "game/game.h"
#include "game/dawn/dawngame.h"
#include "game/poker/ui/pokerplayerui.h"
#include "game/poker/ui/pokerui.h"
#include "game/poker/pokerdiscussion.h"
#include "game/poker/pokergame.h"
#include "game/poker/pokergameaction.h"
#include "game/poker/pokergameassets.h"
#include "game/poker/pokerworld.h"
#include "game/sandbox/sandboxscene.h"
// Player Input
#include "input/input.h"
// Locales
#include "locale/language.h"
// Physics
#include "physics/aabb.h"
// Poker Game Logic
#include "poker/bet.h"
#include "poker/card.h"
#include "poker/dealer.h"
#include "poker/player.h"
#include "poker/poker.h"
#include "poker/turn.h"
#include "poker/winner.h"
// Script engine
#include "script/scripter.h"
// User Interface Objects
#include "ui/align.h"
#include "ui/breakpoint.h"
#include "ui/frame.h"
#include "ui/framedtextmenu.h"
#include "ui/grid.h"
#include "ui/image.h"
#include "ui/label.h"
#include "ui/menu.h"
#include "ui/rectangle.h"
#include "ui/textmenu.h"
// Utility Objects
#include "util/array.h"
#include "util/dynarray.h"
#include "util/flags.h"
#include "util/list.h"
#include "util/math.h"
#include "util/rand.h"
#include "util/string.h"
// Visual Novel Objects
#include "vn/vncharacter.h"
#include "vn/vnconversation.h"
#include "vn/vnscene.h"
#include "vn/vntextbox.h"

58
include/dawn/display/animation/queue.h
View File

@ -1,58 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../../libs.h"
#define ANIMATION_QUEUE_ITEM_MAX 128
#define ANIMATION_QUEUE_START 0xFF
typedef struct _queueaction_t queueaction_t;
typedef struct _queue_t queue_t;
/**
* Callback for queue events.
* @param conversation Conversation this text is attached to.
* @param text Text item that is being used in the callback
* @param i Index of the item in the queue.
*/
typedef void queuecallback_t(queue_t *queue, queueaction_t *action, uint8_t i);
typedef struct _queueaction_t {
/** Index that the action is within the queue */
uint8_t index;
/** Pointer to any custom user data */
void *data;
/** Callback to fire the moment the action is active in the queue */
queuecallback_t *onStart;
/** Callback to fire when this action has ended */
queuecallback_t *onEnd;
/** Callback to fire every update of this queue while action is active. */
queuecallback_t *onUpdate;
} queueaction_t;
typedef struct _queue_t {
/** Array of items within the queue. */
queueaction_t items[ANIMATION_QUEUE_ITEM_MAX];
uint8_t count;
/** Current index within the array of actions that is currently processing */
uint8_t current;
/** Internal timeline tracking */
float timeline;
/** Time that the current aciton started */
float actionStarted;
/** Delay Queue Item Storage */
float delays[ANIMATION_QUEUE_ITEM_MAX];
} queue_t;

78
include/dawn/display/animation/timeline.h
View File

@ -1,78 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../../libs.h"
/** Maximum number of actions a timeline can support, smaller than 0xFF */
#define TIMELINE_ACTION_COUNT_MAX 128
/** Type forwarders */
typedef struct _timeline_t timeline_t;
typedef struct _timelineaction_t timelineaction_t;
/**
* Callback for when a timeline event occurs
* @param timeline The timeline that fired this callback.
* @param action The action that this callback is attached to.
* @param i The index that this action is within the timeline.
*/
typedef void timelinecallback_t(timeline_t *timeline, timelineaction_t *action,
uint8_t i
);
typedef struct _timelineaction_t {
/** Pointer to any custom user data the timeline action wants to use. */
void *data;
/**
* The time that this action should occur within the timeline
* set to 0 or less to start immediately.
*/
float start;
/**
* The duration of the action, this will decide for how long onDuration will
* be called for, and when onEnd should be called.
* Set to a negative number to have this continue forever.
* Set to 0 to only fire the onStart.
* onStart can fire with either onDuration and onEnd on the same frame, but
* onEnd and onDuration cannot fire the same frame.
*/
float duration;
/**
* Enables animation looping. This works by forcing start to be equal to the
* current time at the point in time that onEnd is called. This will also stop
* onStart being called so ensure that your onStart and onEnd logic works.
*/
bool loop;
timelinecallback_t *onStart;
timelinecallback_t *onDuration;
timelinecallback_t *onEnd;
} timelineaction_t;
typedef struct _timeline_t {
/** The current time as far as the timeline is concerned */
float current;
/** The time of the last "frame" as far as the timeline is concerned */
float previous;
/** The frame time diff, essentially current = previous + diff */
float diff;
/** User pointer, allows you to point to some other data */
void *user;
/** Actions within the timeline */
timelineaction_t actions[TIMELINE_ACTION_COUNT_MAX];
uint8_t actionCount;
} timeline_t;

26
include/dawn/display/bitmapfont.h
View File

@ -1,26 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
/** Which is the first character within the font tilemap */
#define BITMAP_FONT_CHAR_START 33
/** Center a font along the X axis */
#define BITMAP_FONT_CENTER_X 9876543
/** Center a font along the Y axis */
#define BITMAP_FONT_CENTER_Y -BITMAP_FONT_CENTER_X
/** Align right edge of font to origin */
#define BITMAP_FONT_RIGHT_X (BITMAP_FONT_CENTER_X-1)
typedef struct {
float width, height;
int32_t lines;
} bitmapfontmeasure_t;

19
include/dawn/display/camera.h
View File

@ -1,19 +0,0 @@
/**
* Copyright (c) 2021 Dominic Msters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#include "matrix.h"
/** The math for the camera is stored here. */
typedef struct {
/** View Matrix (Where the camera looks) */
matrix_t view;
/** Projection Matrix (How the camera looks) */
matrix_t projection;
} camera_t;

82
include/dawn/display/font.h
View File

@ -1,82 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#include "texture.h"
/** Which character (ASCII) to start the font from */
#define FONT_FIRST_CHAR 32
/** How many characters (after the first char) to generate */
#define FONT_NUM_CHARS 96
/** Width of the loaded font texture */
#define FONT_TEXTURE_WIDTH 1024
/** Height of the loaded font texture */
#define FONT_TEXTURE_HEIGHT FONT_TEXTURE_WIDTH
/** Refer to STBTT docs for OpenGL Fill Mode v d3d Fill Modes */
#define FONT_FILL_MODE 1
/** Passed to STBTT for scaling the font, essentially the font resolution */
#define FONT_TEXTURE_SIZE 64.0f
/** The global scale, just used to provide fine control of font sizes */
#define FONT_GLOBAL_SCALE 0.5f;
/** Default Font Size (on which all font scales are based) */
#define FONT_SIZE_DEFAULT 16.0f
// Chars
#define FONT_NEWLINE '\n'
#define FONT_SPACE ' '
// Heights
#define FONT_LINE_HEIGHT FONT_TEXTURE_SIZE * 0.75f
#define FONT_INITIAL_LINE FONT_LINE_HEIGHT * 0.75f
#define FONT_SPACE_SIZE FONT_TEXTURE_SIZE * 0.45f
/** Maximum number of characters a font text info can hold. */
#define FONT_TEXT_INFO_CHARS_MAX 1024
/** Maximum number of newlines that a font text info can hold. */
#define FONT_TEXT_INFO_LINES_MAX FONT_TEXT_INFO_CHARS_MAX/50
/** Representation of a font that can be used to render text */
typedef struct {
texture_t texture;
stbtt_bakedchar characterData[FONT_NUM_CHARS];
} font_t;
typedef struct {
/** What (real character) index the line starts at */
int32_t start;
/** How many (real) characters the line is in length */
int32_t length;
} fonttextinfoline_t;
typedef struct {
/** How many raw chars are in the string */
int32_t length;
/** How many real characters (non whitespace) are in the string */
int32_t realLength;
/** How many lines is the string? Trailing newlines will count */
int32_t lineCount;
/** The real character info for each line */
fonttextinfoline_t lines[FONT_TEXT_INFO_LINES_MAX];
/** Dimensions of the string */
float width, height;
/** Array of precalculated quads */
stbtt_aligned_quad quads[FONT_TEXT_INFO_CHARS_MAX];
} fonttextinfo_t;

16
include/dawn/display/framebuffer.h
View File

@ -1,16 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#include "texture.h"
typedef struct {
GLuint fboId;
GLuint rboId;
texture_t texture;
} framebuffer_t;

18
include/dawn/display/matrix.h
View File

@ -1,18 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
/**
* Representation for a matrix. Used as a highlevel wrapper for the math
* functions that sit underneath this API.
*/
typedef struct {
/** Internal Matrix API */
mat4 internalMatrix;
} matrix_t;

36
include/dawn/display/primitive.h
View File

@ -1,36 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#define PRIMITIVE_POSITIONS_PER_VERTICE 3
#define PRIMITIVE_COORDINATES_PER_VERTICE 2
/** Structure containing information about a primitive */
typedef struct {
/** How many vertices are in the primitive */
int32_t verticeCount;
/** How many indices are in the primitive */
int32_t indiceCount;
/** Pointer to the vertex buffer on the GPU */
GLuint vertexBuffer;
/** Pointer to the index buffer on the GPU */
GLuint indexBuffer;
} primitive_t;
/** Structure containing vertice position information */
typedef struct {
/** Coordinates */
float x, y, z;
/** Texture UVs */
float u, v;
} vertice_t;
/** Indice that references a specific vertice */
typedef unsigned int indice_t;

16
include/dawn/display/render.h
View File

@ -1,16 +0,0 @@
// Copyright (c) 2021 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "../libs.h"
/**
* Contains information about the current render state, can be used for querying
* how the renderer is currently set up.
*/
typedef struct {
/** Resolution (in pixels). Floats to allow subpixels in future. */
float width, height;
} render_t;

35
include/dawn/display/renderlist.h
View File

@ -1,35 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#include "../util/dynarray.h"
#include "../engine/engine.h"
#include "framebuffer.h"
#include "shader.h"
#include "primitive.h"
typedef struct {
framebuffer_t frame;
shader_t *shader;
} renderpass_t;
typedef struct {
framebuffer_t frame;
primitive_t quad;
dynarray_t passes;
void *user;
} renderlist_t;
typedef void renderitemcallback_t(
renderlist_t *list, renderpass_t *pass, engine_t *engine, int32_t i
);
typedef struct {
renderitemcallback_t *onRender;
} renderitem_t;

46
include/dawn/display/scene.h
View File

@ -1,46 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#include "../engine/engine.h"
/** Maximum number of items a scene can support */
#define SCENE_ITEMS_MAX 32
typedef struct _scene_t scene_t;
typedef struct _sceneitem_t sceneitem_t;
/**
* Callback for when scene events occur.
*
* @param scene The scene that is being evented.
* @param i The index of the current scene item.
* @param engine The game's engine.
*/
typedef void sceneitemcallback_t(
scene_t *scene, int32_t i, engine_t *engine
);
typedef struct _sceneitem_t {
sceneitemcallback_t *onUpdate;
sceneitemcallback_t *onRender;
sceneitemcallback_t *onDispose;
} sceneitem_t;
typedef struct _scene_t {
/** Camera that is used to render the scene */
camera_t camera;
/** Any custom user data pointer */
void *user;
/** Items within the scene */
sceneitem_t items[SCENE_ITEMS_MAX];
int32_t itemCount;
} scene_t;

48
include/dawn/display/shader.h
View File

@ -1,48 +0,0 @@
/**
* Copyright (c) 2021 Dominic Msters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#define SHADER_UNI_VIEW "u_View"
#define SHADER_UNI_PROJ "u_Proj"
#define SHADER_UNI_TEXT "u_Text"
#define SHADER_UNI_MODL "u_Modl"
#define SHADER_UNI_COLR "u_Colr"
/** Representation of a shader uniform */
typedef GLuint shaderuniform_t;
/**
* Structure containing information about an OpenGL Shader. For simplicity sake
* we demand certain uninforms to be present on the shader target.
*/
typedef struct {
/** Pointer to an uploaded vertex shader program */
shaderuniform_t shaderVertex;
/** Pointer to an uploaded fragment shader program */
shaderuniform_t shaderFrag;
/** Pointer to an uploaded shader program linked */
shaderuniform_t shaderProgram;
/** Matrix for the view matrix */
shaderuniform_t uniView;
/** Matrix for the projection matrix */
shaderuniform_t uniProj;
/** Uniform for the current texture */
shaderuniform_t uniText;
/** Uniform for the current model world position */
shaderuniform_t uniModl;
/** Uniform for the color multiplier */
shaderuniform_t uniColr;
} shader_t;

21
include/dawn/display/spritebatch.h
View File

@ -1,21 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
/** Definition of a Sprite Batch. */
typedef struct {
/** Maximum sprites the batch can hold. */
int32_t maxSprites;
/** The current/next sprite index. */
int32_t currentSprite;
/** Internal primitive */
primitive_t primitive;
} spritebatch_t;

34
include/dawn/display/texture.h
View File

@ -1,34 +0,0 @@
// Copyright (c) 2021 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "../libs.h"
/**
* Structure detailing information about a texture.
* Because we plan to upload the pixels of a texture into the GPU, we don't
* store the pixels in memory because we don't need to!
*/
typedef struct {
/** Width (in pixels) of the texture */
int32_t width;
/** Height (in pixels) of the texture */
int32_t height;
/** Texture ID on the GPU */
GLuint id;
} texture_t;
/** Information about a single pixel. */
typedef struct {
/** RGBA Color values */
uint8_t r, g, b, a;
} pixel_t;
#define PIXEL_COLOR_WHITE ((pixel_t){ .r = 255, .g = 255, .b = 255, .a = 255 })
#define PIXEL_COLOR_RED ((pixel_t){ .r = 255, .g = 0, .b = 0, .a = 255 })
#define PIXEL_COLOR_GREEN ((pixel_t){ .r = 0, .g = 255, .b = 0, .a = 255 })
#define PIXEL_COLOR_BLUE ((pixel_t){ .r = 0, .g = 0, .b = 255, .a = 255 })
#define PIXEL_COLOR_BLACK ((pixel_t){ .r = 0, .g = 0, .b = 0, .a = 255 })
#define PIXEL_COLOR_TRANSPARENT ((pixel_t){ .r = 0, .g = 0, .b = 0, .a = 0 })

27
include/dawn/display/tileset.h
View File

@ -1,27 +0,0 @@
// Copyright (c) 2021 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "../libs.h"
/** Division of a texture */
typedef struct {
float x0, y0, x1, y1;
} tilesetdiv_t;
/** Definition of a Tileset */
typedef struct {
/** Count of X/Y divisions */
int32_t columns, rows;
/** Size of each divison (in pixels) */
float divX, divY;
/** Count of divisions (unused) */
int32_t count;
/** Division information */
tilesetdiv_t *divisions;
} tileset_t;

22
include/dawn/engine/engine.h
View File

@ -1,22 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../display/render.h"
#include "../input/input.h"
#include "../epoch/epoch.h"
typedef struct {
/** Time Manager for the game */
epoch_t time;
/** Render Manager for the game */
render_t render;
/** Input Manager for the game */
input_t input;
} engine_t;

41
include/dawn/epoch/epoch.h
View File

@ -1,41 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#define EPOCH_FIXED_STEP 0.016f
#define EPOCH_SMALLEST_STEP 0.001f
typedef struct {
/**
* Current time (as a float of seconds since game start).
*
* When time is initialized this will start at a fixed value of 2/60ths of a
* second, regardless of what engine the game is running.
*
* This is to avoid any divide by zero errors.
*/
float current;
/**
* Last Time (as a float of seconds since the game start).
*
* This value will start at 1/60th of a second regardless of engine the game
* is running on to avoid divide by zero errors.
*/
float last;
/**
* Varying timestep that occured since the last frame.
*/
float delta;
/**
* Fixed timestep that is not affected by framerate but remains consistent.
*/
float fixedDelta;
} epoch_t;

10
include/dawn/file/asset.h
View File

@ -1,10 +0,0 @@
// Copyright (c) 2021 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "../libs.h"
/** Definition of an asset ready to be buffered */
typedef FILE assetbuffer_t;

92
include/dawn/file/csv.h
View File

@ -1,92 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#include "asset.h"
/** Maximum characters that a cell can support */
#define CSV_BUFFER_SIZE 32
/** Maximum characters in any given cell */
#define CSV_CELL_SIZE_MAX 1024
/** Maximum number of columns/cells in a given row */
#define CSV_ROW_COLUMNS_MAX 16
/** Count of characters maximum that a row can support */
#define CSV_ROW_CHARACTERS_MAX CSV_CELL_SIZE_MAX * CSV_ROW_COLUMNS_MAX
/** Result of a CSV buffer operation. */
typedef struct {
/** How many rows within the CSV */
int32_t rowCount;
/** Count of columns in the CSV, this is the longest row in the CSV. */
int32_t columnCount;
/** How many cells within the CSV */
int32_t cellCount;
} csvbufferresult_t;
/** Callback to receive data for each cell in a CSV being buffered */
typedef bool csvbuffercallback_t(
assetbuffer_t *asset, void *user, int32_t row, int32_t column, char *data
);
/** Representation of a CSV Row's complete data. */
typedef struct {
/** Characters within the row */
char data[CSV_ROW_CHARACTERS_MAX];
/** Pointer to the start of each string within the row */
char *columns[CSV_ROW_COLUMNS_MAX];
/** How many columns within the row */
int32_t columnCount;
} csvrow_t;
/** Callback to receive buffer data for a CSV row */
typedef bool csvbufferrowcallback_t(
assetbuffer_t *asset, void *user, int32_t row, csvrow_t *csv
);
/** Callback to receive buffer data for a CSV row, but includes CSV headers. */
typedef bool csvbufferrowwitheaderscallback_t(
assetbuffer_t *asset, void *user, int32_t row,
csvrow_t *header, csvrow_t *current
);
/** Data used by the cell callback for when the row buffering is progressing */
typedef struct {
/** Which row the current buffer is on */
int32_t row;
/** Information about the current row being parsed */
csvrow_t rowCurrent;
/** Pointer to custom user data */
void *user;
/** Pointer to custom user callback */
csvbufferrowcallback_t *callback;
} csvbufferrowdata_t;
/** Data used by the row callback for when the header row is parsed */
typedef struct {
/** Information about the header row */
csvrow_t headerRow;
/** Pointer to custom user data */
void *user;
/** Pointer to custom user callback */
csvbufferrowwitheaderscallback_t *callback;
} csvbufferrowwithheadersdata_t;
/** Data used while searching a CSV */
typedef struct {
/** Row to store the data in */
csvrow_t *row;
/** Row's index */
int32_t rowIndex;
/** Column to check */
int32_t column;
/** Value to check row */
char *value;
} csvsearchdata_t;

35
include/dawn/file/xml.h
View File

@ -1,35 +0,0 @@
// Copyright (c) 2021 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "../libs.h"
#define XML_DOING_NOTHING 0x00
#define XML_PARSING_TAG_NAME 0x01
#define XML_LOOKING_FOR_ATTRIBUTE 0x02
#define XML_PARSING_ATTRIBUTE_NAME 0x03
#define XML_LOOKING_FOR_ATTRIBUTE_VALUE 0x04
#define XML_PARSING_ATTRIBUTE_VALUE 0x05
#define XML_PARSING_VALUE 0x06
#define XML_PARSING_CHILD 0x07
#define XML_PARSING_CLOSE 0x08
#define XML_TEXT_BUFFER_MAX 256
#define XML_CHILD_COUNT_MAX 16
#define XML_ATTRIBUTE_MAX 16
typedef struct _xml_t xml_t;
typedef struct _xml_t {
char *node;
char *value;
char *attributeNames[XML_ATTRIBUTE_MAX];
char *attributeDatas[XML_ATTRIBUTE_MAX];
uint8_t attributeCount;
xml_t *children;
uint8_t childrenCount;
} xml_t;

13
include/dawn/game/dawn/dawngame.h
View File

@ -1,13 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../../libs.h"
typedef struct {
int32_t INeedSomePropertyToStopCompilerComplaining;
} dawngame_t;

30
include/dawn/game/game.h
View File

@ -1,30 +0,0 @@
// Copyright (c) 2021 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "../libs.h"
#include "../engine/engine.h"
#if SETTING_GAME == SETTING_GAME_POKER
#include "poker/pokergame.h"
#elif SETTING_GAME == SETTING_GAME_DAWN
#include "dawn/dawngame.h"
#elif SETTING_GAME == SETTING_GAME_SANDBOX
#include "sandbox/sandboxscene.h"
#endif
/** Describes the current game */
typedef struct {
/** Engine for the game */
engine_t engine;
#if SETTING_GAME == SETTING_GAME_POKER
pokergame_t pokerGame;
#elif SETTING_GAME == SETTING_GAME_DAWN
dawngame_t dawnGame;
#elif SETTING_GAME == SETTING_GAME_SANDBOX
sandboxscene_t sandboxScene;
#endif
} game_t;

65
include/dawn/game/poker/pokergame.h
View File

@ -1,65 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../../libs.h"
#include "../../display/animation/queue.h"
#include "pokergameassets.h"
#include "pokerworld.h"
#include "pokergameaction.h"
#include "ui/pokerui.h"
#include "../../engine/engine.h"
#include "../../poker/poker.h"
#include "../../poker/player.h"
#include "../../poker/dealer.h"
#include "../../vn/vnconversation.h"
#include "../../vn/vnscene.h"
#define POKER_GAME_SEAT_COUNT 8
#define POKER_GAME_SEAT_FOR_PLAYER(p) (p - (POKER_PLAYER_COUNT/2))
#define POKER_GAME_SEAT_DEALER POKER_GAME_SEAT_FOR_PLAYER(POKER_DEALER_INDEX)
/**
* Return the seat for a given player index, also works for the dealer index.
* @param i The players index.
* @return The players seat number.
*/
#define pokerGameSeatFromIndex(i) (\
i == POKER_DEALER_INDEX ? \
POKER_GAME_SEAT_DEALER : \
POKER_GAME_SEAT_FOR_PLAYER(i) \
)
#define POKER_GAME_PENNY_BASE_WIDTH 1000
#define POKER_GAME_PENNY_BASE_HEIGHT 1920
#define POKER_GAME_PENNY_FACE_X 367
#define POKER_GAME_PENNY_FACE_Y 256
#define POKER_GAME_PENNY_FACE_WIDTH 280
#define POKER_GAME_PENNY_FACE_HEIGHT 280
typedef struct {
/** Poker Game State */
poker_t poker;
/** Visual Novel Engine */
vnscene_t scene;
/** Assets (Files) for the game. */
pokergameassets_t assets;
/** Poker Game World. */
pokerworld_t world;
/** UI For the Game */
pokerui_t ui;
/** Data for the actions */
pokergameactiondata_t actionData[ANIMATION_QUEUE_ITEM_MAX];
/** Pointer back to the game engine */
engine_t *engine;
} pokergame_t;

23
include/dawn/game/poker/pokergameassets.h
View File

@ -1,23 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../../display/font.h"
#include "../../display/shader.h"
#include "../../locale/language.h"
typedef struct {
font_t font;
shader_t shader;
language_t language;
texture_t testTexture;
texture_t roomTexture;
texture_t cardTexture;
texture_t pennyTexture;
} pokergameassets_t;

26
include/dawn/game/poker/pokerworld.h
View File

@ -1,26 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../../libs.h"
#include "../../util/math.h"
#include "../../display/primitive.h"
#define POKER_WORLD_SEAT_DISTANCE -1
#define POKER_WORLD_SEAT_ROTATION(n) (n * mathDeg2Rad(45.0f))
#define POKER_WORLD_SEAT_POSITION_X(n) ( \
POKER_WORLD_SEAT_DISTANCE * (float)sin(POKER_WORLD_SEAT_ROTATION(n)) \
)
#define POKER_WORLD_SEAT_POSITION_Y -0.2f
#define POKER_WORLD_SEAT_POSITION_Z(n) ( \
POKER_WORLD_SEAT_DISTANCE * (float)cos(POKER_WORLD_SEAT_ROTATION(n)) \
)
typedef struct {
primitive_t skywall;
} pokerworld_t;

35
include/dawn/game/poker/ui/pokerplayerui.h
View File

@ -1,35 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../../../libs.h"
#include "../../../ui/label.h"
#include "../../../ui/image.h"
#include "../../../display/framebuffer.h"
#include "../../../display/camera.h"
#include "../../../ui/grid.h"
#include "../../../ui/align.h"
#define POKER_PLAYER_UI_IMAGE_SIZE 64
#define POKER_PLAYER_UI_WIDTH 300
#define POKER_PLAYER_UI_HEIGHT POKER_PLAYER_UI_IMAGE_SIZE
#define POKER_PLAYER_UI_IMAGE_RESOLUTION POKER_PLAYER_UI_IMAGE_SIZE * 2
#define POKER_PLAYER_UI_IMAGE_DIST 0.8f
#define POKER_PLAYER_UI_IMAGE_Y 0.1f
#define POKER_PLAYER_UI_PADDING 8
#define POKER_PLAYER_UI_CHIPS_ANIMATION_SPEED 0.5f
typedef struct {
framebuffer_t frame;
primitive_t quad;
label_t label;
grid_t grid;
} pokerplayerui_t;

17
include/dawn/game/poker/ui/pokerui.h
View File

@ -1,17 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../../../libs.h"
#include "../../../poker/player.h"
#include "pokerplayerui.h"
#include "../../../ui/image.h"
typedef struct {
pokerplayerui_t player[POKER_PLAYER_COUNT];
image_t card;
} pokerui_t;

24
include/dawn/game/sandbox/sandboxscene.h
View File

@ -1,24 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../../libs.h"
#include "../../display/camera.h"
#include "../../display/shader.h"
#include "../../display/font.h"
#include "../../display/primitive.h"
#include "../../display/renderlist.h"
#include "../../display/texture.h"
typedef struct {
camera_t camera;
primitive_t primitive;
texture_t texture;
shader_t shader;
font_t font;
} sandboxscene_t;

72
include/dawn/input/input.h
View File

@ -1,72 +0,0 @@
// Copyright (c) 2021 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "../libs.h"
#include "../util/list.h"
/** Debug Inputs */
#define INPUT_NULL (inputbind_t)0x00
/** Real Inputs (Starts at 32/0x20) */
#define INPUT_UP (inputbind_t)0x20
#define INPUT_DOWN (inputbind_t)0x21
#define INPUT_LEFT (inputbind_t)0x22
#define INPUT_RIGHT (inputbind_t)0x23
#define INPUT_ACCEPT (inputbind_t)0x24
/** Additional sources */
#define INPUT_MOUSE_X (inputsource_t)0x10
#define INPUT_MOUSE_Y (inputsource_t)0x11
#define INPUT_BIND_COUNT 0x40
#define INPUT_SOURCE_COUNT 0xFF
/**
* Input Bind, a specific action bind reference for the game engine to use.
* e.g. "Jump" or "Walk Forward".
*/
typedef uint8_t inputbind_t;
/**
* Input source identifier. It's up to the platform itself to decide what the
* hell this number refers to. For most platforms it will be an input, such as a
* keyboard scancode or a (pad number * button count) + button.
*/
typedef uint8_t inputsource_t;
/**
* Value that represents the state of an input. Defined as 0-1 where 0 is set
* to be completely off / netural state, and 1 is completely on / full state.
*/
typedef float inputval_t;
/**
* Structure for the entire input mapping.
*/
typedef struct {
/** Float of the input between 0 and 1. */
inputval_t inputsA[INPUT_BIND_COUNT];
/** Float of the input between 0 and 1. */
inputval_t inputsB[INPUT_BIND_COUNT];
/** Flippable state */
inputval_t *current, *previous;
/**
* Binding Map, Array of lists where index = binding and entry is a list of
* input sources.
*/
list_t *bindMap[INPUT_BIND_COUNT];
/**
* Input buffer array. Keeps track of raw values from the inputs.
* The engine will read from the buffer when necessary.
*/
inputval_t buffer[INPUT_SOURCE_COUNT];
/** Float of the GameTime that the input was actuated last. */
float times[INPUT_BIND_COUNT];
} input_t;

34
include/dawn/locale/language.h
View File

@ -1,34 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#include "../file/asset.h"
#include "../file/csv.h"
/** Column name for the KEY within the CSV */
#define LANGUAGE_HEADER_KEY "Key"
/** Column name for the VALUE within the CSV */
#define LANGUAGE_HEADER_VALUE "Value"
/** Definition for a Language */
typedef struct {
/** The buffer to read the asset from. */
assetbuffer_t *asset;
/** CSV Row for the header */
csvrow_t header;
/** The index in the header row that the key column is in. */
int32_t headerIndexKey;
/** The index in the header row that the value column is in. */
int32_t headerIndexValue;
} language_t;
typedef struct {
language_t *language;
csvrow_t *row;
char *key;
} languagecsvget_t;

26
include/dawn/physics/aabb.h
View File

@ -1,26 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
typedef struct {
float hitX;
float hitY;
float normalX;
float normalY;
} aabbpointhit2d_t;
typedef struct {
float time;
float normalX;
float normalY;
float hitX;
float hitY;
} aabbvectorhit2d_t;

43
include/dawn/poker/bet.h
View File

@ -1,43 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#include "player.h"
/** How many chips each player has by defautl */
#define POKER_BET_PLAYER_CHIPS_DEFAULT 10000
/** The default blind cost for the big blind. */
#define POKER_BET_BLIND_BIG_DEFAULT 600
/** The default blind cost for the small blind. (Defaults half big blind) */
#define POKER_BET_BLIND_SMALL_DEFAULT (POKER_BET_BLIND_BIG_DEFAULT/2)
/**
* The default betting player for the round.
*
* @param poker Pointer to the poker instance.
* @return The Poker round default betting player.
*/
#define POKER_BET_ROUND_PLAYER_DEFAULT(poker) ( \
((poker)->roundSmallBlind + 1) % POKER_PLAYER_COUNT \
)
typedef struct {
/** Blinds */
int32_t blindSmall, blindBig;
/** How big the current bet is for the round. */
int32_t currentBet;
/** For Betting round, which player is currently betting */
uint8_t better;
/** Current pot of chips */
int32_t pot;
} pokerbet_t;

111
include/dawn/poker/card.h
View File

@ -1,111 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
////////////////////////////////////////////////////////////////////////////////
// Cards
////////////////////////////////////////////////////////////////////////////////
// Aces
#define CARD_CLUBS_TWO 0x00
#define CARD_CLUBS_THREE 0x01
#define CARD_CLUBS_FOUR 0x02
#define CARD_CLUBS_FIVE 0x03
#define CARD_CLUBS_SIX 0x04
#define CARD_CLUBS_SEVEN 0x05
#define CARD_CLUBS_EIGHT 0x06
#define CARD_CLUBS_NINE 0x07
#define CARD_CLUBS_TEN 0x08
#define CARD_CLUBS_JACK 0x09
#define CARD_CLUBS_QUEEN 0x0A
#define CARD_CLUBS_KING 0x0B
#define CARD_CLUBS_ACE 0x0C
// Diamonds
#define CARD_DIAMONDS_TWO 0x0D
#define CARD_DIAMONDS_THREE 0x0E
#define CARD_DIAMONDS_FOUR 0x0F
#define CARD_DIAMONDS_FIVE 0x10
#define CARD_DIAMONDS_SIX 0x11
#define CARD_DIAMONDS_SEVEN 0x12
#define CARD_DIAMONDS_EIGHT 0x13
#define CARD_DIAMONDS_NINE 0x14
#define CARD_DIAMONDS_TEN 0x15
#define CARD_DIAMONDS_JACK 0x16
#define CARD_DIAMONDS_QUEEN 0x17
#define CARD_DIAMONDS_KING 0x18
#define CARD_DIAMONDS_ACE 0x19
// Hearts
#define CARD_HEARTS_TWO 0x1A
#define CARD_HEARTS_THREE 0x1B
#define CARD_HEARTS_FOUR 0x1C
#define CARD_HEARTS_FIVE 0x1D
#define CARD_HEARTS_SIX 0x1E
#define CARD_HEARTS_SEVEN 0x1F
#define CARD_HEARTS_EIGHT 0x20
#define CARD_HEARTS_NINE 0x21
#define CARD_HEARTS_TEN 0x22
#define CARD_HEARTS_JACK 0x23
#define CARD_HEARTS_QUEEN 0x24
#define CARD_HEARTS_KING 0x25
#define CARD_HEARTS_ACE 0x26
// Spades
#define CARD_SPADES_TWO 0x27
#define CARD_SPADES_THREE 0x28
#define CARD_SPADES_FOUR 0x29
#define CARD_SPADES_FIVE 0x2A
#define CARD_SPADES_SIX 0x2B
#define CARD_SPADES_SEVEN 0x2C
#define CARD_SPADES_EIGHT 0x2D
#define CARD_SPADES_NINE 0x2E
#define CARD_SPADES_TEN 0x2F
#define CARD_SPADES_JACK 0x30
#define CARD_SPADES_QUEEN 0x31
#define CARD_SPADES_KING 0x32
#define CARD_SPADES_ACE 0x33
////////////////////////////////////////////////////////////////////////////////
// Suits
////////////////////////////////////////////////////////////////////////////////
#define CARD_SUIT_CLUBS 0x00
#define CARD_SUIT_DIAMONDS 0x01
#define CARD_SUIT_HEARTS 0x02
#define CARD_SUIT_SPADES 0x03
////////////////////////////////////////////////////////////////////////////////
// Card numbers
////////////////////////////////////////////////////////////////////////////////
#define CARD_TWO 0x00
#define CARD_THREE 0x01
#define CARD_FOUR 0x02
#define CARD_FIVE 0x03
#define CARD_SIX 0x04
#define CARD_SEVEN 0x05
#define CARD_EIGHT 0x06
#define CARD_NINE 0x07
#define CARD_TEN 0x08
#define CARD_JACK 0x09
#define CARD_QUEEN 0x0A
#define CARD_KING 0x0B
#define CARD_ACE 0x0C
/** Count of cards in each suit */
#define CARD_COUNT_PER_SUIT 13
/** Count of suits */
#define CARD_SUIT_COUNT 4
/** Standard Card Deck Size */
#define CARD_DECK_SIZE 52
/** Type Representing a card's id */
typedef uint8_t card_t;

34
include/dawn/poker/dealer.h
View File

@ -1,34 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#include "card.h"
/** How many cards the dealer can hold in their hand */
#define POKER_DEALER_HAND_SIZE 5
/** How many cards the grave can hold */
#define POKER_DEALER_GRAVE_SIZE CARD_DECK_SIZE
/** Which VN Character index is the dealer */
#define POKER_DEALER_INDEX POKER_PLAYER_HUMAN_INDEX
/** Representation of the dealer state */
typedef struct {
/** Current Card Deck */
card_t deck[CARD_DECK_SIZE];
uint8_t deckSize;
/** Dealer Hand */
card_t cards[POKER_DEALER_HAND_SIZE];
uint8_t cardsFacing;
/** Card grave (where spent cards go when burned */
card_t grave[POKER_DEALER_GRAVE_SIZE];
uint8_t graveSize;
} pokerdealer_t;

57
include/dawn/poker/player.h
View File

@ -1,57 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#include "../util/flags.h"
#include "bet.h"
#include "card.h"
/** How many cards a player can hold in their hand */
#define POKER_PLAYER_HAND 2
/** How many players in a poker game (excludes dealer) */
#define POKER_PLAYER_COUNT 5
////////////////////////////////////////////////////////////////////////////////
// Player States
////////////////////////////////////////////////////////////////////////////////
/** State for whether or not a player has folded */
#define POKER_PLAYER_STATE_FOLDED flagDefine(0)
/** State for whether or not a player is showing their hand */
#define POKER_PLAYER_STATE_SHOWING flagDefine(1)
/** State for whether or not the player is out */
#define POKER_PLAYER_STATE_OUT flagDefine(2)
/** Flag that is reset at the start of each round, and set when move occurs. */
#define POKER_PLAYER_STATE_ROUND_MOVE flagDefine(3)
/** The index that the player who is the human... is */
#define POKER_PLAYER_HUMAN_INDEX 0x02
////////////////////////////////////////////////////////////////////////////////
// Player Definition
////////////////////////////////////////////////////////////////////////////////
/** Poker Player State */
typedef struct {
/** Cards in the players' hand */
card_t cards[POKER_PLAYER_HAND];
uint8_t cardCount;
/** Current State of player */
uint8_t state;
/** Chips in players' posession */
int32_t chips;
/** Current bet in current round player has placed */
int32_t currentBet;
} pokerplayer_t;

55
include/dawn/poker/poker.h
View File

@ -1,55 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#include "bet.h"
#include "dealer.h"
#include "player.h"
#include "card.h"
#include "winner.h"
/** How many cards to deal each player during the deal round */
#define POKER_DEAL_CARD_EACH 2
/** How many cards are dealt for the flop, turn and river */
#define POKER_FLOP_CARD_COUNT 3
#define POKER_TURN_CARD_COUNT 1
#define POKER_RIVER_CARD_COUNT 1
#define POKER_STATE_NULL 0x00
#define POKER_STATE_STARTING_MATCH 0x01
#define POKER_STATE_STARTING_ROUND 0x02
#define POKER_STATE_TAKING_BLINDS 0x03
#define POKER_STATE_DEALING 0x04
#define POKER_STATE_CARDS_FLOPPING 0x05
#define POKER_STATE_BETTING 0x06
#define POKER_STATE_DECIDING_WINNER 0x07
typedef struct {
/** Poker betting state */
pokerbet_t bet;
/** Player States */
pokerdealer_t dealer;
pokerplayer_t players[POKER_PLAYER_COUNT];
/** Winning player states */
pokerwinner_t winner;
/** The current player that is the dealer */
uint8_t roundDealer;
/** Which player is the small blind for this round */
uint8_t roundSmallBlind;
/** Which player is the big blind for this round */
uint8_t roundBigBlind;
uint8_t state;
} poker_t;

26
include/dawn/poker/turn.h
View File

@ -1,26 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#define POKER_TURN_TYPE_OUT 0x00
#define POKER_TURN_TYPE_FOLD 0x01
#define POKER_TURN_TYPE_BET 0x02
#define POKER_TURN_TYPE_CALL 0x03
#define POKER_TURN_TYPE_ALL_IN 0x04
#define POKER_TURN_TYPE_CHECK 0x05
/** The turn that a player/the AI decided to do for its turn */
typedef struct {
/** What type of action the turn is */
uint8_t type;
/** How many chips they did in their turn (if applicable) */
int32_t chips;
/** How confident the AI is about their turn. */
float confidence;
} pokerturn_t;

54
include/dawn/poker/winner.h
View File

@ -1,54 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#include "player.h"
#include "dealer.h"
/** Size of the FULL hand used to calculate a winning. */
#define POKER_WINNING_FULL_SIZE POKER_PLAYER_HAND+POKER_DEALER_HAND_SIZE
/** How many cards make a winning set */
#define POKER_WINNING_SET_SIZE 5
/** Winning Types */
#define POKER_WINNING_TYPE_NULL 0x00
#define POKER_WINNING_TYPE_ROYAL_FLUSH 0x01
#define POKER_WINNING_TYPE_STRAIGHT_FLUSH 0x02
#define POKER_WINNING_TYPE_FOUR_OF_A_KIND 0x03
#define POKER_WINNING_TYPE_FULL_HOUSE 0x04
#define POKER_WINNING_TYPE_FLUSH 0x05
#define POKER_WINNING_TYPE_STRAIGHT 0x06
#define POKER_WINNING_TYPE_THREE_OF_A_KIND 0x07
#define POKER_WINNING_TYPE_TWO_PAIR 0x08
#define POKER_WINNING_TYPE_PAIR 0x09
#define POKER_WINNNIG_TYPE_HIGH_CARD 0x0A
/** Holds information about a player's winning state */
typedef struct {
/** The full set of both the dealer and player's hand */
card_t full[POKER_WINNING_FULL_SIZE];
uint8_t fullSize;
/** Holds the winning set */
card_t set[POKER_WINNING_SET_SIZE];
uint8_t setSize;
/** Winning Type */
uint8_t type;
/** If there was a kicker card it will be here, otherwise -1 for no kicker */
card_t kicker;
} pokerplayerwinning_t;
typedef struct {
/** Winning States */
pokerplayerwinning_t winnings[POKER_PLAYER_COUNT];
uint8_t winners[POKER_PLAYER_COUNT];
uint8_t winnerCount;
} pokerwinner_t;

24
include/dawn/script/scripter.h
View File

@ -1,24 +0,0 @@
// Copyright (c) 2021 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#include "../libs.h"
/** Implies that the arguments the function will take is variable */
#define SCRIPTER_VARIABLE_ARGUMENT_COUNT DUK_VARARGS
/** Global context defintion of the pointer referring back to the scripter */
#define SCRIPTER_SELF_NAME "__scripter"
/** Type forwarders */
typedef duk_context scriptercontext_t;
typedef duk_ret_t scripterreturn_t;
typedef struct {
duk_context *context;
engine_t *engine;
void *user;
} scripter_t;
typedef scripterreturn_t scriptermethod_t(scriptercontext_t *context);

20
include/dawn/ui/align.h
View File

@ -1,20 +0,0 @@
// Copyright (c) 2021 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "../libs.h"
#define ALIGN_POS_CENTER flagDefine(0)
#define ALIGN_POS_START flagDefine(1)
#define ALIGN_POS_END flagDefine(2)
#define ALIGN_SIZE_FILL flagDefine(3)
#define ALIGN_SIZE_ORIGINAL flagDefine(4)
#define ALIGN_SIZE_RATIO flagDefine(5)
typedef struct {
float x, y;
float width, height;
} align_t;

30
include/dawn/ui/breakpoint.h
View File

@ -1,30 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
/** Maximum breakpoints that the list can support. */
#define BREAKPOINT_COUNT_MAX 0x04
/** Callback for when a new breakpint is reached. */
typedef void breakpointcallback_t(void *user, uint8_t i, float breakpoint);
typedef struct {
/** List of breakpoints */
float breakpoints[BREAKPOINT_COUNT_MAX];
uint8_t breakpointCount;
/** Which breakpoint is current */
uint8_t breakpointCurrent;
/** Pointer to any custom user data. */
void *user;
/** Callback for when a breakpoint is reached */
breakpointcallback_t *onBreakpoint;
} breakpointlist_t;

23
include/dawn/ui/frame.h
View File

@ -1,23 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#include "../display/primitive.h"
#include "../display/font.h"
/** Size of the border (in pixels) on each edge */
#define FRAME_BORDER_SIZE 16
/** Total border size for a given frame on each axis */
#define FRAME_BORDER_SIZE_FULL FRAME_BORDER_SIZE * 2
/** How many quads are within the frame */
#define FRAME_PRIMITIVE_COUNT 9
typedef struct {
texture_t *texture;
primitive_t primitive;
} frame_t;

17
include/dawn/ui/framedtextmenu.h
View File

@ -1,17 +0,0 @@
// Copyright (c) 2021 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "../libs.h"
#include "frame.h"
#include "textmenu.h"
/** The default gutter for the grid of a framed text menu */
#define FRAMED_TEXT_MENU_GUTTER_DEFAULT 8.0f
typedef struct {
frame_t frame;
textmenu_t menu;
} framedtextmenu_t;

40
include/dawn/ui/grid.h
View File

@ -1,40 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
/** Maximum number of columns a grid can have */
#define GRID_COLUMN_COUNT_MAX 16
/** Maximum number of rows a grid can have */
#define GRID_ROW_COUNT_MAX GRID_COLUMN_COUNT_MAX
/** Cell size for "auto", basically to fill the remaining space evenly */
#define GRID_CEL_SIZE_AUTO -1
/** Definitio of a grid */
typedef struct {
/** Count of columns/rows in the grid */
uint8_t columns, rows;
/** Cell Definitions, used to control how the cells will size themselves */
float columnDefinitions[GRID_COLUMN_COUNT_MAX];
float rowDefinitions[GRID_COLUMN_COUNT_MAX];
/** Settings to control gutters (space between cells) and border (of grid) */
float gutterX, gutterY;
float borderX, borderY;
/** Calculated sizes and positions for each cell */
float columnSizes[GRID_COLUMN_COUNT_MAX];
float columnPositions[GRID_COLUMN_COUNT_MAX];
float rowSizes[GRID_ROW_COUNT_MAX];
float rowPositions[GRID_COLUMN_COUNT_MAX];
/** Cached size of the grid */
float width, height;
} grid_t;

16
include/dawn/ui/image.h
View File

@ -1,16 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#include "../display/primitive.h"
typedef struct {
texture_t *texture;
primitive_t quad;
float width, height;
} image_t;

20
include/dawn/ui/label.h
View File

@ -1,20 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#include "../display/primitive.h"
#include "../display/font.h"
/** Representation of a Label UI Element */
typedef struct {
font_t *font;
float fontSize;
float maxWidth;
fonttextinfo_t info;
primitive_t primitive;
} label_t;

33
include/dawn/ui/menu.h
View File

@ -1,33 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
/** The maximum number of items a menu can hold */
#define MENU_ITEMS_MAX 32
/** Callback for when menu events are fired. */
typedef void menucallback_t(void *user, uint8_t i);
typedef struct {
uint8_t x;
uint8_t y;
uint8_t width;
uint8_t height;
} menuitem_t;
typedef struct {
menuitem_t items[MENU_ITEMS_MAX];
uint8_t itemCount;
uint8_t selected;
uint8_t cursorX;
uint8_t cursorY;
void *user;
menucallback_t *onSelect;
} menu_t;

16
include/dawn/ui/rectangle.h
View File

@ -1,16 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#include "../display/primitive.h"
typedef struct {
float width, height;
texture_t texture;
primitive_t quad;
} rectangle_t;

31
include/dawn/ui/textmenu.h
View File

@ -1,31 +0,0 @@
// Copyright (c) 2021 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "../libs.h"
#include "../display/font.h"
#include "menu.h"
#include "grid.h"
#include "label.h"
#include "rectangle.h"
/** Colour of the selection box for the text menu */
#define TEXTMENU_SELECTION_COLOR ((pixel_t){.r=0xFF,.g=0xFF,.b=0xFF,.a=0x64})
/** Callback type for when an item is selected */
typedef void textmenucallback_t(void *user, uint8_t i, char *text);
typedef struct {
menu_t menu;
grid_t grid;
font_t *font;
rectangle_t rectangle;
char *texts[MENU_ITEMS_MAX];
label_t labels[MENU_ITEMS_MAX];
textmenucallback_t *onSelect;
void *user;
} textmenu_t;

18
include/dawn/util/array.h
View File

@ -1,18 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
/**
* Definition of a callback that is used to sort an array.
*
* @param left The left element in the array.
* @param right The right element in the array.
* @return -1 for Left priority, 1 for Right and 0 for Equal.
*/
typedef int32_t arraysort_t(const void*, const void*);

24
include/dawn/util/dynarray.h
View File

@ -1,24 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
/** Custom Array Definition */
typedef struct {
/** The data storage */
void *data;
/** Size of each element within the array */
size_t size;
/** The count of elements currently in the array */
int32_t length;
/** Total count of elements the array can hold */
int32_t total;
} dynarray_t;

31
include/dawn/util/list.h
View File

@ -1,31 +0,0 @@
// Copyright (c) 2021 Dominic Masters
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
#pragma once
#include "../libs.h"
/**
* Entry within a given linked list.
* @param data* The pointer to the data that is within the entry.
* @param prev* Pointer to the previous entry in the list.
* @param next* Pointer to the next entry in the list.
*/
typedef struct listentry_t {
void *data;
struct listentry_t *prev;
struct listentry_t *next;
} listentry_t;
/**
* Linked List of elements, Doubly Linked.
* @param size The count of elements currently within the list
* @param start* First element within the list.
* @param end* Last element within the list.
*/
typedef struct {
uint32_t size;
listentry_t *start;
listentry_t *end;
} list_t;

33
include/dawn/util/string.h
View File

@ -1,33 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#define STRING_HANDLEBAR_KEY_MAXLENGTH 32
#define STRING_STACK_STRING_SIZE 256
#define STRING_STACK_STRING_COUNT 128
#define STRING_STACK_BUFFER STRING_STACK_STRING_SIZE * STRING_STACK_STRING_COUNT
/** Representation of a String Handlebar Variable */
typedef struct {
/** The key to use to replace in the source */
char *key;
/** The value to replace it with */
char *value;
} stringhandlebarvariable_t;
/** Definition of a string stack to push and pop strings from. */
typedef struct {
/** Raw char buffer, for holding strings */
char buffer[STRING_STACK_BUFFER];
/** Strings themselves */
char *strings[STRING_STACK_STRING_COUNT];
/** How many strings are on the stack */
int32_t size;
} stringstack_t;

127
include/dawn/vn/vncharacter.h
View File

@ -1,127 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#include "../display/texture.h"
#include "../display/primitive.h"
#include "../display/tileset.h"
#define VN_CHARACTER_BLINK_TIME_RANGE_MAX 6
#define VN_CHARACTER_SIZE 0.5
/** How many quads the VN Character has. Base, Eyes, Mouth and Eyebrows */
#define VN_CHARACTER_QUAD_COUNT 4
/** The Quads */
#define VN_CHARACTER_QUAD_BASE 0
#define VN_CHARACTER_QUAD_EYEBROWS 1
#define VN_CHARACTER_QUAD_EYES 2
#define VN_CHARACTER_QUAD_MOUTH 3
/** How many frames does each mouth set have */
#define VN_CHARACTER_TALKING_FRAME_COUNT 3
#define VN_CHARACTER_EMOTION_BORED 0x00
#define VN_CHARACTER_EMOTION_BORED_SMILING 0x01
#define VN_CHARACTER_EMOTION_BORED_DISAGREE 0x02
#define VN_CHARACTER_EMOTION_BORED_AGREE 0x03
#define VN_CHARACTER_EMOTION_SHORT 0x04
#define VN_CHARACTER_EMOTION_SMUG_SLIGHT 0x05
#define VN_CHARACTER_EMOTION_BORED_ANNOYED 0x06
#define VN_CHARACTER_EMOTION_BORED_PROUD 0x07
#define VN_CHARACTER_EMOTION_BORED_THINKING 0x08
#define VN_CHARACTER_EMOTION_HAPPY_THINKING 0x09
#define VN_CHARACTER_EMOTION_SERIOUS_THINKING 0x0A
#define VN_CHARACTER_EMOTION_SMUG_THINKING_SLIGHT 0x0B
#define VN_CHARACTER_EMOTION_XXXX_THINKING 0x0C// "concerned thinking"
#define VN_CHARACTER_EMOTION_HAPPY_FAKE_THINKING 0x0D
#define VN_CHARACTER_EMOTION_XXXX_THINKING2 0x0E// "serious concerned thinking"
#define VN_CHARACTER_EMOTION_XXXX_THINKING3 0x0F // "Happy pleased thinking"
#define VN_CHARACTER_EMOTION_BORED_LISTENING 0x10
#define VN_CHARACTER_EMOTION_HUMBLED 0x11
#define VN_CHARACTER_EMOTION_CONCERNED_1 0x12
#define VN_CHARACTER_EMOTION_PROUD 0x13
#define VN_CHARACTER_EMOTION_DEADPAN 0x14
#define VN_CHARACTER_EMOTION_SMIRK 0x15
#define VN_CHARACTER_EMOTION_CONCERNED_2 0x16
#define VN_CHARACTER_EMOTION_TEASING 0x17
#define VN_CHARACTER_EMOTION_XXXX_THINKING4 0x18// "concerned thinking lightly"
#define VN_CHARACTER_EMOTION_XXXX_THINKING5 0x19// "daydreaming"
#define VN_CHARACTER_EMOTION_XXXX_THINKING6 0x1A// "concerned thinking heavy"
#define VN_CHARACTER_EMOTION_XXXX_THINKING7 0x1B// "pleasant daydreaming"
#define VN_CHARACTER_EMOTION_XXXX_THINKING8 0x1C// not really sure
#define VN_CHARACTER_EMOTION_ANIME_MOM 0x1D
#define VN_CHARACTER_EMOTION_XXXX_THINKING9 0x1E// not really sure
#define VN_CHARACTER_EMOTION_ANIME_MOM_SMUG 0x1F
#define VN_CHARACTER_EMOTION_CURIOUS 0x20
#define VN_CHARACTER_EMOTION_HAPPY 0x21
#define VN_CHARACTER_EMOTION_CONCERNED_WORRIED 0x22
#define VN_CHARACTER_EMOTION_HAPPY_PROUD_SLIGHT 0x23
#define VN_CHARACTER_EMOTION_NOT_BELIEVING 0x24//"Mhm, suuure"
#define VN_CHARACTER_EMOTION_HAPPY_TIRED 0x25
#define VN_CHARACTER_EMOTION_CONCERNED_SLIGHT 0x26
#define VN_CHARACTER_EMOTION_HAPPY_PROUD 0x27
#define VN_CHARACTER_EMOTION_XXXX_THINKING10 0x28// sort of tsundere
#define VN_CHARACTER_EMOTION_XXXX_THINKING11 0x29// "thinking of something nice"
#define VN_CHARACTER_EMOTION_XXXX_THINKING12 0x2A// big sister vibes
#define VN_CHARACTER_EMOTION_XXXX_THINKING13 0x2B// "vibin"
#define VN_CHARACTER_EMOTION_XXXX_THINKING14 0x2C// not really sure
#define VN_CHARACTER_EMOTION_XXXX_THINKING15 0x2D// not really sure
#define VN_CHARACTER_EMOTION_XXXX_THINKING16 0x2E// not really sure
#define VN_CHARACTER_EMOTION_XXXX_THINKING17 0x2F// not really sure
#define VN_CHARACTER_EMOTION_CONCERNED 0x30
#define VN_CHARACTER_EMOTION_RELIEVED 0x31
#define VN_CHARACTER_EMOTION_CONCERNED_VERY 0x32
#define VN_CHARACTER_EMOTION_RELIEVED_SMUG 0x33//"slightly smug"
#define VN_CHARACTER_EMOTION_CONCERNED_3 0x34// "slightly worried"
#define VN_CHARACTER_EMOTION_CONCERNED_4 0x35// "slightly smug"
#define VN_CHARACTER_DISAPPOINTED 0x36// "slightly worried"
#define VN_CHARACTER_EMOTION_CONCERNED_5 0x37// "slightly smugger"
#define VN_CHARACTER_EMOTION_CONCERNED_THINKING 0x38
#define VN_CHARACTER_EMOTION_SMUG_1 0x39
#define VN_CHARACTER_EMOTION_CONCERNED_THINKING_DEEP 0x3A
#define VN_CHARACTER_EMOTION_SMUG_2 0x3B
#define VN_CHARACTER_EMOTION_XXXX_THINKING18 0x3C// not really sure
#define VN_CHARACTER_EMOTION_XXXX_THINKING19 0x3D// not really sure
#define VN_CHARACTER_EMOTION_XXXX_THINKING20 0x3E// not really sure
#define VN_CHARACTER_EMOTION_XXXX_THINKING21 0x3F// not really sure
#define VN_CHARACTER_EMOTION_SERIOUS 0x40
#define VN_CHARACTER_EMOTION_READY 0x41
#define VN_CHARACTER_EMOTION_SERIOUS_ANGRY 0x42
#define VN_CHARACTER_EMOTION_SMUG 0x43
#define VN_CHARACTER_EMOTION_ANGRY 0x44
#define VN_CHARACTER_EMOTION_ANGRY_PROUD 0x45
#define VN_CHARACTER_EMOTION_ANGRY_VERY 0x46
#define VN_CHARACTER_EMOTION_SMUG_VERY 0x47
#define VN_CHARACTER_EMOTION_SERIOUS_THINKING_VERY 0x48
#define VN_CHARACTER_EMOTION_SMUG_THINKING 0x49
#define VN_CHARACTER_EMOTION_ANGRY_THINKING 0x4A
#define VN_CHARACTER_EMOTION_SMUG_THINKING_VERY 0x4B
#define VN_CHARACTER_EMOTION_XXXX_THINKING22 0x4C// not really sure
#define VN_CHARACTER_EMOTION_HAPPY_FAKE_THINKING_ANGRY 0x4D
#define VN_CHARACTER_EMOTION_XXXX_THINKING23 0x4E// not really sure
#define VN_CHARACTER_EMOTION_BOASTFUL 0x4F
typedef struct {
float x, y, z;
float yaw, pitch, roll;
float scaleX, scaleY;
bool talking;
float blinkStart;
uint8_t emotion;
primitive_t primitive;
texture_t *texture;
int32_t baseWidth, baseHeight;
int32_t faceX, faceY;
int32_t faceWidth, faceHeight;
} vncharacter_t;

40
include/dawn/vn/vnconversation.h
View File

@ -1,40 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#include "../display/animation/queue.h"
#include "vncharacter.h"
#include "vntextbox.h"
typedef struct _vnconversation_t vnconversation_t;
typedef struct {
/** Pointer to the original conversation */
vnconversation_t *conversation;
/** Storage for pointer to text for text conversation elements */
char *text;
/** Character this conversation piece belongs to */
vncharacter_t *character;
/** Character's emotion */
uint8_t emotion;
} vnconversationitemdata_t;
/** Representation of a conversation, laid out similarly to a timeline. */
typedef struct _vnconversation_t {
/** Internal Textbox for text elements */
vntextbox_t textbox;
/** Data Storage for items' data */
vnconversationitemdata_t itemData[ANIMATION_QUEUE_ITEM_MAX];
/** Internal Queue for queueing the conversation */
queue_t actionQueue;
} vnconversation_t;

34
include/dawn/vn/vnscene.h
View File

@ -1,34 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#include "vncharacter.h"
#include "vnconversation.h"
#include "vntextbox.h"
/** Maximum number of Visual Novel Characters the scene can support */
#define VN_SCENE_CHARACTERS_MAX 6
typedef struct {
float cameraX;
float cameraY;
float cameraZ;
float cameraLookX;
float cameraLookY;
float cameraLookZ;
/** Camera used for rendering, updated frequently */
camera_t camera;
/** Internal conversation element */
vnconversation_t conversation;
/** Character array */
vncharacter_t characters[VN_SCENE_CHARACTERS_MAX];
uint8_t characterCount;
} vnscene_t;

53
include/dawn/vn/vntextbox.h
View File

@ -1,53 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "../libs.h"
#include "../display/animation/timeline.h"
#include "../display/font.h"
#include "../ui/frame.h"
#include "../util/flags.h"
/** Amount of characters scrolled, per second */
#define VN_TEXTBOX_SCROLL_SPEED 60
#define VN_TEXTBOX_FONT_SIZE FONT_SIZE_DEFAULT
#define VN_TEXTBOX_STATE_CLOSED flagDefine(0)
typedef struct {
/** Stores the maximum width that this textbox can take up */
float widthMax;
/** Font that the text box uses */
font_t *font;
/** Box State Flags */
uint8_t state;
/** How many rows of text at most can be displayed in a single text box */
int32_t linesMax;
int32_t lineCurrent;
/** Readonly values for the dimensions of the textbox */
float width, height;
/** Animation of the textbox */
float textScroll;
/** Information about the current rendered text */
fonttextinfo_t textInfo;
/** Primitive to hold talking text */
primitive_t primitive;
/** The frame for the textbox */
frame_t frame;
/** Current spoken text, tracked in-case of re-render */
char *text;
} vntextbox_t;

3
platform/glfw/glwfwplatform.h
View File

@ -4,8 +4,7 @@
// https://opensource.org/licenses/MIT
#pragma once
#include <dawn/dawn.h>
#include "../../src/libs.h"
#include "../../src/display/render.h"
#include "../../src/game/game.h"
#include "../../src/input/input.h"

3
src/display/animation/animation.h
View File

@ -5,7 +5,8 @@
* https://opensource.org/licenses/MIT
*/
#include <dawn/dawn.h>
#pragma once
#include "../../libs.h"
/**
* Animation tool for converting 0-1 space into a 0-0.5 back to zero space. This

0
include/dawn/display/animation/easing.h → src/display/animation/easing.h
View File

52
src/display/animation/queue.h
View File

@ -6,8 +6,58 @@
*/
#pragma once
#include <dawn/dawn.h>
#include "../../libs.h"
#include "../../util/array.h"
#include "../../engine/engine.h"
#define ANIMATION_QUEUE_ITEM_MAX 128
#define ANIMATION_QUEUE_START 0xFF
typedef struct _queueaction_t queueaction_t;
typedef struct _queue_t queue_t;
/**
* Callback for queue events.
* @param conversation Conversation this text is attached to.
* @param text Text item that is being used in the callback
* @param i Index of the item in the queue.
*/
typedef void queuecallback_t(queue_t *queue, queueaction_t *action, uint8_t i);
typedef struct _queueaction_t {
/** Index that the action is within the queue */
uint8_t index;
/** Pointer to any custom user data */
void *data;
/** Callback to fire the moment the action is active in the queue */
queuecallback_t *onStart;
/** Callback to fire when this action has ended */
queuecallback_t *onEnd;
/** Callback to fire every update of this queue while action is active. */
queuecallback_t *onUpdate;
} queueaction_t;
typedef struct _queue_t {
/** Array of items within the queue. */
queueaction_t items[ANIMATION_QUEUE_ITEM_MAX];
uint8_t count;
/** Current index within the array of actions that is currently processing */
uint8_t current;
/** Internal timeline tracking */
float timeline;
/** Time that the current aciton started */
float actionStarted;
/** Delay Queue Item Storage */
float delays[ANIMATION_QUEUE_ITEM_MAX];
} queue_t;
/**
* Initialize the queue set.

72
src/display/animation/timeline.h
View File

@ -4,7 +4,77 @@
// https://opensource.org/licenses/MIT
#pragma once
#include <dawn/dawn.h>
#include "../../libs.h"
/** Maximum number of actions a timeline can support, smaller than 0xFF */
#define TIMELINE_ACTION_COUNT_MAX 128
/** Type forwarders */
typedef struct _timeline_t timeline_t;
typedef struct _timelineaction_t timelineaction_t;
/**
* Callback for when a timeline event occurs
* @param timeline The timeline that fired this callback.
* @param action The action that this callback is attached to.
* @param i The index that this action is within the timeline.
*/
typedef void timelinecallback_t(timeline_t *timeline, timelineaction_t *action,
uint8_t i
);
typedef struct _timelineaction_t {
/** Pointer to any custom user data the timeline action wants to use. */
void *data;
/**
* The time that this action should occur within the timeline
* set to 0 or less to start immediately.
*/
float start;
/**
* The duration of the action, this will decide for how long onDuration will
* be called for, and when onEnd should be called.
* Set to a negative number to have this continue forever.
* Set to 0 to only fire the onStart.
* onStart can fire with either onDuration and onEnd on the same frame, but
* onEnd and onDuration cannot fire the same frame.
*/
float duration;
/**
* Enables animation looping. This works by forcing start to be equal to the
* current time at the point in time that onEnd is called. This will also stop
* onStart being called so ensure that your onStart and onEnd logic works.
*/
bool loop;
timelinecallback_t *onStart;
timelinecallback_t *onDuration;
timelinecallback_t *onEnd;
} timelineaction_t;
typedef struct _timeline_t {
/** The current time as far as the timeline is concerned */
float current;
/** The time of the last "frame" as far as the timeline is concerned */
float previous;
/** The frame time diff, essentially current = previous + diff */
float diff;
/** User pointer, allows you to point to some other data */
void *user;
/** Actions within the timeline */
timelineaction_t actions[TIMELINE_ACTION_COUNT_MAX];
uint8_t actionCount;
} timeline_t;
/**
* Initializes a timeline back to its default state.

20
src/display/bitmapfont.h
View File

@ -6,8 +6,26 @@
*/
#pragma once
#include <dawn/dawn.h>
#include "../libs.h"
#include "spritebatch.h"
#include "tileset.h"
/** Which is the first character within the font tilemap */
#define BITMAP_FONT_CHAR_START 33
/** Center a font along the X axis */
#define BITMAP_FONT_CENTER_X 9876543
/** Center a font along the Y axis */
#define BITMAP_FONT_CENTER_Y -BITMAP_FONT_CENTER_X
/** Align right edge of font to origin */
#define BITMAP_FONT_RIGHT_X (BITMAP_FONT_CENTER_X-1)
typedef struct {
float width, height;
int32_t lines;
} bitmapfontmeasure_t;
/**
* Get the division for a given character.

12
src/display/camera.h
View File

@ -4,9 +4,19 @@
// https://opensource.org/licenses/MIT
#pragma once
#include <dawn/dawn.h>
#include "../libs.h"
#include "../util/math.h"
#include "matrix.h"
/** The math for the camera is stored here. */
typedef struct {
/** View Matrix (Where the camera looks) */
matrix_t view;
/** Projection Matrix (How the camera looks) */
matrix_t projection;
} camera_t;
/**
* Make a camera look at a position in world space while itself being positioned
* within world space.

75
src/display/font.h
View File

@ -6,13 +6,84 @@
*/
#pragma once
#include <dawn/dawn.h>
#include "../libs.h"
#include "texture.h"
#include "primitive.h"
#include "primitives/quad.h"
#include "../util/mem.h"
/** Which character (ASCII) to start the font from */
#define FONT_FIRST_CHAR 32
/** How many characters (after the first char) to generate */
#define FONT_NUM_CHARS 96
/** Width of the loaded font texture */
#define FONT_TEXTURE_WIDTH 1024
/** Height of the loaded font texture */
#define FONT_TEXTURE_HEIGHT FONT_TEXTURE_WIDTH
/** Refer to STBTT docs for OpenGL Fill Mode v d3d Fill Modes */
#define FONT_FILL_MODE 1
/** Passed to STBTT for scaling the font, essentially the font resolution */
#define FONT_TEXTURE_SIZE 64.0f
/** The global scale, just used to provide fine control of font sizes */
#define FONT_GLOBAL_SCALE 0.5f;
/** Default Font Size (on which all font scales are based) */
#define FONT_SIZE_DEFAULT 16.0f
// Chars
#define FONT_NEWLINE '\n'
#define FONT_SPACE ' '
// Heights
#define FONT_LINE_HEIGHT FONT_TEXTURE_SIZE * 0.75f
#define FONT_INITIAL_LINE FONT_LINE_HEIGHT * 0.75f
#define FONT_SPACE_SIZE FONT_TEXTURE_SIZE * 0.45f
/** Maximum number of characters a font text info can hold. */
#define FONT_TEXT_INFO_CHARS_MAX 1024
/** Maximum number of newlines that a font text info can hold. */
#define FONT_TEXT_INFO_LINES_MAX FONT_TEXT_INFO_CHARS_MAX/50
/** Representation of a font that can be used to render text */
typedef struct {
texture_t texture;
stbtt_bakedchar characterData[FONT_NUM_CHARS];
} font_t;
typedef struct {
/** What (real character) index the line starts at */
int32_t start;
/** How many (real) characters the line is in length */
int32_t length;
} fonttextinfoline_t;
typedef struct {
/** How many raw chars are in the string */
int32_t length;
/** How many real characters (non whitespace) are in the string */
int32_t realLength;
/** How many lines is the string? Trailing newlines will count */
int32_t lineCount;
/** The real character info for each line */
fonttextinfoline_t lines[FONT_TEXT_INFO_LINES_MAX];
/** Dimensions of the string */
float width, height;
/** Array of precalculated quads */
stbtt_aligned_quad quads[FONT_TEXT_INFO_CHARS_MAX];
} fonttextinfo_t;
/**
* Initializes Font from raw TTF data.
* @param font Font to initialize

9
src/display/framebuffer.h
View File

@ -6,8 +6,15 @@
*/
#pragma once
#include <dawn/dawn.h>
#include "../libs.h"
#include "texture.h"
#include "render.h"
typedef struct {
GLuint fboId;
GLuint rboId;
texture_t texture;
} framebuffer_t;
/**
* Initializes frame buffer that can be rendered to.

11
src/display/matrix.h
View File

@ -6,7 +6,16 @@
*/
#pragma once
#include <dawn/dawn.h>
#include "../libs.h"
/**
* Representation for a matrix. Used as a highlevel wrapper for the math
* functions that sit underneath this API.
*/
typedef struct {
/** Internal Matrix API */
mat4 internalMatrix;
} matrix_t;
/**
* Makes matrix identity.

29
src/display/primitive.h
View File

@ -6,7 +6,34 @@
*/
#pragma once
#include <dawn/dawn.h>
#include "../libs.h"
#define PRIMITIVE_POSITIONS_PER_VERTICE 3
#define PRIMITIVE_COORDINATES_PER_VERTICE 2
/** Structure containing information about a primitive */
typedef struct {
/** How many vertices are in the primitive */
int32_t verticeCount;
/** How many indices are in the primitive */
int32_t indiceCount;
/** Pointer to the vertex buffer on the GPU */
GLuint vertexBuffer;
/** Pointer to the index buffer on the GPU */
GLuint indexBuffer;
} primitive_t;
/** Structure containing vertice position information */
typedef struct {
/** Coordinates */
float x, y, z;
/** Texture UVs */
float u, v;
} vertice_t;
/** Indice that references a specific vertice */
typedef unsigned int indice_t;
/**
* Creates a new primitive.

3
src/display/primitives/cube.h
View File

@ -4,13 +4,12 @@
// https://opensource.org/licenses/MIT
#pragma once
#include <dawn/dawn.h>
#include "../../libs.h"
#include "../primitive.h"
#define CUBE_VERTICE_COUNT 8
#define CUBE_INDICE_COUNT 36
/**
* Buffer the vertices and indices of a cube onto a primitive.
* @param primitive Primitive to buffer to.

2
src/display/primitives/quad.h
View File

@ -4,7 +4,7 @@
// https://opensource.org/licenses/MIT
#pragma once
#include <dawn/dawn.h>
#include "../../libs.h"
#include "../primitive.h"
#define QUAD_VERTICE_COUNT 4

3
src/display/primitives/skywall.h
View File

@ -4,7 +4,8 @@
// https://opensource.org/licenses/MIT
#pragma once
#include <dawn/dawn.h>
#include "../../libs.h"
#include "../../util/math.h"
#include "../primitive.h"
/** How many slices in each cylinder. */

11
src/display/render.h
View File

@ -4,9 +4,18 @@
// https://opensource.org/licenses/MIT
#pragma once
#include <dawn/dawn.h>
#include "../libs.h"
#include "framebuffer.h"
/**
* Contains information about the current render state, can be used for querying
* how the renderer is currently set up.
*/
typedef struct {
/** Resolution (in pixels). Floats to allow subpixels in future. */
float width, height;
} render_t;
/**
* Initialize the renderer.
*/

23
src/display/renderlist.h
View File

@ -6,7 +6,7 @@
*/
#pragma once
#include <dawn/dawn.h>
#include "../libs.h"
#include "../game/game.h"
#include "framebuffer.h"
#include "primitive.h"
@ -15,6 +15,27 @@
#include "primitives/quad.h"
#include "../util/dynarray.h"
typedef struct {
framebuffer_t frame;
shader_t *shader;
} renderpass_t;
typedef struct {
framebuffer_t frame;
primitive_t quad;
dynarray_t passes;
void *user;
} renderlist_t;
typedef void renderitemcallback_t(
renderlist_t *list, renderpass_t *pass, engine_t *engine, int32_t i
);
typedef struct {
renderitemcallback_t *onRender;
} renderitem_t;
void renderListInit(renderlist_t *list, int32_t passes, int32_t width, int32_t height);
renderpass_t * renderListGetPass(renderlist_t *list, int32_t pass);
int32_t renderPassAdd(renderlist_t *list);

39
src/display/scene.h
View File

@ -6,9 +6,46 @@
*/
#pragma once
#include <dawn/dawn.h>
#include "../libs.h"
#include "camera.h"
#include "shader.h"
#include "../engine/engine.h"
/** Maximum number of items a scene can support */
#define SCENE_ITEMS_MAX 32
typedef struct _scene_t scene_t;
typedef struct _sceneitem_t sceneitem_t;
/**
* Callback for when scene events occur.
*
* @param scene The scene that is being evented.
* @param i The index of the current scene item.
* @param engine The game's engine.
*/
typedef void sceneitemcallback_t(
scene_t *scene, int32_t i, engine_t *engine
);
typedef struct _sceneitem_t {
sceneitemcallback_t *onUpdate;
sceneitemcallback_t *onRender;
sceneitemcallback_t *onDispose;
} sceneitem_t;
typedef struct _scene_t {
/** Camera that is used to render the scene */
camera_t camera;
/** Any custom user data pointer */
void *user;
/** Items within the scene */
sceneitem_t items[SCENE_ITEMS_MAX];
int32_t itemCount;
} scene_t;
void sceneInit(scene_t *scene);

43
src/display/shader.h
View File

@ -6,8 +6,49 @@
*/
#pragma once
#include <dawn/dawn.h>
#include "../libs.h"
#include "matrix.h"
#include "camera.h"
#include "texture.h"
#define SHADER_UNI_VIEW "u_View"
#define SHADER_UNI_PROJ "u_Proj"
#define SHADER_UNI_TEXT "u_Text"
#define SHADER_UNI_MODL "u_Modl"
#define SHADER_UNI_COLR "u_Colr"
/** Representation of a shader uniform */
typedef GLuint shaderuniform_t;
/**
* Structure containing information about an OpenGL Shader. For simplicity sake
* we demand certain uninforms to be present on the shader target.
*/
typedef struct {
/** Pointer to an uploaded vertex shader program */
shaderuniform_t shaderVertex;
/** Pointer to an uploaded fragment shader program */
shaderuniform_t shaderFrag;
/** Pointer to an uploaded shader program linked */
shaderuniform_t shaderProgram;
/** Matrix for the view matrix */
shaderuniform_t uniView;
/** Matrix for the projection matrix */
shaderuniform_t uniProj;
/** Uniform for the current texture */
shaderuniform_t uniText;
/** Uniform for the current model world position */
shaderuniform_t uniModl;
/** Uniform for the color multiplier */
shaderuniform_t uniColr;
} shader_t;
/**
* Compiles a shader from vertex and fragment shader code.

14
src/display/spritebatch.h
View File

@ -4,10 +4,22 @@
// https://opensource.org/licenses/MIT
#pragma once
#include <dawn/dawn.h>
#include "../libs.h"
#include "primitive.h"
#include "primitives/quad.h"
/** Definition of a Sprite Batch. */
typedef struct {
/** Maximum sprites the batch can hold. */
int32_t maxSprites;
/** The current/next sprite index. */
int32_t currentSprite;
/** Internal primitive */
primitive_t primitive;
} spritebatch_t;
/**
* Creates a new Sprite Batch made of standard quads.
*

29
src/display/texture.h
View File

@ -4,7 +4,34 @@
// https://opensource.org/licenses/MIT
#pragma once
#include <dawn/dawn.h>
#include "../libs.h"
/**
* Structure detailing information about a texture.
* Because we plan to upload the pixels of a texture into the GPU, we don't
* store the pixels in memory because we don't need to!
*/
typedef struct {
/** Width (in pixels) of the texture */
int32_t width;
/** Height (in pixels) of the texture */
int32_t height;
/** Texture ID on the GPU */
GLuint id;
} texture_t;
/** Information about a single pixel. */
typedef struct {
/** RGBA Color values */
uint8_t r, g, b, a;
} pixel_t;
#define PIXEL_COLOR_WHITE ((pixel_t){ .r = 255, .g = 255, .b = 255, .a = 255 })
#define PIXEL_COLOR_RED ((pixel_t){ .r = 255, .g = 0, .b = 0, .a = 255 })
#define PIXEL_COLOR_GREEN ((pixel_t){ .r = 0, .g = 255, .b = 0, .a = 255 })
#define PIXEL_COLOR_BLUE ((pixel_t){ .r = 0, .g = 0, .b = 255, .a = 255 })
#define PIXEL_COLOR_BLACK ((pixel_t){ .r = 0, .g = 0, .b = 0, .a = 255 })
#define PIXEL_COLOR_TRANSPARENT ((pixel_t){ .r = 0, .g = 0, .b = 0, .a = 0 })
/**
* Initializes a texture that can be written in to.

22
src/display/tileset.h
View File

@ -4,7 +4,27 @@
// https://opensource.org/licenses/MIT
#pragma once
#include <dawn/dawn.h>
#include "../libs.h"
/** Division of a texture */
typedef struct {
float x0, y0, x1, y1;
} tilesetdiv_t;
/** Definition of a Tileset */
typedef struct {
/** Count of X/Y divisions */
int32_t columns, rows;
/** Size of each divison (in pixels) */
float divX, divY;
/** Count of divisions (unused) */
int32_t count;
/** Division information */
tilesetdiv_t *divisions;
} tileset_t;
/**
* Create a tileset. Tilesets will be pre-divided to save performance later.

14
src/engine/engine.h
View File

@ -6,11 +6,23 @@
*/
#pragma once
#include <dawn/dawn.h>
#include "../libs.h"
#include "../game/game.h"
#include "../input/input.h"
#include "../epoch/epoch.h"
#include "../display/render.h"
typedef struct {
/** Time Manager for the game */
epoch_t time;
/** Render Manager for the game */
render_t render;
/** Input Manager for the game */
input_t input;
} engine_t;
/**
* Initializes the provided engine. This will initialize all of the various
* managers for the game to use.

35
src/epoch/epoch.h
View File

@ -6,7 +6,40 @@
*/
#pragma once
#include <dawn/dawn.h>
#include "../libs.h"
#define EPOCH_FIXED_STEP 0.016f
#define EPOCH_SMALLEST_STEP 0.001f
typedef struct {
/**
* Current time (as a float of seconds since game start).
*
* When time is initialized this will start at a fixed value of 2/60ths of a
* second, regardless of what engine the game is running.
*
* This is to avoid any divide by zero errors.
*/
float current;
/**
* Last Time (as a float of seconds since the game start).
*
* This value will start at 1/60th of a second regardless of engine the game
* is running on to avoid divide by zero errors.
*/
float last;
/**
* Varying timestep that occured since the last frame.
*/
float delta;
/**
* Fixed timestep that is not affected by framerate but remains consistent.
*/
float fixedDelta;
} epoch_t;
/**
* Initializes the epoch time tracking.

6
src/file/asset.h
View File

@ -6,12 +6,16 @@
*/
#pragma once
#include <dawn/dawn.h>
#include "../libs.h"
#include "../display/shader.h"
#include "../display/texture.h"
#include "../display/font.h"
#include "../script/scripter.h"
#include "xml.h"
/** Definition of an asset ready to be buffered */
typedef FILE assetbuffer_t;
/**
* Method to load an asset into memory as a raw string.
* @param assetName Path leading to the asset within the root asset directory.

84
src/file/csv.h
View File

@ -6,10 +6,92 @@
*/
#pragma once
#include <dawn/dawn.h>
#include "../libs.h"
#include "asset.h"
#include "../util/array.h"
/** Maximum characters that a cell can support */
#define CSV_BUFFER_SIZE 32
/** Maximum characters in any given cell */
#define CSV_CELL_SIZE_MAX 1024
/** Maximum number of columns/cells in a given row */
#define CSV_ROW_COLUMNS_MAX 16
/** Count of characters maximum that a row can support */
#define CSV_ROW_CHARACTERS_MAX CSV_CELL_SIZE_MAX * CSV_ROW_COLUMNS_MAX
/** Result of a CSV buffer operation. */
typedef struct {
/** How many rows within the CSV */
int32_t rowCount;
/** Count of columns in the CSV, this is the longest row in the CSV. */
int32_t columnCount;
/** How many cells within the CSV */
int32_t cellCount;
} csvbufferresult_t;
/** Callback to receive data for each cell in a CSV being buffered */
typedef bool csvbuffercallback_t(
assetbuffer_t *asset, void *user, int32_t row, int32_t column, char *data
);
/** Representation of a CSV Row's complete data. */
typedef struct {
/** Characters within the row */
char data[CSV_ROW_CHARACTERS_MAX];
/** Pointer to the start of each string within the row */
char *columns[CSV_ROW_COLUMNS_MAX];
/** How many columns within the row */
int32_t columnCount;
} csvrow_t;
/** Callback to receive buffer data for a CSV row */
typedef bool csvbufferrowcallback_t(
assetbuffer_t *asset, void *user, int32_t row, csvrow_t *csv
);
/** Callback to receive buffer data for a CSV row, but includes CSV headers. */
typedef bool csvbufferrowwitheaderscallback_t(
assetbuffer_t *asset, void *user, int32_t row,
csvrow_t *header, csvrow_t *current
);
/** Data used by the cell callback for when the row buffering is progressing */
typedef struct {
/** Which row the current buffer is on */
int32_t row;
/** Information about the current row being parsed */
csvrow_t rowCurrent;
/** Pointer to custom user data */
void *user;
/** Pointer to custom user callback */
csvbufferrowcallback_t *callback;
} csvbufferrowdata_t;
/** Data used by the row callback for when the header row is parsed */
typedef struct {
/** Information about the header row */
csvrow_t headerRow;
/** Pointer to custom user data */
void *user;
/** Pointer to custom user callback */
csvbufferrowwitheaderscallback_t *callback;
} csvbufferrowwithheadersdata_t;
/** Data used while searching a CSV */
typedef struct {
/** Row to store the data in */
csvrow_t *row;
/** Row's index */
int32_t rowIndex;
/** Column to check */
int32_t column;
/** Value to check row */
char *value;
} csvsearchdata_t;
/**
* Buffer each cell within a CSV Asset Buffer with a callback.
*

31
src/file/xml.h
View File

@ -6,7 +6,36 @@
*/
#pragma once
#include <dawn/dawn.h>
#include "../libs.h"
#define XML_DOING_NOTHING 0x00
#define XML_PARSING_TAG_NAME 0x01
#define XML_LOOKING_FOR_ATTRIBUTE 0x02
#define XML_PARSING_ATTRIBUTE_NAME 0x03
#define XML_LOOKING_FOR_ATTRIBUTE_VALUE 0x04
#define XML_PARSING_ATTRIBUTE_VALUE 0x05
#define XML_PARSING_VALUE 0x06
#define XML_PARSING_CHILD 0x07
#define XML_PARSING_CLOSE 0x08
#define XML_TEXT_BUFFER_MAX 256
#define XML_CHILD_COUNT_MAX 16
#define XML_ATTRIBUTE_MAX 16
typedef struct _xml_t xml_t;
typedef struct _xml_t {
char *node;
char *value;
char *attributeNames[XML_ATTRIBUTE_MAX];
char *attributeDatas[XML_ATTRIBUTE_MAX];
uint8_t attributeCount;
xml_t *children;
uint8_t childrenCount;
} xml_t;
/**
* Load an XML child from a string buffer.

7
src/game/dawn/dawngame.h
View File

@ -6,7 +6,12 @@
*/
#pragma once
#include <dawn/dawn.h>
#include "../../libs.h"
#include "../game.h"
typedef struct {
int32_t INeedSomePropertyToStopCompilerComplaining;
} dawngame_t;
/**
* Initializes the Dawn Game instance.

16
src/game/game.h
View File

@ -4,7 +4,7 @@
// https://opensource.org/licenses/MIT
#pragma once
#include <dawn/dawn.h>
#include "../libs.h"
#include "../engine/engine.h"
#include "../locale/language.h"
@ -16,6 +16,20 @@
#include "sandbox/sandboxscene.h"
#endif
/** Describes the current game */
typedef struct {
/** Engine for the game */
engine_t engine;
#if SETTING_GAME == SETTING_GAME_POKER
pokergame_t pokerGame;
#elif SETTING_GAME == SETTING_GAME_DAWN
dawngame_t dawnGame;
#elif SETTING_GAME == SETTING_GAME_SANDBOX
sandboxscene_t sandboxScene;
#endif
} game_t;
/**
* Initialize the game context.
*

3
src/game/poker/actions/action.h
View File

@ -6,8 +6,9 @@
*/
#pragma once
#include <dawn/dawn.h>
#include "../../../libs.h"
#include "../../../display/animation/queue.h"
#include "../pokergame.h"
/**
* Adds an action to the poker game scene's queue.

2
src/game/poker/actions/bet.h
View File

@ -6,7 +6,7 @@
*/
#pragma once
#include <dawn/dawn.h>
#include "../../../libs.h"
#include "action.h"
#include "restack.h"
#include "../../../poker/turn.h"

2
src/game/poker/actions/look.h
View File

@ -6,7 +6,7 @@
*/
#pragma once
#include <dawn/dawn.h>
#include "../../../libs.h"
#include "action.h"
#include "../../../display/animation/queue.h"
#include "../pokerworld.h"

2
src/game/poker/actions/restack.h
View File

@ -6,7 +6,7 @@
*/
#pragma once
#include <dawn/dawn.h>
#include "../../../libs.h"
#include "action.h"
#include "../../../display/animation/queue.h"
#include "../pokergame.h"

2
src/game/poker/actions/round.h
View File

@ -4,7 +4,7 @@
// https://opensource.org/licenses/MIT
#pragma once
#include <dawn/dawn.h>
#include "../../../libs.h"
#include "action.h"
#include "../../../poker/bet.h"
#include "../../../poker/actions/round.h"

2
src/game/poker/actions/start.h
View File

@ -6,7 +6,7 @@
*/
#pragma once
#include <dawn/dawn.h>
#include "../../../libs.h"
#include "../../../vn/conversation/talk.h"
#include "../../../display/animation/queue.h"
#include "../../../poker/actions/match.h"

26
src/game/poker/discussion/pokerdiscussion.h
View File

@ -1,26 +0,0 @@
/**
* Copyright (c) 2021 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include <dawn/dawn.h>
#include "../../../vn/conversation/vnconversation.h"
#include "../../../vn/conversation/talk.h"
#include "../actions/look.h"
/**
* Retreives the discussion based on some discussion data.
* @param disc The discussion data to buffer into.
* @param data The discussion data.
*/
void pokerDiscussionGet(pokerdiscussion_t *disc, pokerdiscussiondata_t *data);
/**
* Queue a discussion data result onto the conversation stack.
*
* @param data The discussion data.
*/
void pokerDiscussionQueue(pokerdiscussiondata_t *data);

0
src/game/poker/discussion/pokerdiscussion.c → src/game/poker/pokerdiscussion.c
View File

18
include/dawn/game/poker/pokerdiscussion.h → src/game/poker/pokerdiscussion.h
View File

@ -7,7 +7,9 @@
#pragma once
#include "../../libs.h"
#include "pokergame.h"
#include "../../vn/conversation/vnconversation.h"
#include "../../vn/conversation/talk.h"
#include "actions/look.h"
/** Maximum number of messages that the discussion buffer can hold */
#define POKER_DISCUSSION_MESSAGE_COUNT_MAX 32
@ -37,3 +39,17 @@ typedef struct {
uint8_t emotions[POKER_DISCUSSION_MESSAGE_COUNT_MAX];
uint8_t count;
} pokerdiscussion_t;
/**
* Retreives the discussion based on some discussion data.
* @param disc The discussion data to buffer into.
* @param data The discussion data.
*/
void pokerDiscussionGet(pokerdiscussion_t *disc, pokerdiscussiondata_t *data);
/**
* Queue a discussion data result onto the conversation stack.
*
* @param data The discussion data.
*/
void pokerDiscussionQueue(pokerdiscussiondata_t *data);

47
src/game/poker/pokergame.h
View File

@ -6,7 +6,7 @@
*/
#pragma once
#include <dawn/dawn.h>
#include "../../libs.h"
#include "pokergameassets.h"
#include "../../poker/poker.h"
#include "../../vn/conversation/talk.h"
@ -17,6 +17,51 @@
#include "pokerworld.h"
#include "actions/start.h"
#define POKER_GAME_SEAT_COUNT 8
#define POKER_GAME_SEAT_FOR_PLAYER(p) (p - (POKER_PLAYER_COUNT/2))
#define POKER_GAME_SEAT_DEALER POKER_GAME_SEAT_FOR_PLAYER(POKER_DEALER_INDEX)
/**
* Return the seat for a given player index, also works for the dealer index.
* @param i The players index.
* @return The players seat number.
*/
#define pokerGameSeatFromIndex(i) (\
i == POKER_DEALER_INDEX ? \
POKER_GAME_SEAT_DEALER : \
POKER_GAME_SEAT_FOR_PLAYER(i) \
)
#define POKER_GAME_PENNY_BASE_WIDTH 1000
#define POKER_GAME_PENNY_BASE_HEIGHT 1920
#define POKER_GAME_PENNY_FACE_X 367
#define POKER_GAME_PENNY_FACE_Y 256
#define POKER_GAME_PENNY_FACE_WIDTH 280
#define POKER_GAME_PENNY_FACE_HEIGHT 280
typedef struct {
/** Poker Game State */
poker_t poker;
/** Visual Novel Engine */
vnscene_t scene;
/** Assets (Files) for the game. */
pokergameassets_t assets;
/** Poker Game World. */
pokerworld_t world;
/** UI For the Game */
pokerui_t ui;
/** Data for the actions */
pokergameactiondata_t actionData[ANIMATION_QUEUE_ITEM_MAX];
/** Pointer back to the game engine */
engine_t *engine;
} pokergame_t;
/**
* Initializes the game state for the poker game.
*

3
include/dawn/game/poker/pokergameaction.h → src/game/poker/pokergameaction.h
View File

@ -6,8 +6,7 @@
*/
#pragma once
#include "../../libs.h"
#include <dawn/dawn.h>
typedef struct {
uint8_t lookAtPlayer;

14
src/game/poker/pokergameassets.h
View File

@ -6,11 +6,23 @@
*/
#pragma once
#include <dawn/dawn.h>
#include "../../libs.h"
#include "../../file/asset.h"
#include "../../locale/language.h"
#include "../../display/texture.h"
typedef struct {
font_t font;
shader_t shader;
language_t language;
texture_t testTexture;
texture_t roomTexture;
texture_t cardTexture;
texture_t pennyTexture;
} pokergameassets_t;
/**
* Load and initializes all the assets used by the poker game.
*

17
src/game/poker/pokerworld.h
View File

@ -6,13 +6,28 @@
*/
#pragma once
#include <dawn/dawn.h>
#include "../../libs.h"
#include "../../display/shader.h"
#include "../../display/primitive.h"
#include "../../display/primitives/skywall.h"
#include "../../vn/vnscene.h"
#include "../../vn/vncharacter.h"
#define POKER_WORLD_SEAT_DISTANCE -1
#define POKER_WORLD_SEAT_ROTATION(n) (n * mathDeg2Rad(45.0f))
#define POKER_WORLD_SEAT_POSITION_X(n) ( \
POKER_WORLD_SEAT_DISTANCE * (float)sin(POKER_WORLD_SEAT_ROTATION(n)) \
)
#define POKER_WORLD_SEAT_POSITION_Y -0.2f
#define POKER_WORLD_SEAT_POSITION_Z(n) ( \
POKER_WORLD_SEAT_DISTANCE * (float)cos(POKER_WORLD_SEAT_ROTATION(n)) \
)
typedef struct {
primitive_t skywall;
} pokerworld_t;
/**
* Initialize the poker renderer.
*

Some files were not shown because too many files have changed in this diff Show More