Is it possible to setup user made levels (like in Mario Maker)?

[JustYourAverageJosh]

Hi, have a Level editor for my game and would like to allow users to upload their levels online for others to see and download them.
Possibly, users would be able to rate levels, and the levels would have stats (amount of people that have beaten it for example). Similar to Mario Maker's user levels but simpler.

It looks like I can use Firestore to do this? So do I have this right:
-Connect to a collection
-Download all documents and have my game display them (Level name, rating, stats)
-If the user wants to upload a new Level, get a dictionary of it's data and Add document to the collection

Not sure of:
-How do I get the document Ids when I connect to a collection?
-EDIT document (to update stats and ratings)
-Delete document (user wants to delete their level)
↳Authenticate that the user owns that level and can delete it. Maybe implemented by creating a key when uploading and matching it when trying to delete.

Thank you for any help! and thank you for your awesome work on this!

[fenix-hub]

Hi @JustYourAverageJosh
Of course you can achieve this with our addon. I'll give you some tips to guide you for the process, but it will need to implement some custom logic in your project to manage levels, ids and users.

First thing first, we will always make reference to the wiki so everything I'm mentioning is not something completely new and you can always check it out by yourself.

• To authenticate a user, just follow one of the explenations given here.
  When you sign-up a new user, Firebase will give it a randomized UUID to identify it, other than simple email. You can retrieve this both in the callback of signup_successful and login_successful signals, which will return a dictionary containing it (its key name is localid), or after a sign-up/sign-in it can be obtained calling the Firebase.Auth.get_user_data() function, that will return a complete FirebaseUserData upon receiving the user_received(firebase_user_data) signal.
  Everything is documented here.
  Having the localid saved in your instance could be very helpful to identify everything a user adds to a Firestore collection, because you will be able to save it in a Firebase Document itself.
  For instance, when you crate a document (with your own structure) to save a user made level, you can give that an additional field like "owner" : user_id, so when you list through all your documents you will be able to identify those ones created by a specific owner.
  Another way to achieve this would be to create a document with its id equals to the user uuid, but since you cannot store multiple documents with the same id, a document will identify all the levels created by that user, which you can store (for example) in an array of dictionaries, or as an additional collection of levels.
  It's up to you to chose your own logic. Here's a metacode of the ones suggested by me

method 1 ...
firestore/user_levels/ (collection)
└ level_id_1 (document)
   { owner : user_id, level_info : ...   }
└ level_id_2 (document)
  { owner : another_user_id, level_info : ... }

method 2. ...
firestore/users/ (collection)
└ user_id_randomstring (document)
└└ levels (collection)
└└└ level_1  (document)
         { level_info : ... }
└└└ level_2 (document)
         { level_info : ... }
└ another_user_id_randomistring (document)
└└ levels (collection)
      { level_info : ... }
└└└ level_1 (document)
        { level_info : ... }
└└└ level_2 (document)
        { level_info : ... }

• To update a document, the process is identical to adding a new one. It is documented here. The only difference is that, instead of calling the .add() function, you will call the .update() function, always using the same document ID and document structure. To update just a field, make sure to reference the right collection path and the right document id - thus you will have to specify only those keys you want to update, instead of rewriting the whole document structure.

• To delete a document, just call the .delete(DOCUMENT_ID) function.

• Now, this is the part where everything depends on the logic you want to implement.
  I already guided you through a process that could let you and your players identify their levels through their UUID (of course you can use whataver identification method you want, as long as it is stored somewhere).
  To let user update only those documents created by them, you can do two different things:

1. let them have a list of all those documents that are identified by their ids: in this way, even though they potentially have access to the whole collection, they will be only able to see those documents filtered by their id. This is a client-side option
2. write your own rules in Firestore. For this I'm not able to give you useful information other than the documentation itself, but basically you want to give to firebase some rules on how to manage access to Firestore with a server-side logic.

While the first method is much easier to implement, since you only have to get all documents in a collection in godot, and eventually just filter those ones with the correct ids, the second one is the most secure one, since unauthenticated users and those users that don't follow Firestore rules will never be able to delete any document they are not allowed to.
Of course a combination of the two methods would be the best option.

I hope I helped you a little bit with your project. While I'm not able to help you out with futher suggestions in project logics (since it would require time), we can always help you to understand our addon if anything is missing. Thank you.

[JustYourAverageJosh]

Thank you so much for the info! I will go through and try to get this setup!

[WolfgangSenff]

We actually have a really nice control for 2D that does this, specifically for TileMaps. It would be easy to study it and extend it if you want to. Feel free to take a look, and reuse any code you find (or use the control directly if it helps):
https://github.com/GodotNuts/GodotFirebase-UI/tree/main/firebase-ui/tilemaps/firestore_tilemap