How would I make planets seem further than they are

Help and Feedback Scripting Support
, , , ,
#16

hmmm, I aint really sure, I think some kind of illusion would be need for it, since you cant scale the planet realisticly. So the only thing that comes to my mind is to make the player’s ship much much slower when this close to the planet, so much that it does the effect of enormous planet. I dont have any more idea though

#17

Oh ok, I appreciate the help though! Hopefully, someone else comes along with some ideas.

#18

What i’d suggest is moving the ship back every time it travels a certain distance.
Of course for this to look seamless you need to make the random parts around in the space replicate in the beginning and in the end, kinda like animating a character walk

2 Likes
#19

I like this idea, the only problem is how to make it look seamless and smooth from the pov of the player

1 Like
#20

Honestly there’s no perfect answer except making huge planets.

You could get close to what you want using scaling and other stuff but it’d be far from realism and probably also mess the multiplayer system.

#21

If I could, I would, but because of floating point error, the game starts acting weird at around 100k studs, which is ideally how big the planets would be.

So full-size, properly spaced planets is a no.

If only Roblox decided to actually add seamless teleports, I could simply just teleport the player to a new place when floating point error starts to occur

#22

Although it wont be seamless, you could try a custom tp screen. You can try to have all parts get cloned into a viewport frame (if that wont lag, ive barely used vps before) which is set to the teleport gui.

#23

It is a good idea, but because viewport frames are rubbish, the quality would look like poo, and it would take a long time to teleport, which kinda ruins the whole ‘immersive experience’ thing

#24

Yep theres basically no way. Best bet is to make rockets move slower.

#25

Yeah, I did try to scale the ships down by 16x but that just made floating point error occur earlier, because the engine had to work with smaller decimal values.

I know that it is possible, as games such as Elite Dangerous, Star Citizen and No Man’s Sky all achieved it, but they obviously use way more advanced game engines, which Roblox just can’t compete with.

1 Like
#26

It is possible, but NOT on roblox, so thats why it is impossible for your case.

1 Like
#27

Yep. I will continue trying to do it though. I quite like the idea of moving the ship back seamlessly when it gets too far…

1 Like
#28

It’s all about perspective. You don’t need to make the player travel thousands of thousands of studs, rather you just need to scale everything (except the player) down. While it is true you might run into precision issues as you subdivide, remember that the size of the moon is smaller than our thumb at arm’s length. An image that spans millions of miles is shrunk to something smaller than 144x144 pixels.

#29

You could shrink them as you move away, so you don’t need to move them as far as getting that distance floating point error. This is done with a script that calculates the distance from the player constantly and apply that to object size. So it’s a combo of moving it and resizing it.

#30

this is the original solution that @Sarlex0 suggested, and I explained why it wouldn’t work

#31

If I understand correctly, you mean to keep the player in the same spot, and then grow/shrink the planets as the player ‘moves’. I have thought about this idea before, but I’m not really sure how to make it look good with multiplayer.

#32

You just would hide the players and represent their general position as a “warp point” and then the player has the option to tp to them. “tping” is just reordering the scene by moving the planets to be relative to this position (remember not roblox position, but a virtual position in “space”) and then you unhide the given player. It will work out because their velocities will now be relative as it’s assumed that they aren’t traveling hyperfast. No Mans Sky takes this same approach with its hyperspeed mode feature.

#33

Hello, I see your problem and It is very hard to solve. However, I will try my best to help you! the challenge you’re facing is essentially how to handle large spaces and distances in a way that Roblox (or any game engine) can handle, while also keeping the gameplay and visuals smooth and immersive.

For your specific problem, you might consider using “level of detail” (LOD) techniques not just for the visual aspects (mesh scaling), but also for the positional aspects. This means you would dynamically adjust the actual distances between the spaceship and the planets based on various factors such as speed, direction, and whether or not the spaceship is in subspace.

One potential solution to avoid sudden jumps of planets could be interpolating their positions between the normal and subspace states. If the transition between normal and subspace isn’t instantaneous but happens over a certain duration (say, a few seconds), you could smoothly move the planets from their position relative to the spaceship back to their original positions. This way, the transition wouldn’t be jarring but would appear as a natural part of entering subspace. Similarly, when exiting subspace, you could calculate the spaceship’s position relative to the planets and then smoothly move them away to create the illusion of the spaceship slowing down.

-- ...
local transitionDuration = 3 -- time it takes to enter/exit subspace
local transitionStart = 0 -- time when last transition started
local transitioning = false -- whether we're currently transitioning
local previousSubspaceState = shipValues.subspace

game:GetService("RunService").RenderStepped:connect(function(step)
    local currentTime = os.clock()
    
    if shipValues.subspace ~= previousSubspaceState then
        transitioning = true
        transitionStart = currentTime
    end

    for i, v in pairs(Bodies) do
        -- ...

        if transitioning then
            local transitionProgress = math.min(1, (currentTime - transitionStart) / transitionDuration)
            if not shipValues.subspace then
                transitionProgress = 1 - transitionProgress -- reverse if exiting subspace
            end

            local normalPosition = workspace.CurrentCamera.CoordinateFrame.p + (v.OriginalPositionConst.Value - workspace.CurrentCamera.CoordinateFrame.p).unit * distanceConstant
            local subspacePosition = v.OriginalPositionConst.Value

            v.CFrame = CFrame.new(normalPosition:Lerp(subspacePosition, transitionProgress))

            -- handle mesh scaling similarly
        elseif -- ... rest of your code
        end
    end

    if transitioning and currentTime - transitionStart >= transitionDuration then
        transitioning = false
    end

    previousSubspaceState = shipValues.subspace
end)

This code essentially interpolates the position of each planet between its position in normal space and its position in subspace over the duration of transitionDuration. This should create a smooth transition effect where the planets appear to move naturally when entering and exiting subspace. You’d do something similar for the mesh scaling.

Remember, you may need to adjust it to fit your specific game’s mechanics and style. You’ll also want to thoroughly test it to ensure it works as expected and provides a good player experience.

1 Like
#34

You can use streaming enabled and make it so that certain radius from the player stuff will appear or disappear depending on how far an object is to the player, it also helps prevent lag for huge games.

#35

Wow! I’m incredibly grateful for this idea, and I will definitely utilize it.
One question though: do you have any idea how I would sort out if the player goes past the planet’s OriginalPositionConst? Because if the player goes past it, or goes inside it, it will look like the planet just disappeared, which is obviously not good.

Either way, thank you so much for this response, I really appreciate it.

1 Like