open-project-1 VS guid-based-reference

I wish they'd go the way of Epic and make an actual game with their engine. They've tried a few times and given up each time. It's pretty embarrassing when they've done things like released a fully featured multiplayer FPS demo that doesn't actually work out of the box and has a custom editor tool manager, custom scene loader, and custom networking layer that were never merged into mainline unity. Meanwhile they still have no official stable networking module. The old functional one was sunset and the new ones are still in beta.

https://github.com/Unity-Technologies/FPSSample

> This project is based on Unity 2018.3

> NOTE: Due to a bug in Unity 2018.3, you have to take the following step right after the initial import: 1 Search for Firstperson_Projection in the Project search field. Select the 4 shaders, right click and reimport them. 2 If you have script compile errors related to entities, you need to remove and re-install the entities package.

> One day soon we will remove this note and there will be cake.

> Once the editor is ready, open the Project Tools Window by navigating to FPS Sample > Windows > Project tools.

> Keep this window docked as you will use it a lot. From here you can open the levels, build assetbundles and build standalone players.

https://github.com/UnityTechnologies/open-project-1

> Note: As of December 2021, Open Projects and Chop Chop are not in development anymore.

Unity has some official open source games https://github.com/UnityTechnologies Chop Chop is one of the best. https://github.com/UnityTechnologies/open-project-1

Additive scenes are great but a bit more advanced. Moving your player to the right location after changing scenes is something you will need to solve regardless of using a single scene or additive scene structure. That said for the "transfer" you can have your player in its own player scene (another additive scene) or the base scene and just move the position. Instead of trying to have a reference to everything you should be using events, it is more performant, and there is no need to have a reference there for you do not need to drag and drop between scenes. Here is a project where you can reference a scriptable object event system that has no issues working across scenes: https://github.com/UnityTechnologies/open-project-1/tree/main/UOP1_Project/Assets/Scripts/Events

The fantastic UOP1 project has great examples of this using scriptable objects as event channels to communicate between a persistent managers scene and the current gameplay scene.

For starters, it might be worth checking out the Scriptable Object demo project and the videos on youtube that deal with it. https://github.com/UnityTechnologies/open-project-1

And for anyone else looking for real-world examples: this repo is interesting: https://github.com/UnityTechnologies/open-project-1

I didn't use any particular tutorial for my save system but Unity actually developed a community based Open Project a year or so ago. Their save system is probably a good reference to get something started. They have a few other systems implemented in that project as well that you might find useful, although personally I didn't love how much they used scriptableobjects for their event system.

Hi, so apparently some people (including me) after downloading zip containing unity open project 1 from it's github page had problems with unpacking it. The (one of the possible) solution(s) was downloading it using github desktop - which is quite unpractical since if you lost internet connection during the process you have to re - download the entire project. So if you want to download it, you can use this google drive link: https://drive.google.com/drive/folders/1o5Db5fI9HHD3T8wv2C7PlDV1pu8unma1?usp=sharing

When you download the Unity Hub, it will have a learn tab. Selecting that you can download sample games that will show how Unity works. Besides that Unity has an Opensource project this was canceled after the community dried up around it.

What might work well for you is taking apart one of the example projects, add new features or just mess with existing systems. For Unity there's https://github.com/UnityTechnologies/open-project-1 for example.

This has worked for me so far. I have my save data saved in JSON format in a text file. Your gameobjects/player objects need to have unique ID. Unity has a solution to this on their GitHub. If this isn't an online game, have a Savemanager singleton. when the game starts, the Savemanager will read all of the savedata from your text file into memory (dictionary with GUID as key). Each component that needs to save data can implement a Saveable interface. Each component will have a reference to the central gameobject GUID. On awake each component can request to load the specific type of save data it needs from the Savemanager, if none exists the manager will return a new savedata instance for the component. Each component that needs to be saved can also request that they be added to a central list in the Savemanager. When it comes time to save all your data, you can call a Save method on each component in your list that implements the Saveable interface.

You can serialize the data and save and load from a file when your game starts. If you're only saving the mutable data then the save file should be fairly small and this would load quickly. You can load your save data into a static class when you first load up the game and then keep all data that's changed during the play session in a runtime dictionary for quick access between scenes. Your save data for each object will need some sort of unique GUID. For scene objects you can use Guid reference which automatically creates a unique guid when you add the component to a scene object. For gameobjects created at runtime you will need to save additional info that includes the original prefab it was instantiated from, transform position, etc. Using addressables you can load your prefab at runtime based on it's address/name/custom guid even and instantiate a copy and load the save data.

Give each gameobject in your scene a unique guid if you haven't. Unity has a guid solution on GitHub, it's as simple as adding a component to your scene gameobject (unity guid component). Make a non-monobehavior data class that would save all of the state information you need in a serializable form. Then come save time use JSON and write out your custom data class with the guid for the particular scene object to a text file. When you load your save data at runtime, populate a dictionary with the guid as a key for quick access to your save data.

"GitHub - Unity-Technologies/guid-based-reference: A component for giving Game Objects a GUID and a class to create references to objects in any Scene by GUID" https://github.com/Unity-Technologies/guid-based-reference