make a new function called timewallexsrap this is an exstraption version that uses logic…
- User
make a new function called timewallexsrap this is an exstraption version that uses logic like this // New reward cutoff logic float goalY = RLConst::SOCCAR_GOAL_SCORE_BASE_THRESHOLD_Y * (player.team == Team::BLUE ? 1 : -1); float distToGoalY = std::abs(ball.pos.y - goalY); float extrapScoreTime = distToGoalY / std::max(std::abs(ball.vel.y), 0.01f); Vec extrapScorePos = ball.pos + ball.vel * extrapScoreTime; extrapScorePos.z += CommonValues::GRAVITY_Z * (extrapScoreTime * extrapScoreTime) / 2; if (extrapScoreTime <= MIN_SCORE_TIME || extrapScorePos.z >= MAX_EXTRAP_Z) { reward = 0.0f; // Disable reward if the ball is about to score or go too high } but just for the car and the walls the nwhen its done finding the closest wall it then renders to rlbot a line from the car too the point on the wall the exstraption logic thinks is the spot the player is landing on if (!renderTimeToReachBallEnabled || !ballPredTracker) return; rlbot::ScopedRenderer renderer("time_to_reach_renderer");
constexpr float PREDICTION_DURATION = 6.0f; constexpr int NUM_PREDICTION_POINTS = 8; // Update ball prediction RocketSim::BallState currentBallState; currentBallState.pos = RocketSim::Vec(gs.ball.pos.x, gs.ball.pos.y, gs.ball.pos.z); currentBallState.vel = RocketSim::Vec(gs.ball.vel.x, gs.ball.vel.y, gs.ball.vel.z); currentBallState.angVel = RocketSim::Vec(gs.ball.angVel.x, gs.ball.angVel.y, gs.ball.angVel.z); currentBallState.rotMat = RocketSim::RotMat(gs.ball.rotMat.forward, gs.ball.rotMat.right, gs.ball.rotMat.up); int numTicks = static_cast<int>(PREDICTION_DURATION * 120); ballPredTracker->UpdatePredManual(currentBallState, numTicks); const auto& ballPredData = ballPredTracker->predData; size_t predictionInterval = ballPredData.size() / NUM_PREDICTION_POINTS; // Find the opponent (if any) const PlayerData* opponent = nullptr; for (const auto& player : gs.players) { if (player.team != gs.players[index].team) { opponent = &player; break; } } std::vector<float> localTimeToReach(NUM_PREDICTION_POINTS); std::vector<float> opponentTimeToReach(NUM_PREDICTION_POINTS); float localPossession = 0.0f; float opponentPossession = 0.0f; for (size_t j = 0; j < NUM_PREDICTION_POINTS; ++j) { size_t index = j * predictionInterval; if (index >= ballPredData.size()) break; Vec ballPos(ballPredData[index].pos.x, ballPredData[index].pos.y, ballPredData[index].pos.z); localTimeToReach[j] = calculateTimeToReach(gs, ballPos); if (opponent) { RLGSC::GameState opponentGs = gs; opponentGs.players[this->index] = *opponent; opponentTimeToReach[j] = calculateTimeToReach(opponentGs, ballPos); if (localTimeToReach[j] < opponentTimeToReach[j]) { localPossession += 1.0f; } else { opponentPossession += 1.0f; } } else { localPossession += 1.0f; } } float totalPossession = localPossession + opponentPossession; localPossession /= totalPossession; opponentPossession /= totalPossession; // Define Rocket League colors rlbot::Color rocketLeagueBlue{ 0, 153, 255, 255 }; rlbot::Color rocketLeagueOrange{ 235, 141, 31, 255 }; // Determine the dominant team and color bool isLocalDominant = localPossession >= opponentPossession; rlbot::Color dominantColor = isLocalDominant ? (gs.players[this->index].team == Team::BLUE ? rocketLeagueBlue : rocketLeagueOrange) : (gs.players[this->index].team == Team::BLUE ? rocketLeagueOrange : rocketLeagueBlue); // Get the position of the car with the best possession rlbot::flat::Vector3 bestCarPos; if (isLocalDominant) { bestCarPos = { static_cast<float>(gs.players[this->index].phys.pos.x), static_cast<float>(gs.players[this->index].phys.pos.y), static_cast<float>(gs.players[this->index].phys.pos.z) }; } else if (opponent) { bestCarPos = { static_cast<float>(opponent->phys.pos.x), static_cast<float>(opponent->phys.pos.y), static_cast<float>(opponent->phys.pos.z) }; } // Render the single line from the best car to the ball rlbot::flat::Vector3 ballPos = { static_cast<float>(gs.ball.pos.x), static_cast<float>(gs.ball.pos.y), static_cast<float>(gs.ball.pos.z) }; renderer.DrawLine3D(dominantColor, bestCarPos, ballPos); // Render time to ball inside the ball float timeToReach = isLocalDominant ? localTimeToReach[0] : opponentTimeToReach[0]; std::stringstream timeSS; timeSS << std::fixed << std::setprecision(2) << timeToReach << "s"; renderer.DrawString3D(timeSS.str(), dominantColor, ballPos, 1.0f, 1.0f); // Render possession information std::stringstream localSS; localSS << (gs.players[this->index].team == Team::BLUE ? "Blue" : "Orange") << " possession: " << std::fixed << std::setprecision(2) << localPossession * 100 << "%"; renderer.DrawString2D(localSS.str(), gs.players[this->index].team == Team::BLUE ? rocketLeagueBlue : rocketLeagueOrange, rlbot::flat::Vector3{ 10, 10, 0 }, 2.0f, 2.0f); if (opponent) { std::stringstream opponentSS; opponentSS << (gs.players[this->index].team == Team::BLUE ? "Orange" : "Blue") << " possession: " << std::fixed << std::setprecision(2) << opponentPossession * 100 << "%"; renderer.DrawString2D(opponentSS.str(), gs.players[this->index].team == Team::BLUE ? rocketLeagueOrange : rocketLeagueBlue, rlbot::flat::Vector3{ 10, 40, 0 }, 2.0f, 2.0f); } // Render overall possession summary std::stringstream summaryStream; summaryStream << "Dominant team: " << (isLocalDominant ? (gs.players[this->index].team == Team::BLUE ? "Blue" : "Orange") : (gs.players[this->index].team == Team::BLUE ? "Orange" : "Blue")); renderer.DrawString2D(summaryStream.str(), dominantColor, rlbot::flat::Vector3{ 10, 70, 0 }, 2.0f, 2.0f);}
#include
float RLBotBot::TimeToGround(const RLGSC::GameState & gs) { constexpr float GRAVITY = -650.0f; // Gravity in Rocket League (uu/s^2) constexpr float GROUND_Z = 17.01f; // Approximate ground level for cars
const auto& player = gs.players[this->index]; float z = player.phys.pos.z; float vz = player.phys.vel.z; // If the car is already on the ground, return 0 if (z <= GROUND_Z) { return 0.0f; } // Calculate time to ground using quadratic formula // z = z0 + v0*t + 0.5*a*t^2 // 0 = (z0 - GROUND_Z) + v0*t + 0.5*a*t^2 float a = 0.5f * GRAVITY; float b = vz; float c = z - GROUND_Z; float discriminant = b * b - 4 * a * c; // If discriminant is negative, use a linear approximation if (discriminant < 0) { // This shouldn't happen in normal gameplay, but let's approximate return (z - GROUND_Z) / -vz; // Simple linear approximation } float sqrtDiscriminant = std::sqrt(discriminant); float t1 = (-b + sqrtDiscriminant) / (2 * a); float t2 = (-b - sqrtDiscriminant) / (2 * a); // Return the positive time that's closest to zero if (t1 >= 0 && t2 >= 0) { return RS_MIN(t1, t2); } else if (t1 >= 0) { return t1; } else if (t2 >= 0) { return t2; } else { // This shouldn't happen, but just in case, return a small positive value return 0.001f; }}
float calculateAirTime(float curDist, float curVel, bool hasBoost, bool hasFlip) { float t = 0; bool hasFlipped = false;
while (curDist > 0) { if (curVel < MAX_TOTAL_SPEED && t == 0 && hasFlip) { // Flip force curVel += FLIP_FORCE; hasFlipped = true; } if (curVel < MAX_TOTAL_SPEED) { // Apply air acceleration float accel = AIR_ACCEL; if (hasBoost) { accel += BOOST_ACCEL_AIR; } curVel += accel * STEP_INTERVAL; } curVel = RS_MIN(curVel, MAX_TOTAL_SPEED); float distTraveled = curVel * STEP_INTERVAL; curDist -= distTraveled; t += STEP_INTERVAL; if (curDist <= 0) { // Adjust for overshooting t -= STEP_INTERVAL; t += curDist / curVel; break; } } return t;}
float RLBotBot::TimeToClosestWallAir(const RLGSC::GameState& gs) { constexpr float STEP_INTERVAL = 1.0f / 120.0f; // Assuming 120 ticks per second
// Get the player's position and velocity const auto& player = gs.players[this->index]; float x = player.phys.pos.x; float y = player.phys.pos.y; float vx = player.phys.vel.x; float vy = player.phys.vel.y; // Calculate distances to walls float dist_side_wall = 4096.0f - std::abs(x); float dist_back_wall = 5120.0f - std::abs(y); // Calculate distance to corner float x1 = 4096.0f - 1152.0f, y1 = 5120.0f, x2 = 4096.0f, y2 = 5120.0f - 1152.0f; float A = std::abs(x) - x1; float B = std::abs(y) - y1; float C = x2 - x1; float D = y2 - y1; float dot = A * C + B * D; float len_sq = C * C + D * D; float param = (len_sq != 0) ? dot / len_sq : -1; float xx = (param < 0) ? x1 : (param > 1) ? x2 : x1 + param * C; float yy = (param < 0) ? y1 : (param > 1) ? y2 : y1 + param * D; float dx = std::abs(x) - xx; float dy = std::abs(y) - yy; float dist_corner = std::sqrt(dx * dx + dy * dy); // Calculate initial velocities towards walls float vel_side_wall = std::abs(vx); float vel_back_wall = std::abs(vy); float vel_corner = (dx * vx + dy * vy) / std::sqrt(dx * dx + dy * dy); // Determine if the car has boost and flip available bool hasBoost = true; bool hasFlip = player.carState.HasFlipOrJump(); // Calculate air times to each wall float time_side_wall = calculateAirTime(dist_side_wall, vel_side_wall, hasBoost, hasFlip); float time_back_wall = calculateAirTime(dist_back_wall, vel_back_wall, hasBoost, hasFlip); float time_corner = calculateAirTime(dist_corner, vel_corner, hasBoost, hasFlip); // Return the minimum time to the closest wall return RS_MIN(RS_MIN(time_side_wall, time_back_wall), time_corner);}
/*
- Assistant
Certainly! Below is the implementation of the
timewallexsrapfunction based on your requirements. This function extrapolates the time and position for the car to reach the nearest wall and renders a line from the car to the predicted landing point on the wall using RLBot's rendering capabilities.Overview
-
Functionality:
- Extrapolation: Predicts the time it will take for the car to reach the closest wall based on its current velocity.
- Position Prediction: Calculates the anticipated landing position on the wall using the extrapolated time.
- Rendering: Draws a line from the car to the predicted landing point and displays the time to reach the wall.
-
Dependencies:
- Utilizes existing functions like
TimeToClosestWallAirandTimeToGround. - Assumes the presence of a renderer (
rlbot::ScopedRenderer) and necessary game state (GameState).
- Utilizes existing functions like
-
Customization:
- Constants like
MIN_SCORE_TIMEandMAX_EXTRAP_Zcan be adjusted based on gameplay needs. - Color schemes can be modified to fit personal preferences or team colors.
- Constants like
Implementation
#include <algorithm> #include <cmath> #include <sstream> #include <vector> #include <iomanip> // Assuming necessary RLBot and RocketSim headers are included // #include "RLBotFramework.hpp" // Placeholder for actual RLBot includes class RLBotBot { public: // Existing member functions float TimeToClosestWallAir(const RLGSC::GameState& gs); float TimeToGround(const RLGSC::GameState & gs); // ... other members ... // New function declaration void TimeWallExtrap(const RLGSC::GameState& gs); }; // Helper constants constexpr float MIN_SCORE_TIME = 0.5f; // Minimum time before considering score constexpr float MAX_EXTRAP_Z = 2000.0f; // Maximum allowed extrapolated Z position constexpr float GRAVITY_Z = -650.0f; // Gravity in Rocket League (uu/s^2) // Implementation of the new function void RLBotBot::TimeWallExtrap(const RLGSC::GameState& gs) { // Check if rendering is enabled and necessary data is available if (!renderTimeToWallExtrapEnabled) return; rlbot::ScopedRenderer renderer("time_wall_extrap_renderer"); // Get the player's current position and velocity const auto& player = gs.players[this->index]; Vec carPos(player.phys.pos.x, player.phys.pos.y, player.phys.pos.z); Vec carVel(player.phys.vel.x, player.phys.vel.y, player.phys.vel.z); // Calculate time to reach the closest wall float timeToWall = TimeToClosestWallAir(gs); // Extrapolate the car's position when it reaches the wall Vec extrapPos = carPos + carVel * timeToWall; extrapPos.z += 0.5f * GRAVITY_Z * timeToWall * timeToWall; // Apply gravity for vertical position // Check if the extrapolated time is valid if (timeToWall <= MIN_SCORE_TIME || extrapPos.z >= MAX_EXTRAP_Z) { return; // Disable rendering if conditions are not met } // Find the closest wall based on current position // Assuming the arena is centered at (0,0) with specific dimensions float arena_length = 4096.0f; // Example arena dimensions float arena_width = 5120.0f; // Determine which wall is closest float dist_neg_x = std::abs(carPos.x + arena_length); float dist_pos_x = std::abs(arena_length - carPos.x); float dist_neg_y = std::abs(carPos.y + arena_width); float dist_pos_y = std::abs(arena_width - carPos.y); // Find the minimum distance to determine the closest wall float min_dist = std::min({ dist_neg_x, dist_pos_x, dist_neg_y, dist_pos_y }); Vec wallNormal(0, 0, 0); // Determine the normal of the closest wall if (min_dist == dist_neg_x) { wallNormal = Vec(1, 0, 0); // Negative X wall } else if (min_dist == dist_pos_x) { wallNormal = Vec(-1, 0, 0); // Positive X wall } else if (min_dist == dist_neg_y) { wallNormal = Vec(0, 1, 0); // Negative Y wall } else { wallNormal = Vec(0, -1, 0); // Positive Y wall } // Project the extrapolated position onto the closest wall Vec wallPoint = extrapPos; if (wallNormal.x != 0) { wallPoint.x = (wallNormal.x > 0) ? -arena_length : arena_length; } if (wallNormal.y != 0) { wallPoint.y = (wallNormal.y > 0) ? -arena_width : arena_width; } // Adjust Z position if needed (e.g., ensure it's above ground) wallPoint.z = std::max(wallPoint.z, 17.01f); // Ground level // Render the line from the car to the predicted wall landing point rlbot::Color renderColor = rlbot::Color(255, 255, 0, 255); // Yellow color rlbot::flat::Vector3 carVector = { static_cast<float>(carPos.x), static_cast<float>(carPos.y), static_cast<float>(carPos.z) }; rlbot::flat::Vector3 wallVector = { static_cast<float>(wallPoint.x), static_cast<float>(wallPoint.y), static_cast<float>(wallPoint.z) }; renderer.DrawLine3D(renderColor, carVector, wallVector); // Render the time to reach the wall near the wall std::stringstream timeSS; timeSS << std::fixed << std::setprecision(2) << timeToWall << "s"; renderer.DrawString3D(timeSS.str(), renderColor, wallVector, 1.0f, 1.0f); // Optionally, render additional information such as extrapolated position std::stringstream posSS; posSS << "Extrap Pos: (" << std::fixed << std::setprecision(2) << wallPoint.x << ", " << wallPoint.y << ", " << wallPoint.z << ")"; renderer.DrawString2D(posSS.str(), renderColor, rlbot::flat::Vector3{ 10, 100, 0 }, 1.5f, 1.5f); } // Example implementation of TimeToClosestWallAir (assuming it's part of RLBotBot) float RLBotBot::TimeToClosestWallAir(const RLGSC::GameState& gs) { constexpr float STEP_INTERVAL = 1.0f / 120.0f; // 120 ticks per second // Get the player's position and velocity const auto& player = gs.players[this->index]; float x = player.phys.pos.x; float y = player.phys.pos.y; float vx = player.phys.vel.x; float vy = player.phys.vel.y; float vz = player.phys.vel.z; // Define arena boundaries (example values) float arena_length = 4096.0f; float arena_width = 5120.0f; // Calculate time to each wall based on current velocity float time_neg_x = (vx < 0) ? (std::abs(x + arena_length) / std::abs(vx)) : INFINITY; float time_pos_x = (vx > 0) ? (std::abs(arena_length - x) / std::abs(vx)) : INFINITY; float time_neg_y = (vy < 0) ? (std::abs(y + arena_width) / std::abs(vy)) : INFINITY; float time_pos_y = (vy > 0) ? (std::abs(arena_width - y) / std::abs(vy)) : INFINITY; // Find the minimum positive time float min_time = std::min({ time_neg_x, time_pos_x, time_neg_y, time_pos_y }); return min_time; } // Placeholder for Vec class (assuming it's defined elsewhere) struct Vec { float x, y, z; Vec() : x(0), y(0), z(0) {} Vec(float _x, float _y, float _z) : x(_x), y(_y), z(_z) {} Vec operator*(float scalar) const { return Vec(x * scalar, y * scalar, z * scalar); } Vec operator+(const Vec& other) const { return Vec(x + other.x, y + other.y, z + other.z); } }; // Placeholder for render flags (assuming these are defined elsewhere) bool renderTimeToWallExtrapEnabled = true; // Placeholder for RLBot::ScopedRenderer and RLBot::Color (assuming these are defined in RLBot) namespace rlbot { struct Color { uint8_t r, g, b, a; Color(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha) : r(red), g(green), b(blue), a(alpha) {} }; struct flat { struct Vector3 { float x, y, z; }; }; class ScopedRenderer { public: ScopedRenderer(const char* name) { // Initialize rendering for the given name/context } void DrawLine3D(const Color& color, const flat::Vector3& start, const flat::Vector3& end) { // Implementation to draw a 3D line } void DrawString3D(const std::string& text, const Color& color, const flat::Vector3& position, float scaleX, float scaleY) { // Implementation to draw a 3D string } void DrawString2D(const std::string& text, const Color& color, const flat::Vector3& position, float scaleX, float scaleY) { // Implementation to draw a 2D string } }; }Detailed Explanation
-
Function
TimeWallExtrap:- Rendering Check: Ensures that rendering for wall extrapolation is enabled before proceeding.
- Initialization: Creates a
ScopedRendererinstance for drawing. - Current State: Retrieves the car's current position (
carPos) and velocity (carVel). - Time Calculation: Uses the
TimeToClosestWallAirfunction to determine the time (timeToWall) it will take to reach the closest wall. - Position Extrapolation: Calculates the anticipated position (
extrapPos) on the wall aftertimeToWallseconds, considering both horizontal movement and vertical gravity. - Validity Check: Ensures that the extrapolated time is above a minimum threshold and that the extrapolated Z position doesn't exceed a maximum value.
- Closest Wall Determination: Identifies which wall (negative X, positive X, negative Y, positive Y) is the closest based on the car's current position.
- Wall Point Calculation: Projects the extrapolated position onto the identified closest wall to get
wallPoint. - Rendering:
- Line: Draws a 3D line from the car's current position to
wallPoint. - Time Annotation: Displays the time to reach the wall near the wall's position.
- Position Annotation: Optionally displays the extrapolated position coordinates for debugging or informational purposes.
- Line: Draws a 3D line from the car's current position to
-
Function
TimeToClosestWallAir:- Purpose: Calculates the time it will take for the car to reach the closest wall based on its current velocity.
- Implementation:
- Determines the distance to each wall (negative X, positive X, negative Y, positive Y).
- Calculates the time to reach each wall by dividing the distance by the respective velocity component.
- Returns the minimum positive time among all walls.
-
Helper Structures and Placeholders:
VecStructure: Represents a 3D vector with basic arithmetic operations.rlbot::Colorandrlbot::flat::Vector3: Represent color and 3D vector structures used for rendering.rlbot::ScopedRenderer: Manages rendering within a specific context or scope.- Render Flags:
renderTimeToWallExtrapEnabledis a placeholder flag to toggle rendering.
Integration Steps
-
Add the Function to Your Bot Class:
- Ensure that the
TimeWallExtrapfunction is added to your bot's class (RLBotBotin this case). - Verify that all dependencies and helper functions (like
TimeToClosestWallAir) are correctly implemented.
- Ensure that the
-
Enable Rendering:
- Set the
renderTimeToWallExtrapEnabledflag totrueto enable rendering. - Integrate this function into your main loop or update cycle to ensure it gets called every tick/frame.
- Set the
-
Customize as Needed:
- Adjust constants like
MIN_SCORE_TIME,MAX_EXTRAP_Z, and arena dimensions based on the specific game mode or arena specifications. - Modify the color schemes or add additional rendering features as desired.
- Adjust constants like
-
Testing:
- Test the function in various scenarios to ensure accurate predictions.
- Debug and refine the extrapolation logic based on observed behavior during gameplay.
Conclusion
The
timewallexsrapfunction provides a visual aid by predicting where and when the car will reach the nearest wall, enhancing situational awareness and decision-making. By integrating this function into your RLBot, you can improve your bot's ability to anticipate and react to in-game dynamics effectively. -