Rotate Player in Relation to Rotated Rectangle

Question

I'm trying to build a game where the player can stand on rotated rectangles. Take the example if a rectangular platform is rotated 20 degrees, then the player would be standing on the platform at a 20 degree angle as well, and could move along that rotated axis. Perhaps this image will clear this up:

Therefore, I need to:

1. Make the platform solid so the player can stand on it
2. Make the player rotate to the same angle as the platform
3. Make the player move on the rotated axis

I've tried to do this, but I've failed. Here's my code that I tried:

#include "raylib.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define WIDTH 1200 
#define HEIGHT 800

typedef struct {
    const int width;
    const int height;
    int FPS;
} Window;

Window window = {
    .FPS = 60,
};

typedef struct {
    Vector2 pos;
    Vector2 acc;
    Vector2 vel;
    int width;
    int height;

    double accSpeed;
    int maxVel;
    double friction;
    double rotation;
    double scale;

    float jumpForce;
    float gravity;
    bool canJump;

} Player;

Player player = {

    .pos = {WIDTH/2, HEIGHT/2},
    .acc = {0, 0},
    .vel = {0, 0},
    .width = 50,
    .height = 100,

    .accSpeed = 0.15,
    .maxVel = 7,
    .friction = 0.2,
    .rotation = 0,
    .scale = 0.5,

    .jumpForce = 15,
    .gravity = 0.5,
    .canJump = true,
};

void movePlayerX();
void movePlayerY();
int rectCollide();

int main() {

    InitWindow(WIDTH, HEIGHT, "Window");
    SetTargetFPS(window.FPS);

    //Rectangle playerArea = {player.pos.x, player.pos.y, playerImg.width*player.scale, playerImg.height*player.scale}; 
    Rectangle playerArea;    
    Rectangle rect1 = {500, 600, 100, 250};


while (!WindowShouldClose()) {      
        
    playerArea = (Rectangle) {    
        player.pos.x,                
        player.pos.y,                
        player.width,  
        player.height,
    };    
            
    BeginDrawing();    
        ClearBackground(RAYWHITE);       
        
        DrawRectanglePro(rect1, (Vector2) {0, 0}, 20, BLUE);

        DrawRectanglePro(playerArea, (Vector2) {0, 0}, player.rotation, RED);
        
        movePlayerX();
        /*if (CheckCollisionRecs(playerArea, rect1)) {
            if (player.vel.x < 0) { // If the player moved left and collided with the right side of block
                    player.pos.x = rect1.x + rect1.width;
                } else { // If the player moved right and collided with the left side of block
                    player.pos.x = rect1.x - playerArea.width;
                }
                player.vel.x = 0;
        }*/
        movePlayerY();
        if (CheckCollisionRecs(playerArea, rect1)) {
            if (player.vel.y < 0) { // If the player hit their head
                player.pos.y = rect1.y + rect1.height;
                player.vel.y *= -0.5; // Not -1 because collisions are not perfectly elastic
            } else {
                player.pos.y = rect1.y - player.height;
                player.rotation = 20;
                player.vel.y = 0;
                player.acc.y = 0;
                player.canJump = true;
            }
        }


            
        if (player.pos.y >= HEIGHT - player.height) {
            player.canJump = true;
            player.pos.y = HEIGHT - player.height;
            player.vel.y = 0;
        }


        EndDrawing(); 

    }
}

void movePlayerX() {
    if (IsKeyDown(KEY_LEFT) && player.vel.x > -player.maxVel) {
        player.acc.x = -player.accSpeed;
    } else if (IsKeyDown(KEY_RIGHT) && player.vel.x < player.maxVel) {
        player.acc.x = player.accSpeed;
    } else if (abs(player.vel.x) > 0.2) {
        if (player.vel.x < 0) {
            player.acc.x = player.friction;
        } else {
            player.acc.x = -player.friction;
        }
    } else {
        player.vel.x = 0;
        player.acc.x = 0;
    }
    player.vel.x += player.acc.x;
    player.pos.x += player.vel.x;
}

void movePlayerY() {
    if (IsKeyPressed(KEY_UP) && player.vel.y == 0 && player.acc.y == 0 && player.canJump) {
        player.canJump = false;
        player.vel.y = -player.jumpForce;
    }
    player.acc.y += player.gravity;
    player.vel.y += player.acc.y;
    player.pos.y += player.vel.y;
    player.acc.y = 0;
}

As can be seen from the code, after I call the player movement functions, movePlayerX() and movePlayerY(), I'm trying to detect if the player is colliding with the rectangle. However, I'm just using the regular built in CheckCollisionRecs() function, which detects collision on a non-rotated rectangle, which won't work.

Therefore, I was wondering: how can I get a function to detect the player's collison on a rotated rectangle, then rotate and move the player upon that rotated angle?

Thanks.