From 3352d9a2346bfe56737552d2d938e50259dae785 Mon Sep 17 00:00:00 2001 From: Miloslav Ciz Date: Thu, 19 Dec 2024 21:10:18 +0100 Subject: [PATCH] Turn car vertically on start --- game.h | 4 +++ map.h | 2 +- racing.h | 90 +++++++++++++++++++++++++++++++------------------------- 3 files changed, 55 insertions(+), 41 deletions(-) diff --git a/game.h b/game.h index 03fc464..5485bbd 100644 --- a/game.h +++ b/game.h @@ -414,6 +414,10 @@ LCR_GameUnit physicsInterpolationParam = LCR_GAME_UNIT - if (sleep) LCR_sleep(sleep); + else + { + LCR_LOG1("can't sleep, frames take too long!"); + } LCR_LOG2("game step end"); diff --git a/map.h b/map.h index ada9cd2..d185861 100644 --- a/map.h +++ b/map.h @@ -508,7 +508,7 @@ uint8_t LCR_mapLoadFromStr(const char *mapStr) LCR_currentMap.startPos[0] = coords[0]; LCR_currentMap.startPos[1] = coords[1]; LCR_currentMap.startPos[2] = coords[2]; - LCR_currentMap.startPos[3] = trans & 0x60; + LCR_currentMap.startPos[3] = trans; break; case LCR_BLOCK_CHECKPOINT_0: diff --git a/racing.h b/racing.h index 25350c3..c6cb15f 100644 --- a/racing.h +++ b/racing.h @@ -60,6 +60,7 @@ struct TPE_Body carBody; TPE_Joint carJoints[LCR_CAR_JOINTS]; TPE_Connection carConnections[LCR_CAR_CONNECTIONS]; + uint32_t tick; uint8_t wheelCollisions; /**< In individual bits records for each car wheel whether it's currently touching the ground. @@ -70,29 +71,28 @@ struct TPE_Vec3 carRotations[2]; ///< Current and previous rotation in game units. uint8_t carDrifting; ///< Whether or not the car is currently in drift. - TPE_Vec3 carOKPositions[LCR_CAR_JOINTS]; - uint8_t carNotOKCount; - TPE_Unit fanForce; ///< Upwards acceleration caused by a fan. - - LCR_GameUnit wheelRotation; - LCR_GameUnit wheelSteer; - - + LCR_GameUnit wheelAngle; ///< Current wheel angle, 0 to LCR_GAME_UNIT. + LCR_GameUnit wheelSteer; ///< Left/right steer with LCR_CAR_STEER_MAX bounds. LCR_GameUnit carSpeed; /**< Signed speed in game units per tick (negative if backwards) */ + + // for fixing physics bugs: + TPE_Vec3 carOKPositions[LCR_CAR_JOINTS]; + uint8_t carNotOKCount; } LCR_racing; - - - TPE_Vec3 _LCR_TPE_vec3DividePlain(TPE_Vec3 v, TPE_Unit d) { v.x /= d; v.y /= d; v.z /= d; return v; } +/** + Helper function for _LCR_racingEnvironmentFunction, returns closest point + on a map block placed at coordinate origin. +*/ TPE_Vec3 _LCR_racingBlockEnvFunc(TPE_Vec3 point, const uint8_t *block) { TPE_Vec3 v, vBest; @@ -230,8 +230,8 @@ TPE_Vec3 _LCR_racingBlockEnvFunc(TPE_Vec3 point, const uint8_t *block) sides[5] *= -1; } - _CHECK_NEXT(TPE_envAATriPrism(point,TPE_vec3(0,0,0),sides,LCR_PHYSICS_UNIT / 2 - ,1)); + _CHECK_NEXT(TPE_envAATriPrism(point,TPE_vec3(0,0,0),sides, + LCR_PHYSICS_UNIT / 2,1)); sides[2] = sides[4]; sides[3] = sides[5]; @@ -239,8 +239,8 @@ TPE_Vec3 _LCR_racingBlockEnvFunc(TPE_Vec3 point, const uint8_t *block) sides[4] = LCR_PHYSICS_UNIT / 2; sides[5] = LCR_PHYSICS_UNIT / 2; - _CHECK_NEXT(TPE_envAATriPrism(point,TPE_vec3(0,0,0),sides,LCR_PHYSICS_UNIT / 2 - ,1)); + _CHECK_NEXT(TPE_envAATriPrism(point,TPE_vec3(0,0,0),sides, + LCR_PHYSICS_UNIT / 2,1)); point = vBest; @@ -334,8 +334,8 @@ TPE_Vec3 _LCR_racingBlockEnvFunc(TPE_Vec3 point, const uint8_t *block) case LCR_BLOCK_HILL: { - point = - (point.y > -1 * LCR_PHYSICS_UNIT / 4 && point.z < LCR_PHYSICS_UNIT / 4) ? + point = (point.y > -1 * LCR_PHYSICS_UNIT / 4 && point.z + < LCR_PHYSICS_UNIT / 4) ? TPE_envCylinder(point, TPE_vec3(0,-1 * LCR_PHYSICS_UNIT / 2,LCR_PHYSICS_UNIT / 4), TPE_vec3(LCR_PHYSICS_UNIT / 2,0,0), @@ -351,8 +351,7 @@ TPE_Vec3 _LCR_racingBlockEnvFunc(TPE_Vec3 point, const uint8_t *block) } case LCR_BLOCK_BUMP: - point = TPE_envCone(point, - TPE_vec3(0,-1 * LCR_PHYSICS_UNIT / 4 ,0), + point = TPE_envCone(point,TPE_vec3(0,-1 * LCR_PHYSICS_UNIT / 4 ,0), TPE_vec3(0,LCR_PHYSICS_UNIT / 6,0),(5 * LCR_PHYSICS_UNIT) / 12); break; @@ -391,6 +390,10 @@ TPE_Vec3 _LCR_racingBlockEnvFunc(TPE_Vec3 point, const uint8_t *block) return point; } +/** + For tinyphysicsengine, function that defines the shape of physics world, + returns closest point to any given point in space. +*/ TPE_Vec3 _LCR_racingEnvironmentFunction(TPE_Vec3 point, TPE_Unit maxDist) { // start with the map outside walls: @@ -467,7 +470,7 @@ TPE_Vec3 _LCR_racingEnvironmentFunction(TPE_Vec3 point, TPE_Unit maxDist) const uint8_t *block = LCR_currentMap.blocks; - /* Full check of all map blocks, slow, shouldn't happen often! */ + // Full check of all map blocks, slow, shouldn't happen often! for (int j = 0; j < LCR_currentMap.blockCount; ++j) { TPE_ENV_NEXT(_LCR_racingBlockEnvFunc(point,block),point) @@ -563,7 +566,7 @@ void LCR_racingRestart(void) TPE_bodyActivate(&(LCR_racing.carBody)); LCR_racing.wheelCollisions = 0; - LCR_racing.wheelRotation = 0; + LCR_racing.wheelAngle = 0; LCR_racing.wheelSteer = 0; LCR_racing.carSpeed = 0; LCR_racing.carDrifting = 0; @@ -591,8 +594,7 @@ void LCR_racingRestart(void) all map blocks. */ LCR_racing.carBody.flags |= TPE_BODY_FLAG_NO_BSPHERE; -TPE_bodyMoveTo(&(LCR_racing.carBody), - TPE_vec3( + TPE_bodyMoveTo(&(LCR_racing.carBody),TPE_vec3( (((TPE_Unit) LCR_currentMap.startPos[0]) - LCR_MAP_SIZE_BLOCKS / 2) * LCR_PHYSICS_UNIT + LCR_PHYSICS_UNIT / 2, (((TPE_Unit) LCR_currentMap.startPos[1]) - LCR_MAP_SIZE_BLOCKS / 2) @@ -600,19 +602,29 @@ TPE_bodyMoveTo(&(LCR_racing.carBody), (((TPE_Unit) LCR_currentMap.startPos[2]) - LCR_MAP_SIZE_BLOCKS / 2) * LCR_PHYSICS_UNIT + LCR_PHYSICS_UNIT / 2)); -// TODO: allow also flipping the car upside down on start? -if (LCR_currentMap.startPos[3]) - TPE_bodyRotateByAxis(&(LCR_racing.carBody), - TPE_vec3(0, - LCR_currentMap.startPos[3] == LCR_BLOCK_TRANSFORM_ROT_90 ? 3 * TPE_F / 4 : - (LCR_currentMap.startPos[3] == LCR_BLOCK_TRANSFORM_ROT_180 ? TPE_F / 2 : - (TPE_F / 4)),0)); + if (LCR_currentMap.startPos[3]) + { + uint8_t trans = LCR_currentMap.startPos[3]; -for (int i = 0; i < LCR_CAR_JOINTS; ++i) - LCR_racing.carOKPositions[i] = TPE_vec3(0,0,0); + if (trans & LCR_BLOCK_TRANSFORM_FLIP_V) + TPE_bodyRotateByAxis(&(LCR_racing.carBody), + TPE_vec3(TPE_FRACTIONS_PER_UNIT / 2,0,0)); -LCR_racing.carNotOKCount = 0; + trans &= + LCR_BLOCK_TRANSFORM_ROT_90 | + LCR_BLOCK_TRANSFORM_ROT_180 | + LCR_BLOCK_TRANSFORM_ROT_270; + TPE_bodyRotateByAxis(&(LCR_racing.carBody), + TPE_vec3(0,(trans == LCR_BLOCK_TRANSFORM_ROT_90) ? + 3 * TPE_F / 4 : (trans == LCR_BLOCK_TRANSFORM_ROT_180) ? + TPE_F / 2 : (TPE_F / 4),0)); + } + + for (int i = 0; i < LCR_CAR_JOINTS; ++i) + LCR_racing.carOKPositions[i] = TPE_vec3(0,0,0); + + LCR_racing.carNotOKCount = 0; LCR_racing.carPositions[0] = TPE_vec3(0,0,0); LCR_racing.carPositions[1] = LCR_racing.carPositions[0]; @@ -623,8 +635,6 @@ LCR_racing.carNotOKCount = 0; LCR_racing.carPositions[1] = LCR_racing.carPositions[0]; LCR_racing.carRotations[1] = LCR_racing.carRotations[0]; - - // TODO } /** @@ -701,7 +711,7 @@ int LCR_racingCarWheelTouchesGround(int wheel) LCR_GameUnit LCR_racingGetWheelRotation(void) { - return LCR_racing.wheelRotation; + return LCR_racing.wheelAngle; } LCR_GameUnit LCR_racingGetWheelSteer(void) @@ -877,11 +887,11 @@ uint32_t LCR_racingStep(unsigned int input) if (!(input & LCR_RACING_INPUT_BACK)) rotateBy *= -1; - LCR_racing.wheelRotation = - (LCR_racing.wheelRotation + rotateBy) % LCR_GAME_UNIT; + LCR_racing.wheelAngle = + (LCR_racing.wheelAngle + rotateBy) % LCR_GAME_UNIT; - if (LCR_racing.wheelRotation < 0) - LCR_racing.wheelRotation += LCR_GAME_UNIT; + if (LCR_racing.wheelAngle < 0) + LCR_racing.wheelAngle += LCR_GAME_UNIT; } if (input & LCR_RACING_INPUT_RIGHT)