What do you think about creating an open world / MMO in PlayCanvas?

Hi! Tell me, please, what do you think about creating an open world / MMO in PlayCanvas? For example, creating an MMORPG primarily in space, like, for starters, a simpler version of EVE Online?

As I understand it, a similar project can be implemented on PlayCanvas. What do you think? What approaches are better to use in this case?

1. For example, the “Move the world, not the character” approach? So that the character (spaceship or unit that will leave the spaceship at the station) is always in zero coordinates, and so for all players, and only the server knows the absolute coordinates, which translates the local coordinates of individual players into absolute ones and back.

I think this approach will reduce the load on calculating coordinates with gigantic values. As I understand it, in this case there are no miracles and for PlayCanvas / JS, as well as for Godot / GDScript, it is more difficult to operate with numbers in the billions compared to operating with numbers in the thousands, right?

2. I can create virtual chunks, that is, divide the galaxy into star systems, and divide the star systems into separate cubes-chunks. But taking into account, if we apply the approach that I described above “Move the world, not the character”, this, as I understand it, is not so important for the client part, that is, there is no need to create a separate scene for each chunk, because each player will always be in one scene of space, into which other objects will be loaded and unloaded.

But creating chunks will be useful for the server part, so that the server does not use billions of coordinate values, the server can issue coordinates inside chunks.

Please tell me what you think about creating chunks, is it justified for an open world or are there any alternatives?

3. To prevent cheating, it turns out that we need to use the approach “Actions are transmitted to the server, not numbers”. That is, from the client part it is transmitted, for example, where to what coordinates the user wants to fly, for example, he clicked the mouse to some part of space. Only a certain vector is transmitted to the server, along which the user wants to fly, but the server determines what the exact coordinates will be and at what speed the ship can fly to these coordinates.

Well, here, of course, some values ​​can be transmitted from the client to the server, for example, at what speed the player wants to fly, but the server will check whether such speed parameters are available for this ship. But in this case, so that the client does not wait a long time for a response from the server, it is necessary to implement the “Prediction & Rewinding” approach.

Tell me, please, are there any recommendations and any libraries for implementing “Prediction & Rewinding” in PlayCanvas?

4. Apparently, distant objects that are far from the player do not need to be loaded into the scene. Apparently, it is necessary to create a 2D sphere in the background (although this sounds strange), in general, create a 2D layer in the background, on which to display marks of distant space objects, which in fact will not be there, only marks will be shown. And when the player approaches this object, the object will begin to appear, gradually increasing its level of detail.

I have not yet understood how Level of Detail is implemented in PlawCanvas. I have not yet found any information about this in the documentation. If anyone has information on this topic, please provide a link.

So far I have only found an old topic, from which I understood that the old implementation does not work [SOLVED] Level of Details System

We have a project called Universo MMOOMM, we are researching the creation of this project on different technologies. We have been testing the implementation on Godot Engine for a long time, then we started testing the implementation based on The Mirror project, the developers of which created their own platform for collaboration on Godot, but now they have abandoned Godot and are making a new version of The Mirror on a JS engine, I will not say which one, they themselves will make an announcement soon :grinning:

We are currently researching the possibility of creating a project based on PlayCanvas, if anyone is interested, here is the most general information about the project, more documentation will be created soon Make a general description of MVP for Universo Platformo / Universo MMOOMM · Issue #11 · teknokomo/universo-platformo · GitHub

That’s why I am here, reading everything and will be here for a long time, I will be glad to meet the permanent inhabitants of this forum, I greet everyone! :slightly_smiling_face:

Hi @Vladimir_Levadnij ! It’s nice to see another person getting into the exploration space games. I am working on a game similar to EVE online, but it will be low Polly and more focused on the stories of individual planets and the players past. If you need any help or just want to compare notes, reach out!

1 Like

Hi. Nice to meet you, I’ll definitely write to you :slightly_smiling_face:

Here is a video with a test implementation of our project on Godot 3 / 4 (in Russian)

1 Like

