2019-10-03 18:04:14 -04:00
|
|
|
/**
|
|
|
|
@file main.c
|
|
|
|
|
|
|
|
Main source file of the game that puts together all the pieces. main game
|
|
|
|
logic is implemented here.
|
|
|
|
|
|
|
|
by Miloslav Ciz (drummyfish), 2019
|
|
|
|
|
|
|
|
Released under CC0 1.0 (https://creativecommons.org/publicdomain/zero/1.0/)
|
|
|
|
plus a waiver of all other intellectual property. The goal of this work is
|
|
|
|
be and remain completely in the public domain forever, available for any use
|
|
|
|
whatsoever.
|
|
|
|
*/
|
|
|
|
|
2019-09-25 09:51:19 -04:00
|
|
|
#include <stdint.h>
|
|
|
|
|
2019-10-02 08:42:30 -04:00
|
|
|
/*
|
|
|
|
The following keys are mandatory to be implemented on any platform in order
|
|
|
|
for the game to be playable.
|
|
|
|
*/
|
2019-09-25 09:51:19 -04:00
|
|
|
#define SFG_KEY_UP 0
|
|
|
|
#define SFG_KEY_RIGHT 1
|
|
|
|
#define SFG_KEY_DOWN 2
|
|
|
|
#define SFG_KEY_LEFT 3
|
|
|
|
#define SFG_KEY_A 4
|
|
|
|
#define SFG_KEY_B 5
|
|
|
|
#define SFG_KEY_C 6
|
2019-10-02 08:42:30 -04:00
|
|
|
/*
|
|
|
|
The following keys are optional for a platform to implement. They just make
|
|
|
|
the controls more comfortable.
|
|
|
|
*/
|
|
|
|
#define SFG_KEY_JUMP 7
|
|
|
|
#define SFG_KEY_STRAFE_LEFT 8
|
|
|
|
#define SFG_KEY_STRAFE_RIGHT 9
|
2019-09-25 09:51:19 -04:00
|
|
|
|
|
|
|
/* ============================= PORTING =================================== */
|
|
|
|
|
2019-09-27 06:46:44 -04:00
|
|
|
/* When porting, do the following:
|
|
|
|
- implement the following functions in your platform_*.h.
|
|
|
|
- Call SFG_init() from your platform initialization code.
|
|
|
|
- Call SFG_mainLoopBody() from within your platform's main loop.
|
|
|
|
- include "settings.h" in your platform_*.h and optionally hard-override
|
|
|
|
(redefine) some settings in platform_*.h, according to the platform's
|
|
|
|
needs.
|
|
|
|
*/
|
2019-09-25 09:51:19 -04:00
|
|
|
|
2019-09-29 07:50:40 -04:00
|
|
|
#define SFG_LOG(str) ; ///< Can be redefined to log messages for better debug.
|
|
|
|
|
2019-10-02 14:31:27 -04:00
|
|
|
#define SFG_PROGRAM_MEMORY static const /**< Can be redefined to platform's
|
|
|
|
specifier of program meory. */
|
|
|
|
|
2019-10-02 08:42:30 -04:00
|
|
|
/** Return 1 (0) if given key is pressed (not pressed). At least the mandatory
|
|
|
|
keys have to be implemented, the optional keys don't have to ever return 1.
|
|
|
|
See the key contant definitions to see which ones are mandatory. */
|
2019-09-25 09:51:19 -04:00
|
|
|
int8_t SFG_keyPressed(uint8_t key);
|
|
|
|
|
|
|
|
/** Return time in ms sice program start. */
|
|
|
|
uint32_t SFG_getTimeMs();
|
|
|
|
|
|
|
|
/** Sleep (yield CPU) for specified amount of ms. This is used to relieve CPU
|
|
|
|
usage. If your platform doesn't need this or handles it in other way, this
|
|
|
|
function can do nothing. */
|
|
|
|
void SFG_sleepMs(uint16_t timeMs);
|
|
|
|
|
|
|
|
/** Set specified screen pixel. The function doesn't have to check whether
|
|
|
|
the coordinates are within screen. */
|
|
|
|
static inline void SFG_setPixel(uint16_t x, uint16_t y, uint8_t colorIndex);
|
|
|
|
|
|
|
|
/* ========================================================================= */
|
|
|
|
|
|
|
|
/**
|
|
|
|
Game main loop body, call this inside the platform's specific main loop.
|
|
|
|
*/
|
|
|
|
void SFG_mainLoopBody();
|
|
|
|
|
|
|
|
/**
|
|
|
|
Initializes the whole program, call this in the platform initialization.
|
|
|
|
*/
|
|
|
|
void SFG_init();
|
|
|
|
|
2019-09-27 10:38:55 -04:00
|
|
|
#ifdef SFG_PLATFORM_POKITTO
|
|
|
|
#include "platform_pokitto.h"
|
|
|
|
#else
|
|
|
|
#include "platform_sdl.h"
|
|
|
|
#endif
|
2019-09-25 09:51:19 -04:00
|
|
|
|
2019-10-02 14:31:27 -04:00
|
|
|
#include "constants.h"
|
|
|
|
#include "levels.h"
|
|
|
|
#include "assets.h"
|
|
|
|
#include "palette.h"
|
2019-10-04 15:09:10 -04:00
|
|
|
#include "settings.h" // will include if not included by platform
|
|
|
|
|
|
|
|
#define RCL_PIXEL_FUNCTION SFG_pixelFunc
|
|
|
|
#define RCL_TEXTURE_VERTICAL_STRETCH 0
|
|
|
|
|
|
|
|
#define RCL_CAMERA_COLL_HEIGHT_BELOW 800
|
|
|
|
#define RCL_CAMERA_COLL_HEIGHT_ABOVE 100
|
|
|
|
|
|
|
|
#include "raycastlib.h"
|
2019-10-02 14:31:27 -04:00
|
|
|
|
2019-10-04 10:32:24 -04:00
|
|
|
#define SFG_GAME_RESOLUTION_X \
|
|
|
|
(SFG_SCREEN_RESOLUTION_X / SFG_RESOLUTION_SCALEDOWN)
|
|
|
|
|
|
|
|
#define SFG_GAME_RESOLUTION_Y \
|
|
|
|
(SFG_SCREEN_RESOLUTION_Y / SFG_RESOLUTION_SCALEDOWN)
|
|
|
|
|
2019-09-25 09:51:19 -04:00
|
|
|
#define SFG_MS_PER_FRAME (1000 / SFG_FPS) // ms per frame with target FPS
|
|
|
|
|
2019-10-04 15:09:10 -04:00
|
|
|
#if SFG_MS_PER_FRAME == 0
|
|
|
|
#define SFG_MS_PER_FRAME 1
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define SFG_PLAYER_TURN_UNITS_PER_FRAME \
|
2019-09-27 10:38:55 -04:00
|
|
|
((SFG_PLAYER_TURN_SPEED * RCL_UNITS_PER_SQUARE) / (360 * SFG_FPS))
|
|
|
|
|
2019-10-04 15:09:10 -04:00
|
|
|
#if SFG_PLAYER_TURN_UNITS_PER_FRAME == 0
|
|
|
|
#define SFG_PLAYER_TURN_UNITS_PER_FRAME 1
|
|
|
|
#endif
|
2019-09-27 10:38:55 -04:00
|
|
|
|
2019-10-04 15:09:10 -04:00
|
|
|
#define SFG_PLAYER_MOVE_UNITS_PER_FRAME \
|
|
|
|
((SFG_PLAYER_MOVE_SPEED * RCL_UNITS_PER_SQUARE) / SFG_FPS)
|
2019-10-01 14:25:21 -04:00
|
|
|
|
2019-10-04 15:09:10 -04:00
|
|
|
#if SFG_PLAYER_MOVE_UNITS_PER_FRAME == 0
|
|
|
|
#define SFG_PLAYER_MOVE_UNITS_PER_FRAME 1
|
|
|
|
#endif
|
2019-09-25 09:51:19 -04:00
|
|
|
|
2019-10-04 15:09:10 -04:00
|
|
|
#define SFG_GRAVITY_SPEED_INCREASE_PER_FRAME \
|
|
|
|
((SFG_GRAVITY_ACCELERATION * RCL_UNITS_PER_SQUARE) / (SFG_FPS * SFG_FPS))
|
2019-10-01 14:25:21 -04:00
|
|
|
|
2019-10-04 15:09:10 -04:00
|
|
|
#if SFG_GRAVITY_SPEED_INCREASE_PER_FRAME == 0
|
|
|
|
#define SFG_GRAVITY_SPEED_INCREASE_PER_FRAME 1
|
|
|
|
#endif
|
2019-09-25 09:51:19 -04:00
|
|
|
|
2019-09-26 21:34:49 -04:00
|
|
|
/**
|
|
|
|
Step in which walls get higher, in raycastlib units.
|
|
|
|
*/
|
|
|
|
#define SFG_WALL_HEIGHT_STEP (RCL_UNITS_PER_SQUARE / 4)
|
|
|
|
|
2019-09-30 13:39:21 -04:00
|
|
|
#define SFG_CEILING_MAX_HEIGHT\
|
|
|
|
(16 * RCL_UNITS_PER_SQUARE - RCL_UNITS_PER_SQUARE / 2 )
|
|
|
|
|
2019-10-04 10:32:24 -04:00
|
|
|
int8_t SFG_backgroundScaleMap[SFG_GAME_RESOLUTION_Y];
|
2019-09-25 19:34:57 -04:00
|
|
|
uint16_t SFG_backgroundScroll;
|
|
|
|
|
2019-10-01 14:25:21 -04:00
|
|
|
struct
|
|
|
|
{
|
|
|
|
RCL_Camera camera;
|
2019-10-04 11:42:54 -04:00
|
|
|
int8_t squarePosition[2];
|
2019-10-01 14:25:21 -04:00
|
|
|
RCL_Vector2D direction;
|
|
|
|
RCL_Unit verticalSpeed;
|
2019-10-03 14:09:00 -04:00
|
|
|
RCL_Unit previousVerticalSpeed; /**< Vertical speed in previous frame, needed
|
|
|
|
for determining whether player is in the
|
|
|
|
air. */
|
2019-10-01 14:25:21 -04:00
|
|
|
} SFG_player;
|
|
|
|
|
2019-10-04 10:32:24 -04:00
|
|
|
|
|
|
|
#if SFG_RESOLUTION_SCALEDOWN == 1
|
|
|
|
#define SFG_setGamePixel SFG_setPixel
|
|
|
|
#else
|
|
|
|
/**
|
|
|
|
Sets the game pixel (a pixel that can potentially be bigger than the screen
|
|
|
|
pixel).
|
|
|
|
*/
|
|
|
|
static inline void SFG_setGamePixel(uint16_t x, uint16_t y, uint8_t colorIndex)
|
|
|
|
{
|
|
|
|
uint16_t screenY = y * SFG_RESOLUTION_SCALEDOWN;
|
|
|
|
uint16_t screenX = x * SFG_RESOLUTION_SCALEDOWN;
|
|
|
|
|
|
|
|
for (uint16_t j = screenY; j < screenY + SFG_RESOLUTION_SCALEDOWN; ++j)
|
|
|
|
for (uint16_t i = screenX; i < screenX + SFG_RESOLUTION_SCALEDOWN; ++i)
|
|
|
|
SFG_setPixel(i,j,colorIndex);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2019-10-01 14:25:21 -04:00
|
|
|
void SFG_recompurePLayerDirection()
|
|
|
|
{
|
|
|
|
SFG_player.camera.direction = RCL_wrap(SFG_player.camera.direction,RCL_UNITS_PER_SQUARE);
|
|
|
|
|
|
|
|
SFG_player.direction = RCL_angleToDirection(SFG_player.camera.direction);
|
|
|
|
|
|
|
|
SFG_player.direction.x = (SFG_player.direction.x * SFG_PLAYER_MOVE_UNITS_PER_FRAME) / RCL_UNITS_PER_SQUARE;
|
|
|
|
SFG_player.direction.y = (SFG_player.direction.y * SFG_PLAYER_MOVE_UNITS_PER_FRAME) / RCL_UNITS_PER_SQUARE;
|
|
|
|
|
|
|
|
SFG_backgroundScroll =
|
2019-10-04 10:32:24 -04:00
|
|
|
((SFG_player.camera.direction * 8) * SFG_GAME_RESOLUTION_Y) / RCL_UNITS_PER_SQUARE;
|
2019-10-01 14:25:21 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void SFG_initPlayer()
|
|
|
|
{
|
|
|
|
RCL_initCamera(&SFG_player.camera);
|
|
|
|
|
2019-10-04 10:32:24 -04:00
|
|
|
SFG_player.camera.resolution.x = SFG_GAME_RESOLUTION_X / SFG_RAYCASTING_SUBSAMPLE;
|
|
|
|
SFG_player.camera.resolution.y = SFG_GAME_RESOLUTION_Y;
|
2019-10-01 14:25:21 -04:00
|
|
|
SFG_player.camera.height = RCL_UNITS_PER_SQUARE * 12;
|
|
|
|
SFG_player.camera.position.x = RCL_UNITS_PER_SQUARE * 15;
|
|
|
|
SFG_player.camera.position.y = RCL_UNITS_PER_SQUARE * 8;
|
|
|
|
|
|
|
|
SFG_recompurePLayerDirection();
|
|
|
|
SFG_player.verticalSpeed = 0;
|
2019-10-03 14:09:00 -04:00
|
|
|
SFG_player.previousVerticalSpeed = 0;
|
2019-10-01 14:25:21 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
RCL_RayConstraints SFG_rayConstraints;
|
|
|
|
|
2019-10-02 14:31:27 -04:00
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
uint8_t coords[2];
|
|
|
|
uint8_t state; /**< door state in format:
|
|
|
|
|
2019-10-04 11:18:46 -04:00
|
|
|
MSB ccbaaaaa LSB
|
2019-10-02 14:31:27 -04:00
|
|
|
|
|
|
|
aaaaa: current door height (how much they're open)
|
|
|
|
b: whether currently going up (0) or down (1)
|
|
|
|
cc: by which keys the door is unlocked
|
|
|
|
*/
|
2019-10-04 11:18:46 -04:00
|
|
|
} SFG_DoorRecord;
|
2019-10-02 14:31:27 -04:00
|
|
|
|
2019-10-04 11:42:54 -04:00
|
|
|
#define SFG_DOOR_DEFAULT_STATE 0x1f
|
2019-10-04 15:09:10 -04:00
|
|
|
#define SFG_DOOR_UP_DOWN_MASK 0x20
|
|
|
|
#define SFG_DOOR_VERTICAL_POSITION_MASK 0x1f
|
|
|
|
#define SFG_DOOR_HEIGHT_STEP (RCL_UNITS_PER_SQUARE / 0x1f)
|
|
|
|
#define SFG_DOOR_INCREMENT_PER_FRAME \
|
|
|
|
(SFG_DOOR_OPEN_SPEED / (SFG_DOOR_HEIGHT_STEP * SFG_FPS))
|
|
|
|
|
|
|
|
#if SFG_DOOR_INCREMENT_PER_FRAME == 0
|
|
|
|
#define SFG_DOOR_INCREMENT_PER_FRAME 1
|
|
|
|
#endif
|
2019-10-04 11:42:54 -04:00
|
|
|
|
2019-10-02 14:31:27 -04:00
|
|
|
#define SFG_MAX_DOORS 32
|
|
|
|
|
2019-09-26 15:15:07 -04:00
|
|
|
/**
|
|
|
|
Stores the current level and helper precomputed vaues for better performance.
|
|
|
|
*/
|
|
|
|
struct
|
|
|
|
{
|
|
|
|
const SFG_Level *levelPointer;
|
|
|
|
const uint8_t* textures[7];
|
2019-09-26 21:34:49 -04:00
|
|
|
uint32_t timeStart;
|
2019-10-04 11:42:54 -04:00
|
|
|
uint32_t frameStart;
|
2019-09-29 14:26:53 -04:00
|
|
|
uint8_t floorColor;
|
|
|
|
uint8_t ceilingColor;
|
2019-10-04 11:18:46 -04:00
|
|
|
SFG_DoorRecord doors[SFG_MAX_DOORS];
|
2019-10-02 14:31:27 -04:00
|
|
|
uint8_t doorRecordCount;
|
2019-10-04 11:42:54 -04:00
|
|
|
uint8_t checkedDoorIndex; ///< Says which door are currently being checked.
|
2019-09-26 15:15:07 -04:00
|
|
|
} SFG_currentLevel;
|
|
|
|
|
2019-10-03 17:37:52 -04:00
|
|
|
#if SFG_DITHERED_SHADOW
|
|
|
|
SFG_PROGRAM_MEMORY uint8_t SFG_ditheringPatterns[] =
|
|
|
|
{
|
|
|
|
0,0,0,0,
|
|
|
|
0,0,0,0,
|
|
|
|
|
|
|
|
0,0,0,0,
|
|
|
|
0,1,0,0,
|
|
|
|
|
|
|
|
0,0,0,0,
|
|
|
|
0,1,0,1,
|
|
|
|
|
|
|
|
1,0,1,0,
|
|
|
|
0,1,0,0,
|
|
|
|
|
|
|
|
1,0,1,0,
|
|
|
|
0,1,0,1,
|
|
|
|
|
|
|
|
1,0,1,0,
|
|
|
|
0,1,1,1,
|
|
|
|
|
|
|
|
1,1,1,1,
|
|
|
|
0,1,0,1,
|
|
|
|
|
|
|
|
1,1,1,1,
|
|
|
|
0,1,1,1,
|
|
|
|
|
|
|
|
1,1,1,1,
|
|
|
|
1,1,1,1
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2019-09-25 09:51:19 -04:00
|
|
|
void SFG_pixelFunc(RCL_PixelInfo *pixel)
|
|
|
|
{
|
|
|
|
uint8_t color;
|
|
|
|
uint8_t shadow = 0;
|
|
|
|
|
2019-09-29 10:08:38 -04:00
|
|
|
if (pixel->isHorizon && pixel->depth > RCL_UNITS_PER_SQUARE * 16)
|
|
|
|
{
|
|
|
|
color = SFG_TRANSPARENT_COLOR;
|
|
|
|
}
|
|
|
|
else if (pixel->isWall)
|
2019-09-25 09:51:19 -04:00
|
|
|
{
|
2019-09-26 15:15:07 -04:00
|
|
|
uint8_t textureIndex =
|
|
|
|
pixel->isFloor ?
|
2019-09-27 13:04:49 -04:00
|
|
|
(
|
|
|
|
((pixel->hit.type & SFG_TILE_PROPERTY_MASK) != SFG_TILE_PROPERTY_DOOR) ?
|
|
|
|
(pixel->hit.type & 0x7)
|
|
|
|
:
|
|
|
|
(
|
2019-09-28 15:12:16 -04:00
|
|
|
(pixel->texCoords.y > RCL_UNITS_PER_SQUARE) ?
|
2019-09-29 10:08:38 -04:00
|
|
|
(pixel->hit.type & 0x7) : 255
|
2019-09-27 13:04:49 -04:00
|
|
|
)
|
|
|
|
):
|
2019-09-26 15:15:07 -04:00
|
|
|
((pixel->hit.type & 0x38) >> 3);
|
2019-09-29 14:17:31 -04:00
|
|
|
|
2019-09-27 20:08:28 -04:00
|
|
|
RCL_Unit textureV = pixel->texCoords.y;
|
2019-09-26 22:41:45 -04:00
|
|
|
|
2019-09-27 13:04:49 -04:00
|
|
|
if ((pixel->hit.type & SFG_TILE_PROPERTY_MASK) ==
|
|
|
|
SFG_TILE_PROPERTY_SQUEEZER)
|
2019-09-27 09:24:36 -04:00
|
|
|
textureV += pixel->wallHeight;
|
2019-09-26 22:41:45 -04:00
|
|
|
|
2019-09-25 19:34:57 -04:00
|
|
|
color =
|
2019-09-26 15:15:07 -04:00
|
|
|
textureIndex != SFG_TILE_TEXTURE_TRANSPARENT ?
|
2019-09-26 22:12:12 -04:00
|
|
|
(SFG_getTexel(
|
2019-09-28 15:12:16 -04:00
|
|
|
textureIndex != 255 ?
|
|
|
|
SFG_currentLevel.textures[textureIndex]:
|
2019-09-29 03:50:58 -04:00
|
|
|
SFG_texturesWall[SFG_currentLevel.levelPointer->doorTextureIndex],
|
2019-09-26 22:12:12 -04:00
|
|
|
pixel->texCoords.x / 32,
|
2019-09-26 22:41:45 -04:00
|
|
|
textureV / 32)
|
2019-09-26 22:12:12 -04:00
|
|
|
) :
|
2019-09-25 19:34:57 -04:00
|
|
|
SFG_TRANSPARENT_COLOR;
|
|
|
|
|
2019-09-25 09:51:19 -04:00
|
|
|
shadow = pixel->hit.direction >> 1;
|
2019-09-28 15:12:16 -04:00
|
|
|
|
2019-09-25 09:51:19 -04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2019-09-29 14:26:53 -04:00
|
|
|
color = pixel->isFloor ?
|
2019-09-30 13:39:21 -04:00
|
|
|
(SFG_currentLevel.floorColor) :
|
|
|
|
(pixel->height < SFG_CEILING_MAX_HEIGHT ?
|
|
|
|
SFG_currentLevel.ceilingColor : SFG_TRANSPARENT_COLOR);
|
2019-09-25 09:51:19 -04:00
|
|
|
}
|
|
|
|
|
2019-09-25 19:34:57 -04:00
|
|
|
if (color != SFG_TRANSPARENT_COLOR)
|
|
|
|
{
|
2019-09-26 19:25:22 -04:00
|
|
|
#if SFG_DITHERED_SHADOW
|
2019-10-03 17:37:52 -04:00
|
|
|
uint8_t fogShadow = (pixel->depth * 4) / (RCL_UNITS_PER_SQUARE);
|
|
|
|
|
|
|
|
uint8_t fogShadowPart = fogShadow & 0x07;
|
2019-09-26 19:25:22 -04:00
|
|
|
|
2019-10-03 17:37:52 -04:00
|
|
|
fogShadow /= 8;
|
2019-09-26 19:25:22 -04:00
|
|
|
|
2019-10-03 17:37:52 -04:00
|
|
|
uint8_t xMod4 = pixel->position.x & 0x03;
|
|
|
|
uint8_t yMod2 = pixel->position.y & 0x01;
|
2019-09-26 19:25:22 -04:00
|
|
|
|
2019-10-03 17:37:52 -04:00
|
|
|
shadow +=
|
|
|
|
fogShadow + SFG_ditheringPatterns[fogShadowPart * 8 + yMod2 * 4 + xMod4];
|
2019-09-26 19:25:22 -04:00
|
|
|
#else
|
2019-09-25 19:34:57 -04:00
|
|
|
shadow += pixel->depth / (RCL_UNITS_PER_SQUARE * 2);
|
2019-09-26 19:25:22 -04:00
|
|
|
#endif
|
|
|
|
|
2019-10-04 16:40:41 -04:00
|
|
|
#if SFG_ENABLE_FOG
|
2019-09-25 19:34:57 -04:00
|
|
|
color = palette_minusValue(color,shadow);
|
2019-10-04 16:40:41 -04:00
|
|
|
#endif
|
2019-09-25 19:34:57 -04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
color = SFG_getTexel(SFG_backgrounds[0],
|
2019-10-04 10:32:24 -04:00
|
|
|
SFG_backgroundScaleMap[(pixel->position.x * SFG_RAYCASTING_SUBSAMPLE + SFG_backgroundScroll) % SFG_GAME_RESOLUTION_Y],
|
2019-09-28 15:42:02 -04:00
|
|
|
// ^ TODO: get rid of mod?
|
2019-09-25 19:34:57 -04:00
|
|
|
SFG_backgroundScaleMap[pixel->position.y]);
|
|
|
|
}
|
2019-09-25 09:51:19 -04:00
|
|
|
|
2019-09-28 15:42:02 -04:00
|
|
|
RCL_Unit screenX = pixel->position.x * SFG_RAYCASTING_SUBSAMPLE;
|
|
|
|
|
|
|
|
for (uint8_t i = 0; i < SFG_RAYCASTING_SUBSAMPLE; ++i)
|
|
|
|
{
|
2019-10-04 10:32:24 -04:00
|
|
|
SFG_setGamePixel(screenX,pixel->position.y,color);
|
2019-09-28 15:42:02 -04:00
|
|
|
screenX++;
|
|
|
|
}
|
2019-09-25 09:51:19 -04:00
|
|
|
}
|
|
|
|
|
2019-10-04 10:32:24 -04:00
|
|
|
#define SFG_MAX_SPRITE_SIZE SFG_GAME_RESOLUTION_X
|
2019-10-01 19:31:59 -04:00
|
|
|
|
|
|
|
uint8_t SFG_spriteSamplingPoints[SFG_MAX_SPRITE_SIZE];
|
|
|
|
|
|
|
|
void SFG_drawScaledImage(
|
|
|
|
const uint8_t *image,
|
|
|
|
int16_t centerX,
|
|
|
|
int16_t centerY,
|
|
|
|
int16_t size)
|
|
|
|
{
|
|
|
|
if ((size > SFG_MAX_SPRITE_SIZE) || (size == 0))
|
|
|
|
return;
|
|
|
|
|
|
|
|
uint16_t halfSize = size / 2;
|
|
|
|
|
|
|
|
int16_t topLeftX = centerX - halfSize;
|
|
|
|
int16_t topLeftY = centerY - halfSize;
|
|
|
|
|
|
|
|
int16_t x0, u0;
|
|
|
|
|
|
|
|
if (topLeftX < 0)
|
|
|
|
{
|
|
|
|
u0 = -1 * topLeftX;
|
|
|
|
x0 = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
u0 = 0;
|
|
|
|
x0 = topLeftX;
|
|
|
|
}
|
|
|
|
|
|
|
|
int16_t x1 = topLeftX + size - 1;
|
|
|
|
|
2019-10-04 10:32:24 -04:00
|
|
|
if (x1 >= SFG_GAME_RESOLUTION_X)
|
|
|
|
x1 = SFG_GAME_RESOLUTION_X - 1;
|
2019-10-01 19:31:59 -04:00
|
|
|
|
|
|
|
int16_t y0, v0;
|
|
|
|
|
|
|
|
if (topLeftY < 0)
|
|
|
|
{
|
|
|
|
v0 = -1 * topLeftY;
|
|
|
|
y0 = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
v0 = 0;
|
|
|
|
y0 = topLeftY;
|
|
|
|
}
|
|
|
|
|
|
|
|
int16_t y1 = topLeftY + size - 1;
|
|
|
|
|
2019-10-04 10:32:24 -04:00
|
|
|
if (y1 >= SFG_GAME_RESOLUTION_Y)
|
|
|
|
y1 = SFG_GAME_RESOLUTION_Y - 1;
|
2019-10-01 19:31:59 -04:00
|
|
|
|
|
|
|
if ((x0 > x1) || (y0 > y1)) // completely outside screen?
|
|
|
|
return;
|
|
|
|
|
|
|
|
int16_t u1 = u0 + (x1 - x0);
|
|
|
|
int16_t v1 = v0 + (y1 - y0);
|
|
|
|
|
|
|
|
// precompute sampling positions:
|
|
|
|
|
|
|
|
int16_t uMin = RCL_min(u0,u1);
|
|
|
|
int16_t vMin = RCL_min(v0,v1);
|
|
|
|
int16_t uMax = RCL_max(u0,u1);
|
|
|
|
int16_t vMax = RCL_max(v0,v1);
|
|
|
|
|
|
|
|
int16_t precompFrom = RCL_min(uMin,vMin);
|
|
|
|
int16_t precompTo = RCL_max(uMax,vMax);
|
|
|
|
|
|
|
|
#define PRECOMP_SCALE 2048
|
|
|
|
|
|
|
|
int16_t precompStepScaled = (SFG_TEXTURE_SIZE * PRECOMP_SCALE) / size;
|
|
|
|
int16_t precompPosScaled = precompFrom * precompStepScaled;
|
|
|
|
|
|
|
|
for (int16_t i = precompFrom; i <= precompTo; ++i)
|
|
|
|
{
|
|
|
|
SFG_spriteSamplingPoints[i] = precompPosScaled / PRECOMP_SCALE;
|
|
|
|
precompPosScaled += precompStepScaled;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef PRECOMP_SCALE
|
|
|
|
|
|
|
|
for (int16_t x = x0, u = u0; x <= x1; ++x, ++u)
|
|
|
|
for (int16_t y = y0, v = v0; y <= y1; ++y, ++v)
|
2019-10-04 10:32:24 -04:00
|
|
|
SFG_setGamePixel(x,y,SFG_getTexel(image,
|
2019-10-01 19:31:59 -04:00
|
|
|
SFG_spriteSamplingPoints[u],
|
|
|
|
SFG_spriteSamplingPoints[v]));
|
|
|
|
}
|
|
|
|
|
2019-09-26 15:15:07 -04:00
|
|
|
RCL_Unit SFG_texturesAt(int16_t x, int16_t y)
|
2019-09-25 09:51:19 -04:00
|
|
|
{
|
2019-09-26 22:41:45 -04:00
|
|
|
uint8_t p;
|
2019-09-26 21:34:49 -04:00
|
|
|
|
2019-09-30 11:15:15 -04:00
|
|
|
SFG_TileDefinition tile = SFG_getMapTile(SFG_currentLevel.levelPointer,x,y,&p);
|
2019-09-26 22:41:45 -04:00
|
|
|
return
|
|
|
|
SFG_TILE_FLOOR_TEXTURE(tile) | (SFG_TILE_CEILING_TEXTURE(tile) << 3) | p;
|
|
|
|
// ^ store both textures (floor and ceiling) and properties in one number
|
2019-09-25 09:51:19 -04:00
|
|
|
}
|
|
|
|
|
2019-09-26 21:34:49 -04:00
|
|
|
RCL_Unit SFG_movingWallHeight
|
|
|
|
(
|
|
|
|
RCL_Unit low,
|
|
|
|
RCL_Unit high,
|
|
|
|
uint32_t time
|
|
|
|
)
|
|
|
|
{
|
|
|
|
RCL_Unit height = high - low;
|
|
|
|
RCL_Unit halfHeight = height / 2;
|
|
|
|
|
|
|
|
RCL_Unit sinArg =
|
|
|
|
(time * ((SFG_MOVING_WALL_SPEED * RCL_UNITS_PER_SQUARE) / 1000)) / height;
|
|
|
|
|
|
|
|
return
|
|
|
|
low + halfHeight + (RCL_sinInt(sinArg) * halfHeight) / RCL_UNITS_PER_SQUARE;
|
|
|
|
}
|
|
|
|
|
2019-09-25 09:51:19 -04:00
|
|
|
RCL_Unit SFG_floorHeightAt(int16_t x, int16_t y)
|
|
|
|
{
|
2019-09-26 21:34:49 -04:00
|
|
|
uint8_t properties;
|
|
|
|
|
2019-10-04 15:09:10 -04:00
|
|
|
SFG_TileDefinition tile =
|
|
|
|
SFG_getMapTile(SFG_currentLevel.levelPointer,x,y,&properties);
|
2019-09-25 09:51:19 -04:00
|
|
|
|
2019-10-04 15:09:10 -04:00
|
|
|
uint8_t doorHeight = 0;
|
|
|
|
|
|
|
|
if (properties == SFG_TILE_PROPERTY_DOOR)
|
|
|
|
{
|
|
|
|
for (uint8_t i = 0; i < SFG_currentLevel.doorRecordCount; ++i)
|
|
|
|
{
|
|
|
|
SFG_DoorRecord *door = &(SFG_currentLevel.doors[i]);
|
|
|
|
|
|
|
|
if ((door->coords[0] == x) && (door->coords[1] == y))
|
|
|
|
{
|
|
|
|
doorHeight = door->state & SFG_DOOR_VERTICAL_POSITION_MASK;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (properties == SFG_TILE_PROPERTY_ELEVATOR)
|
|
|
|
{
|
|
|
|
return SFG_movingWallHeight(
|
2019-09-26 21:34:49 -04:00
|
|
|
SFG_TILE_FLOOR_HEIGHT(tile) * SFG_WALL_HEIGHT_STEP,
|
|
|
|
SFG_TILE_CEILING_HEIGHT(tile) * SFG_WALL_HEIGHT_STEP,
|
|
|
|
SFG_getTimeMs() - SFG_currentLevel.timeStart);
|
2019-10-04 15:09:10 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
return SFG_TILE_FLOOR_HEIGHT(tile) * SFG_WALL_HEIGHT_STEP -
|
|
|
|
doorHeight * SFG_DOOR_HEIGHT_STEP;
|
2019-09-25 09:51:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
RCL_Unit SFG_ceilingHeightAt(int16_t x, int16_t y)
|
|
|
|
{
|
2019-09-26 21:34:49 -04:00
|
|
|
uint8_t properties;
|
2019-09-30 11:15:15 -04:00
|
|
|
SFG_TileDefinition tile = SFG_getMapTile(SFG_currentLevel.levelPointer,x,y,&properties);
|
2019-09-26 21:34:49 -04:00
|
|
|
|
|
|
|
if (properties == SFG_TILE_PROPERTY_ELEVATOR)
|
|
|
|
return SFG_CEILING_MAX_HEIGHT;
|
2019-09-25 20:40:35 -04:00
|
|
|
|
|
|
|
uint8_t height = SFG_TILE_CEILING_HEIGHT(tile);
|
|
|
|
|
2019-09-27 09:24:36 -04:00
|
|
|
return properties != SFG_TILE_PROPERTY_SQUEEZER ?
|
|
|
|
(
|
|
|
|
height != SFG_TILE_CEILING_MAX_HEIGHT ?
|
|
|
|
((SFG_TILE_FLOOR_HEIGHT(tile) + height) * SFG_WALL_HEIGHT_STEP) :
|
|
|
|
SFG_CEILING_MAX_HEIGHT
|
|
|
|
) :
|
|
|
|
SFG_movingWallHeight(
|
|
|
|
SFG_TILE_FLOOR_HEIGHT(tile) * SFG_WALL_HEIGHT_STEP,
|
2019-09-30 15:35:49 -04:00
|
|
|
(SFG_TILE_CEILING_HEIGHT(tile) + SFG_TILE_FLOOR_HEIGHT(tile))
|
|
|
|
* SFG_WALL_HEIGHT_STEP,
|
2019-09-27 09:24:36 -04:00
|
|
|
SFG_getTimeMs() - SFG_currentLevel.timeStart);
|
2019-09-25 09:51:19 -04:00
|
|
|
}
|
|
|
|
|
2019-10-03 13:31:25 -04:00
|
|
|
uint32_t SFG_gameFrame;
|
2019-09-25 09:51:19 -04:00
|
|
|
uint32_t SFG_lastFrameTimeMs;
|
|
|
|
|
2019-10-02 08:42:30 -04:00
|
|
|
void SFG_setAndInitLevel(const SFG_Level *level)
|
2019-09-26 21:34:49 -04:00
|
|
|
{
|
2019-09-29 07:50:40 -04:00
|
|
|
SFG_LOG("setting and initializing level");
|
|
|
|
|
2019-09-26 21:34:49 -04:00
|
|
|
SFG_currentLevel.levelPointer = level;
|
|
|
|
|
2019-09-29 14:26:53 -04:00
|
|
|
SFG_currentLevel.floorColor = level->floorColor;
|
|
|
|
SFG_currentLevel.ceilingColor = level->ceilingColor;
|
|
|
|
|
2019-09-26 21:34:49 -04:00
|
|
|
for (uint8_t i = 0; i < 7; ++i)
|
|
|
|
SFG_currentLevel.textures[i] =
|
2019-09-29 03:50:58 -04:00
|
|
|
SFG_texturesWall[level->textureIndices[i]];
|
2019-09-26 21:34:49 -04:00
|
|
|
|
2019-10-04 11:18:46 -04:00
|
|
|
SFG_LOG("initializing doors");
|
|
|
|
|
|
|
|
SFG_currentLevel.doorRecordCount = 0;
|
|
|
|
|
|
|
|
for (uint8_t j = 0; j < SFG_MAP_SIZE; ++j)
|
|
|
|
{
|
|
|
|
for (uint8_t i = 0; i < SFG_MAP_SIZE; ++i)
|
|
|
|
{
|
|
|
|
uint8_t properties;
|
|
|
|
|
|
|
|
SFG_getMapTile(level,i,j,&properties);
|
|
|
|
|
|
|
|
if ((properties & SFG_TILE_PROPERTY_MASK) == SFG_TILE_PROPERTY_DOOR)
|
|
|
|
{
|
|
|
|
SFG_DoorRecord *d =
|
|
|
|
&(SFG_currentLevel.doors[SFG_currentLevel.doorRecordCount]);
|
|
|
|
|
|
|
|
d->coords[0] = i;
|
|
|
|
d->coords[1] = j;
|
2019-10-04 11:42:54 -04:00
|
|
|
d->state = SFG_DOOR_DEFAULT_STATE;
|
2019-10-04 11:18:46 -04:00
|
|
|
|
|
|
|
SFG_currentLevel.doorRecordCount++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (SFG_currentLevel.doorRecordCount >= SFG_MAX_DOORS)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (SFG_currentLevel.doorRecordCount >= SFG_MAX_DOORS)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2019-09-27 10:38:55 -04:00
|
|
|
SFG_currentLevel.timeStart = SFG_getTimeMs();
|
2019-10-04 11:42:54 -04:00
|
|
|
SFG_currentLevel.frameStart = SFG_gameFrame;
|
2019-09-26 21:34:49 -04:00
|
|
|
|
2019-10-01 14:25:21 -04:00
|
|
|
SFG_initPlayer();
|
2019-09-26 21:34:49 -04:00
|
|
|
}
|
2019-09-25 09:51:19 -04:00
|
|
|
|
2019-09-27 10:38:55 -04:00
|
|
|
void SFG_init()
|
|
|
|
{
|
2019-09-29 07:50:40 -04:00
|
|
|
SFG_LOG("initializing game")
|
|
|
|
|
2019-10-03 13:31:25 -04:00
|
|
|
SFG_gameFrame = 0;
|
2019-09-27 10:38:55 -04:00
|
|
|
SFG_lastFrameTimeMs = 0;
|
|
|
|
|
|
|
|
RCL_initRayConstraints(&SFG_rayConstraints);
|
|
|
|
|
|
|
|
SFG_rayConstraints.maxHits = SFG_RAYCASTING_MAX_HITS;
|
|
|
|
SFG_rayConstraints.maxSteps = SFG_RAYCASTING_MAX_STEPS;
|
|
|
|
|
2019-10-04 10:32:24 -04:00
|
|
|
for (uint16_t i = 0; i < SFG_GAME_RESOLUTION_Y; ++i)
|
|
|
|
SFG_backgroundScaleMap[i] =
|
|
|
|
(i * SFG_TEXTURE_SIZE) / SFG_GAME_RESOLUTION_Y;
|
2019-09-27 10:38:55 -04:00
|
|
|
|
|
|
|
SFG_backgroundScroll = 0;
|
|
|
|
|
2019-10-02 08:42:30 -04:00
|
|
|
SFG_setAndInitLevel(&SFG_level0);
|
2019-09-27 10:38:55 -04:00
|
|
|
}
|
|
|
|
|
2019-09-25 09:51:19 -04:00
|
|
|
/**
|
|
|
|
Performs one game step (logic, physics), happening SFG_MS_PER_FRAME after
|
|
|
|
previous frame.
|
|
|
|
*/
|
|
|
|
void SFG_gameStep()
|
|
|
|
{
|
|
|
|
int8_t recomputeDirection = 0;
|
|
|
|
|
2019-10-01 14:25:21 -04:00
|
|
|
RCL_Vector2D moveOffset;
|
|
|
|
|
|
|
|
moveOffset.x = 0;
|
|
|
|
moveOffset.y = 0;
|
|
|
|
|
2019-10-02 08:42:30 -04:00
|
|
|
int8_t strafe = 0;
|
|
|
|
|
2019-10-01 14:25:21 -04:00
|
|
|
if (SFG_keyPressed(SFG_KEY_A))
|
2019-09-25 09:51:19 -04:00
|
|
|
{
|
2019-10-01 14:25:21 -04:00
|
|
|
if (SFG_keyPressed(SFG_KEY_LEFT))
|
2019-10-02 08:42:30 -04:00
|
|
|
strafe = -1;
|
2019-10-01 14:25:21 -04:00
|
|
|
else if (SFG_keyPressed(SFG_KEY_RIGHT))
|
2019-10-02 08:42:30 -04:00
|
|
|
strafe = 1;
|
2019-09-25 09:51:19 -04:00
|
|
|
}
|
2019-10-01 14:25:21 -04:00
|
|
|
else
|
2019-09-25 09:51:19 -04:00
|
|
|
{
|
2019-10-01 14:25:21 -04:00
|
|
|
if (SFG_keyPressed(SFG_KEY_LEFT))
|
|
|
|
{
|
|
|
|
SFG_player.camera.direction -= SFG_PLAYER_TURN_UNITS_PER_FRAME;
|
|
|
|
recomputeDirection = 1;
|
|
|
|
}
|
|
|
|
else if (SFG_keyPressed(SFG_KEY_RIGHT))
|
|
|
|
{
|
|
|
|
SFG_player.camera.direction += SFG_PLAYER_TURN_UNITS_PER_FRAME;
|
|
|
|
recomputeDirection = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (recomputeDirection)
|
|
|
|
SFG_recompurePLayerDirection();
|
2019-09-25 09:51:19 -04:00
|
|
|
}
|
|
|
|
|
2019-10-02 08:42:30 -04:00
|
|
|
if (SFG_keyPressed(SFG_KEY_STRAFE_LEFT))
|
|
|
|
strafe = -1;
|
|
|
|
else if (SFG_keyPressed(SFG_KEY_STRAFE_RIGHT))
|
|
|
|
strafe = 1;
|
|
|
|
|
|
|
|
if (strafe != 0)
|
|
|
|
{
|
|
|
|
moveOffset.x = strafe * SFG_player.direction.y;
|
|
|
|
moveOffset.y = -1 * strafe * SFG_player.direction.x;
|
|
|
|
}
|
|
|
|
|
2019-10-02 06:02:52 -04:00
|
|
|
#if SFG_PREVIEW_MODE
|
|
|
|
if (SFG_keyPressed(SFG_KEY_B))
|
|
|
|
SFG_player.verticalSpeed = SFG_PLAYER_MOVE_UNITS_PER_FRAME;
|
|
|
|
else if (SFG_keyPressed(SFG_KEY_C))
|
|
|
|
SFG_player.verticalSpeed = -1 * SFG_PLAYER_MOVE_UNITS_PER_FRAME;
|
|
|
|
else
|
|
|
|
SFG_player.verticalSpeed = 0;
|
|
|
|
#else
|
2019-10-03 14:09:00 -04:00
|
|
|
RCL_Unit verticalOffset =
|
2019-10-03 14:24:34 -04:00
|
|
|
(
|
|
|
|
(
|
|
|
|
SFG_keyPressed(SFG_KEY_JUMP) ||
|
|
|
|
(SFG_keyPressed(SFG_KEY_UP) && SFG_keyPressed(SFG_KEY_C))
|
|
|
|
) &&
|
|
|
|
(SFG_player.verticalSpeed == 0) &&
|
2019-10-03 14:09:00 -04:00
|
|
|
(SFG_player.previousVerticalSpeed == 0)) ?
|
|
|
|
SFG_PLAYER_JUMP_SPEED :
|
|
|
|
(SFG_player.verticalSpeed - SFG_GRAVITY_SPEED_INCREASE_PER_FRAME);
|
2019-10-02 06:02:52 -04:00
|
|
|
#endif
|
2019-09-25 09:51:19 -04:00
|
|
|
|
|
|
|
if (SFG_keyPressed(SFG_KEY_UP))
|
|
|
|
{
|
2019-10-01 14:25:21 -04:00
|
|
|
moveOffset.x += SFG_player.direction.x;
|
|
|
|
moveOffset.y += SFG_player.direction.y;
|
2019-09-25 09:51:19 -04:00
|
|
|
}
|
|
|
|
else if (SFG_keyPressed(SFG_KEY_DOWN))
|
|
|
|
{
|
2019-10-01 14:25:21 -04:00
|
|
|
moveOffset.x -= SFG_player.direction.x;
|
|
|
|
moveOffset.y -= SFG_player.direction.y;
|
2019-09-25 09:51:19 -04:00
|
|
|
}
|
|
|
|
|
2019-10-01 14:25:21 -04:00
|
|
|
RCL_Unit previousHeight = SFG_player.camera.height;
|
|
|
|
|
2019-10-02 06:02:52 -04:00
|
|
|
#if SFG_PREVIEW_MODE
|
|
|
|
SFG_player.camera.position.x +=
|
|
|
|
SFG_PREVIEW_MODE_SPEED_MULTIPLIER * moveOffset.x;
|
|
|
|
|
|
|
|
SFG_player.camera.position.y +=
|
|
|
|
SFG_PREVIEW_MODE_SPEED_MULTIPLIER * moveOffset.y;
|
|
|
|
|
|
|
|
SFG_player.camera.height +=
|
|
|
|
SFG_PREVIEW_MODE_SPEED_MULTIPLIER * SFG_player.verticalSpeed;
|
|
|
|
#else
|
2019-10-01 14:25:21 -04:00
|
|
|
RCL_moveCameraWithCollision(&(SFG_player.camera),moveOffset,
|
2019-10-03 14:09:00 -04:00
|
|
|
verticalOffset,SFG_floorHeightAt,SFG_ceilingHeightAt,1,1);
|
2019-10-01 14:25:21 -04:00
|
|
|
|
2019-10-03 14:09:00 -04:00
|
|
|
SFG_player.previousVerticalSpeed = SFG_player.verticalSpeed;
|
|
|
|
|
|
|
|
RCL_Unit limit = RCL_max(RCL_max(0,verticalOffset),SFG_player.verticalSpeed);
|
|
|
|
|
2019-10-01 14:25:21 -04:00
|
|
|
SFG_player.verticalSpeed =
|
2019-10-03 14:09:00 -04:00
|
|
|
RCL_min(limit,SFG_player.camera.height - previousHeight);
|
|
|
|
/* ^ By "limit" we assure height increase caused by climbing a step doesn't
|
|
|
|
add vertical velocity. */
|
2019-10-02 06:02:52 -04:00
|
|
|
#endif
|
2019-10-04 11:42:54 -04:00
|
|
|
|
|
|
|
SFG_player.squarePosition[0] =
|
|
|
|
SFG_player.camera.position.x / RCL_UNITS_PER_SQUARE;
|
|
|
|
|
|
|
|
SFG_player.squarePosition[1] =
|
|
|
|
SFG_player.camera.position.y / RCL_UNITS_PER_SQUARE;
|
|
|
|
|
|
|
|
// handle door:
|
|
|
|
|
|
|
|
/* Check one door on whether a player is standing nearby. For performance
|
|
|
|
reasons we only check one door and move to another in the next frame. */
|
|
|
|
|
2019-10-04 15:09:10 -04:00
|
|
|
SFG_DoorRecord *door =
|
|
|
|
&(SFG_currentLevel.doors[SFG_currentLevel.checkedDoorIndex]);
|
2019-10-04 11:42:54 -04:00
|
|
|
|
2019-10-04 15:09:10 -04:00
|
|
|
door->state = (door->state & ~SFG_DOOR_UP_DOWN_MASK) |
|
|
|
|
(
|
|
|
|
((door->coords[0] >= (SFG_player.squarePosition[0] - 1)) &&
|
|
|
|
(door->coords[0] <= (SFG_player.squarePosition[0] + 1)) &&
|
|
|
|
(door->coords[1] >= (SFG_player.squarePosition[1] - 1)) &&
|
|
|
|
(door->coords[1] <= (SFG_player.squarePosition[1] + 1))) ?
|
|
|
|
SFG_DOOR_UP_DOWN_MASK : 0x00
|
|
|
|
);
|
2019-10-04 11:42:54 -04:00
|
|
|
|
|
|
|
SFG_currentLevel.checkedDoorIndex++;
|
|
|
|
|
|
|
|
if (SFG_currentLevel.checkedDoorIndex >= SFG_currentLevel.doorRecordCount)
|
|
|
|
SFG_currentLevel.checkedDoorIndex = 0;
|
2019-10-04 15:09:10 -04:00
|
|
|
|
|
|
|
for (uint32_t i = 0; i < SFG_currentLevel.doorRecordCount; ++i)
|
|
|
|
{
|
|
|
|
SFG_DoorRecord *door = &(SFG_currentLevel.doors[i]);
|
|
|
|
|
|
|
|
int8_t height = door->state & SFG_DOOR_VERTICAL_POSITION_MASK;
|
|
|
|
|
|
|
|
height = (door->state & SFG_DOOR_UP_DOWN_MASK) ?
|
|
|
|
RCL_min(0x1f,height + SFG_DOOR_INCREMENT_PER_FRAME) :
|
|
|
|
RCL_max(0x00,height - SFG_DOOR_INCREMENT_PER_FRAME);
|
|
|
|
|
|
|
|
door->state = (door->state & ~SFG_DOOR_VERTICAL_POSITION_MASK) | height;
|
|
|
|
}
|
2019-09-25 09:51:19 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void SFG_mainLoopBody()
|
|
|
|
{
|
|
|
|
/* standard deterministic game loop, independed on actuall achieved FPS,
|
|
|
|
each game logic (physics) frame is performed with the SFG_MS_PER_FRAME
|
|
|
|
delta time. */
|
|
|
|
|
|
|
|
uint32_t timeNow = SFG_getTimeMs();
|
2019-10-03 13:31:25 -04:00
|
|
|
uint32_t timeNextFrame = SFG_lastFrameTimeMs + SFG_MS_PER_FRAME;
|
2019-09-25 09:51:19 -04:00
|
|
|
|
2019-10-03 13:31:25 -04:00
|
|
|
if (timeNow >= timeNextFrame)
|
2019-09-25 09:51:19 -04:00
|
|
|
{
|
2019-10-03 13:31:25 -04:00
|
|
|
uint32_t timeSinceLastFrame = timeNow - SFG_lastFrameTimeMs;
|
|
|
|
|
|
|
|
uint8_t steps = 0;
|
|
|
|
|
2019-09-25 09:51:19 -04:00
|
|
|
// perform game logic (physics), for each frame
|
|
|
|
while (timeSinceLastFrame >= SFG_MS_PER_FRAME)
|
|
|
|
{
|
|
|
|
SFG_gameStep();
|
|
|
|
|
|
|
|
timeSinceLastFrame -= SFG_MS_PER_FRAME;
|
|
|
|
|
2019-10-03 13:31:25 -04:00
|
|
|
SFG_gameFrame++;
|
|
|
|
steps++;
|
2019-09-25 09:51:19 -04:00
|
|
|
}
|
|
|
|
|
2019-10-03 13:31:25 -04:00
|
|
|
if (steps > 1)
|
|
|
|
SFG_LOG("Failed to reach target FPS! Consider setting a lower value.")
|
|
|
|
|
2019-09-25 09:51:19 -04:00
|
|
|
// render noly once
|
2019-10-01 14:25:21 -04:00
|
|
|
RCL_renderComplex(SFG_player.camera,SFG_floorHeightAt,SFG_ceilingHeightAt,SFG_texturesAt,SFG_rayConstraints);
|
2019-09-25 09:51:19 -04:00
|
|
|
|
|
|
|
SFG_lastFrameTimeMs = timeNow;
|
|
|
|
}
|
2019-09-29 07:50:40 -04:00
|
|
|
else
|
2019-10-03 13:31:25 -04:00
|
|
|
{
|
|
|
|
SFG_sleepMs((timeNextFrame - timeNow) / 2); // wait, relieve CPU
|
|
|
|
}
|
2019-09-25 09:51:19 -04:00
|
|
|
}
|