This is the game engine used to create the Khanat MMORPG. This is a free engine with an 3D game client, which is rendered graphically by the “NeL” engine.

inlinetoc

The “Ryzom Core” is based on a server and client architecture. The clients are installed by the players on their own computers, and the server designates all the services that makes it possible for a working client connection.

It is composed of several elements:

• Executable files(the programs themselves).
• Configuration files.
• Data files.

The executable files are of two types:

• 1: First, there is the standard client(which allows access to the game).
• 2: Secondly, an debug client with additional tools for deployment of the game.

Configuration files are small(text/xml) files that contain display, access, and other parameters. They can be edited from the game client(or manually) with a text editor. This is where you specify, for example: the addresses of the main server..

Then there is the game data, namely: the graphic data, sound, localization(translations) and gameplay. They are generally compiled in a .bnp file type format, which are nothing but a somewhat special archive compression(like a kind of .tar file). They are usually found in the /data subdirectory, but the client will look for them in several directories, and in a certain order(according to the indications specified during the compilation of the client). The client overwrites the files with identical names by the last version read. By default it reads the /user directory(for you to try out updates/changes). It is not necessary to archive the data in a .bnp, the files work very well in an un-compressed state.. as long as they respect the standard formats accepted by the game.

The graphics files include types of: .shape, .ig, and .dds. The first two are 3D files used by the game rendering engine(NeL), and the third is a format optimized for rendering games in 3D(one can also use .png - or targa).

Then there are a lot of gameplay files and these are the Data Sheets and Primitives(the first being in “binarized” form to avoid exploits). These are the basic elements(building blocks) for building the world and defining everything. There is an script that makes a kind of compilatated version of the Data Sheets. These files are highly “hierarchized” and standardized(also known as xml files) that allows you to create data for managing all aspects of the world by the server and/or client. It contains all the creatures described, all the skills and all the objects and so on. There are hundreds of these definition files. A game like Ryzom can may represent thousands of Data Sheets in the end! It is necessary to generate a DS for each type of raw material, quality, country(for example). You can say it's like an vast encyclopedia of what's possible. But Primitives would rather then constitute the “atlas” of what exists. They(ofcourse)rely on the DS but they describe exactly what is where and how it must react/interact. This is where missions, NPCs, mob groups, raw material deposits and operating conditions, etc, etc.. are coded.

In fact, this “term” refers to a very large number of services that support the world. We usually speak of a “shard”(which designates an instance of the world), like the pre-fusion English-speaking/German-speaking/French-speaking servers. There is now only one shard at Winch Gate(in addition toYubo for testing). This is an list of distributed services available for those who would like to know more!

As an example, there is a service that manages Artificial Intelligence of a continent. The system can carry out a full service on ancillary machines, and still it was designed 15 years ago, and at a time when computers were much less powerful. In addition, the system has been designed to minimize the “data exchange”. One can play without worry with only a “3G” key. It is this lightness that allows what even a very big game do not always manage well! For ex: A 200 player visual contact event.

The server relies on Primitives and Data Sheets to manage interactions with all the players. Tho these has a non-binarized data, it still has much, much more to offer!! While the client only has the “static” info(the location of buildings for example), the server has the data of what will change(the place where the creatures appear for example). It also integrates the dedicated translation files, which enable it to construct sentences dynamically, thus mastering the localization in a very good way!.

There are a number of commands that can be entered on the management terminal of the shard but also commands that can be entered in it's “ingame chat”, such as the “/emote” command. If you have the sufficient privileges, it then allows you to do MJ/DEV operations like: teleport, display creatures, objects, etc.. These commands are used by the “CSR and Anim” BUT are(as of now) being replaced(little ny little) by Winch Gate with more suited “Arkitect scripts”. This allows you to manage some of the “live gameplay” for not so complex things. For making things last(or to be well managed), a Primitive must be created!!.

Historically there were 3 tools: The “Object Viewer” for everything related to graphics(creation and management of particle systems, micro vegetation etc.), “Georges Editor” for Datasheets and “World Editor” for Primitives. Plus a plugin dedicated to “3DSMax” to create the 3D objects(.ig and .shape) but also(and above all) create landscapes(.zone files) consisting elements of “LIGO bricks”(which can then be assembled dynamically like precisely LEGO's) or used such as for ex: “Pyr” on the world of “Atys”.

The people of Ryzom Core ended up creating a great tool(initilly based on a QT version of Object Viewer), now called “Ryzom Core Studio”. It is designed(with heart) with plugins. So there exist one for Object Viewer(plugin), another for World Editor and another for Georges.. but that's not all, They even added an interface editor, a .bnp package manager, and an translation manager…

We compile all the elements from source code, this being the “client, server and tools”. Everything is in a big “source package”, from which the compilation is launched, and which also stores the executables created in different directories.

There are three source types:

• Graphical data.
• Game data.
• Source code for executables.

The graphics data are essentially “.max” files, readable only by the program “3DSMax”, used(firstly) to be edited by it and then(via the plugin) create the data for the game itself. It also contains textures(as .png in general) and particle systems, which can be modified with Object Viewer. When you launch the “pipeline”(an building environment), it then transforms all this data to files with the correct formats for the game.

From this we get the game data(data sheets and primitives)! If these “data sheets” are modified, they must be recompiled for the client and implemented back into the server(with a followed restart and also provide it to the clients of course, like for ex: a patching system). So every time you want to create a new object, a new skill etc… you have to do a quick recompile and restart again, then patching of the clients should follow. The Ryzom patchlet system is almost fully operational(it is not yet fully deployed due to compatibility concerns of the latest LUA version regarding Windows), but when all this is fixed, it will surely be implemented). Moving on to the primitives, they are the most flexible of all the data, because it's easier to reinstall without having to re-launch the entire shard.

And lastly, the sources for the executables are very large!! The client sources(coded in c ++), the server and the 3D game engine are all created specifically in this way(and all is called “NeL”). The Tools sources contains Ryzom Core Studio but also a number of different online utilities(used by Command prompt) and there's also the 3SMax plugin. Pretty much everything is there!!. The running compilation(when you compile) drops the results into various directories, interspersed according to the options specified by the compiler.

We provide all our Khanat data via an GitLab service.
We have made a presentation with information on how to organize our “repositories and contributions”.

• Installing a game server
• The Ryzom Core engine commands
• Managing a 'shard' of Ryzom Core
• Competence of Coding(Skills)
• Hardcoded C++ information about the Ryzom Core server
• Creating a game universe
• Creation of a new continent
• Creating a new visible IG object
• Change the name of player bots
• Adding a character title
• Organization of graphical data
• Naming conventions for graphical data
• Solving bugs and exploits
• Ticks, counting time

• Using the Ryzom Core Khanat client
• The Debug Mode client version
• Client configuration files
• Configuring the keyboard for the client
• How to modify the client interface
• Creating inventory icons for the client
• Creating Client Launch Images
• Ryzom Core Client launch Errors
• How to make video capturing with the client
• Client commands
• The InGame chat

• Data principle of Khanat
• Ryzom Core Tools
• The NeL graphic pipeline generation on Linux
• Thoughts about making an export plugin from Blender to NeL3D
• Thoughts about exporting to the NeL3D graphics engine
• Materials under NeL3D
• The management of textures by the NeL3D graphics engine
• Multitexturing of a NeL3D object
• The Ryzom Core lexicon of terms

This is an automatic list of all the items that carry the tag Ryzom Core.

This is an automatic list of tags related to Ryzom Core.

• Datasheet
  • world_editor
  • The Primitives