Some thoughts. This is definitely doable in PlayCanvas, but specifics:

  1. As you mentioned, this limitation and the required solution would be similar, regardless of what engine you use. They all use float32 bit numbers to represent positions, and so this is estimated precision based on how large the value (distance from center) the number stores (Chat GPT generated):
  • At 10 meters: Precision ≈ 0.000000596 meters (596 nanometers)
  • At 100 meters: Precision ≈ 0.00000596 meters (5.96 micrometers)
  • At 1,000 meters: Precision ≈ 0.0000596 meters (59.6 micrometers)
  • At 10,000 meters: Precision ≈ 0.000596 meters (596 micrometers)
  • At 100,000 meters: Precision ≈ 0.00596 meters (5.96 millimeters)
  • At 1,000,000 meters: Precision ≈ 0.0596 meters (5.96 centimeters)
  • At 10,000,000 meters: Precision ≈ 0.596 meters (59.6 centimeters)
  • At 100,000,000 meters: Precision ≈ 5.96 meters
  • At 1,000,000,000 meters: Precision ≈ 59.6 meters

So realistically, you could probably depend on 10.000 meters perhaps, after that the object shake will become visible. Easy to test in the engine - just move a cube and a camera far away and slowly move the cube.

For anything larger, you’d need some form of local center, and make everything relative to it. Ideally don’t adjust everything every frame, but only if you need to move the center by 10.000 meters or so.

1 Like
  1. Sounds about right, to avoid cheating, it all needs to be server authoritative. You can transmit any data from the client you want, but they all need to be validated by the server and sent back for execution. The client can start executing those before it receives the response from the server, but if the server corrects some values, the client will need to adjust to it.
    Definitely store things like currently, ship health and similar on server, and the server needs to confirm all those to the client.
    But note that if the client is cheating, it’s important only that other connected players are handle correctly, for example the cheating player cannot cheat kill them. If the cheater has visually inconsistent experience (for example it seems the enemy explodes, even though server later rejects it), that is ok, as only the cheater had bad experience, and the actual stats are simulated / confirmed on server and no affected by cheating.
1 Like
  1. PlayCanvas does not have built in LOD system, but what you describe here is not a LOD system, it’s a system where you load good quality assets for the local scene, and load some billboards / textures for them for the distance objects.

If you need LOD for ships, you’d need to load all of them, and create for example a script that will based on the distance enable / disable child entities that represent individual LOD versions.

1 Like

One thing to think about is if you want quality over quantity, a few really good planets, or quantity over quality, a lot of less good planets. And maybe play around with both! Things like pre-determined loot boxes for planets that can be easily modified will be very helpfull.

1 Like

Hi. Thanks for your answer. I’ll think about all this information while I have the first additional questions.

Since you didn’t mention it, do I understand correctly that PlayCanvas does not support 64-bit coordinates (Large world coordinates)?

Yes, at the beginning of point 4 I talked about one topic, and then moved on to the question specifically about LOD. Did I understand correctly from your answer that PlayCanvas does not currently implement automatic LOD, that is, functionality with pre-defined settings and characteristics for the standard 4 levels of detail, and especially there is no automatic rebuilding of the Mesh depending on the distance, as it is implemented, for example, in Godot 4?

Here are short examples of what I’m asking about

Thank you for your recommendations. Our plan is to go from simple to complex, at the beginning all actions will take place only in space and locations of space stations. Moreover, at first the user will be able to control only a spaceship, and his character will not be able to leave it, which is due to our Lore. But then we will gradually add the ability to walk around the station, and then we will add landing on planets.

We will start with a small number of planets, then their number will increase.

1 Like

Tell me please, do you recommend any Custom GPT for better help with PlayCanvas? For example, I found these options through search, can you recommend any of these options? Is your official GPT in this list?

That is correct, there is no support for this and this is something you’d need to handle on your side. This is most likely similar to majority of other engines too.

1 Like

That is correct, there is no automatic LOD nor mesh simplification supported, you’d need to handle it yourself.

1 Like