SS14 and RobustToolbox are split into several different projects. The main ones you’ll care about are the
Server projects. Other projects are for smaller things like integration tests, benchmarks, or database-specific code.
Server are each packaged into different ‘assemblies’, which is basically .NET talk for executables or shared libraries.
Client project in both Robust and SS14 contains client-specific code, like UI. This assembly is only sent to the client, the person actually playing the game.
Server project contains server-specific code that no specific client should be able to interact with, like atmospherics or botany. This assembly is only located on the game server.
Shared project contains shared code that can be used by the client or the server. This assembly is not executable, and it relies on the client or server to call functions in it or use data classes located within it. The purpose of shared is to allow for network prediction (where the client and server run the same code, to make things smoother) as well as to specify shared data classes, like network messages, so that the client and server can speak to eachother effectively.
Shared code is only allowed to access other shared code, not client or server code. However, client and server code are always allowed to access shared code.
In SS13, all game code is randomly thrown around under
code/, and instead of grouping by relevance to systems, is grouped by abstract things like whether the file is a list of constants or whether a file pertains to a master controller subsystem. In SS14, we first delineate by which game system we’re working with (atmos/botany/buckling, etc) and then by the classes needed for it, which is much easier for anyone actually trying to work within a single system.
Content.Server all follow this organization. RobustToolbox’s equivalents do not currently, but will in the future.
- All game code will be organized in folders directly under Content.Client/Shared/Server etc.
- Game code folders are split into Components, EntitySystems, Visualizers, UI, Prototypes, etc
- If there would only be one file in a folder, it doesn’t need a folder (unless that file would go directly into the project’s top directory, which is undesirable).
- Do not use ‘misc’ folders; misc folders are hell for organization and its completely arbitrary what goes inside them and what doesn’t. You can encapsulate smaller game systems inside larger game systems if it unambiguously makes sense (Atmos -> Piping), but don’t just slap all the smaller game systems into a misc folder.
This structure should hopefully be very clear after working with it or seeing examples.
A real example, under
- Atmos is a fairly large game system. It has many folders, and many files that do not need to go in these folders.
- Botany is a smaller game system. However, it only has one folder for Components since that’s all that’s really there.
- ItemCabinets are a very small game system. They just have a component and EntitySystem, and thus do not need folders for each.
The resources folder is another area where we hope to improve over the organization structure of SS13 codebases.
New folders should usually only be created for a new parent type. If you find something that can be pulled out into a parent prototype, it should go in its own folder.
Parent prototypes should be contained in
base.yml in this folder, while other prototypes go in a different file.
Not everywhere is organized like this; however, the
Structures folder is.
This was chosen to make the directory structure mirror the prototype inheritance tree, making it obvious where to place new prototypes as well as being fairly unambiguous when choosing to create new folders.