I'm planning to train a bot in the rocket league hoops mode, it's the same as standard mode except the ball radius is slightly larger, the arena is smaller and the goals are baskets with a hole shaped like half pills surrounded by a rim and slope. . The issue is that my goal related rewards no longer work in hoops because of the different goal designs. In regular mode the goal is just a hole in a wall, but now in hoops it's a basket. So I can't just target a x,y coordinate, I now need to target a x,y,z target from above. Since the ball needs to fall in to the net it makes things a lot more complicated. The sides of the basket are solid, so I can't just aim for the x,y,z coordinate because there might be a basketwall in the way. I somehow need to encourage the ball to parabola from bellow the goal and go straight when above the goal height, I think that makes sense. This is my current ball to goal reward for standard mode:
class BallTowardsGoalReward : public RewardFunction {
public:
    BallTowardsGoalReward(bool ownGoal = false, float angleThreshold = 0.6f) 
        : ownGoal(ownGoal), angleThreshold(angleThreshold) {}

    virtual void Reset(const GameState& initial_state) override {
        // No reset behavior needed
    }

    virtual float GetReward(const PlayerData& player, const GameState& state, const Action& prevAction) override {
        bool targetOrangeGoal = player.team == Team::BLUE;
        if (ownGoal) targetOrangeGoal = !targetOrangeGoal;

        // Define goal dimensions
        const float GOAL_WIDTH = 892.755f;
        const float GOAL_HEIGHT = 642.775f;
        float goalY = CommonValues::BACK_WALL_Y * (targetOrangeGoal ? 1 : -1);

        float distToScoring = std::abs(state.ball.pos.y - goalY);
        float timeToScoring = distToScoring / (std::abs(state.ball.vel.y) + 1e-6f);

        Vec gravityDrop = Vec(0, 0, CommonValues::GRAVITY_Z) * std::pow(timeToScoring, 2) * 0.5f;
        Vec extrapBallPos = state.ball.pos + state.ball.vel * timeToScoring + gravityDrop;
        extrapBallPos.z = std::max(extrapBallPos.z, CommonValues::BALL_RADIUS);

        Vec targetPos = {
            std::clamp(extrapBallPos.x, -GOAL_WIDTH, GOAL_WIDTH),
            goalY,
            std::clamp(extrapBallPos.z, 0.0f, GOAL_HEIGHT)
        };

        // Calculate direction vectors
        Vec ballDirToGoal = (targetPos - state.ball.pos).Normalized();
        Vec ballHeadingDir = state.ball.vel.Normalized();

        // Calculate dot product
        float unAlign = ballDirToGoal.Dist(ballHeadingDir);

        float reward = 1.0f - (unAlign / angleThreshold);
        reward = std::max(reward, 0.0f) * state.ball.vel.Length() / CommonValues::BALL_MAX_SPEED;

        return reward;
    }

private:
    bool ownGoal;
    float angleThreshold;
};

As you can see it wouldn't work for hoops . First of all the dimensions and position is completely different. The height of the ball is important for hoops as well. The shape of the goal in hoops is a half pill shape composed by a rectangle of R*2 width and 613.3 2D height plus a semicircle of radius R = 659.8331. The goal scored z threshold is 270 ( 366.381 + ball radius). The goal height (top part of the rim) is 392 , so 25.619 higher difference from the real goal threshold(392- 366.381 = 25.619).

Here are the names I gave all these variables:
	namespace CommonValues {
		// Could just use RocketSim's RLConst but I'll just copy to stay faithful

		constexpr float
			SIDE_WALL_X = (8900 / 3.f),
			BACK_WALL_Y = 3581,
			CEILING_Z = 1820,
			BACK_NET_Y = 3581,//same as backwall
			MID_NET_Y = 2994, //based on the max y point where ball can fit 2406.18

			GOAL_HEIGHT = 392, //rim height,  real goal height is is 366.381
			GOAL_RADIUS = 659.8331, //also width/2
			GOAL_WIDTH = 1319.6662, // width of imaginary rectangle and base of semicircle
			GOAL_LENGTH = 2406.18, //Max y distance from wall where standard ball fits
			GOAL_RH = 613.3, //height of imaginary rectangle that forms the half pill

			GOAL_LENGTH_REAL = 1273.74, //really height of inner goal, 0.1x ball could fit

			GRAVITY_Z = -650.0,
			BOOST_CONSUMED_PER_SECOND = 100.0 / 3.0;

		constexpr Vec
			ORANGE_GOAL_CENTER = Vec( 0, MID_NET_Y, 366.381), //ball needs to cross 270
			BLUE_GOAL_CENTER = Vec( 0, -MID_NET_Y, 366.381),

			// Often more useful than center
			ORANGE_GOAL_BACK = Vec( 0, MID_NET_Y, 0 ),
			BLUE_GOAL_BACK = Vec( 0, -MID_NET_Y, 0);

		constexpr float
			BALL_RADIUS = 96.3831, //hoops ball radius

			BALL_MAX_SPEED = 6000,
			CAR_MAX_SPEED = 2300,
			SUPERSONIC_THRESHOLD = 2200,
			CAR_MAX_ANG_VEL = 5.5,

			BLUE_TEAM = 0,
			ORANGE_TEAM = 1,
			NUM_ACTIONS = 8;


There seems to be a lot more to consider when the goal is a basket since the target is raised above the ground and impeded by the sides of the basket. If the ball speed towards the goal is not fast enough it could end up lower than the basket and not go in. If the angle is to shallow when bellow goal height it might not make it over the basket, don't really want to reward it for slamming the ball into the side of the basket but still need to encourage it to move the ball towards the net. The ball could hit the backwall and bounce or roll into  the net.

Can you figure out all the challenges involved in creating a ball to goal reward in hoops game mode. Create a reward that takes into account as much of this as possible.