Monday, December 17, 2012

Particle System Demonstration

One of our community developers, dnk-88, was helping out Botanic from the Tempest in the Aether project with some particle system development. Particle systems are one of the more powerful features in Ryzom Core but are one of the features that we don't have a ton of documentation on how to use.

The particle system that dnk-88 created for Tempest was for their force-shield dome on one of their continents. The video documents the process from empty particle system to complete dome effect. It's a really cool process to watch and gives you a thorough demonstration of the new particle editor.


Note: You will want to full-screen the video to see the details and text better.

Tuesday, August 28, 2012

Tutorial: Chatty NPCs

In Ryzom Core we have one main NPC that randomly chats to you. You can take a look at how he chats you up about the four freedoms but you might want some more explanation. This also isn't the only way to make your NPCs talk your players ears off so lets see how Chiang works and then maybe expand his capabilities a little bit...

Random Chatter Using Timers


This is accomplished using a timer_t0_triggered NPC group event handler and a start_of_state NPC group event handler. The logic here is pretty simple: you use the start_of_state to set your t0 timer. In the case of Chiang the Strong it is set to 1000. This timer value uses in game ticks which is an important distinction. Many people would assume it is seconds or milliseconds. In timing terms there are 10 game ticks per real second so a value of 1000 is approximately every 100 seconds.

So now you have a timer that will go off in 10 seconds. You need to tie that timer to something. In the same NPC group you'll add another NPC group event handler to handle the timer_t0_triggered event. So now when your timer, created above, goes off it will get caught by this new event handler. In this event handler you need to do two things: set the timer again so he keeps chatting and then randomly say something. In order to accomplish two things your first action will be a multi_action which just allows you to specify more than one npc_event_action object. It will execute all of these actions.

The first action you'll add is a new set_timer_t0 action, it is set up the same way as your initial start_of_state but in the case of the Ryzom Core example we change the duration to 1500 - so he's a little less chatty. This new action sets the chatter loop in motion.

Next we'll add a random_select action. Here's a quick hint - most of these types are documented and you can see the local documentation in your favorite browser by clicking "View" next to the action drop down. You'll see this pattern throughout the classic World Editor tool. The documentation for random_select states the random choice is based on weight. This isn't true, it doesn't work. If you need it to work please log a bug. Under the random selection action you'll see that Chiang says four things - this is because he chats about the four freedoms all day long. So just keep adding say actions to your hearts content and he'll keep adding new things to babble about. You'll see that the say parameters are formatted like this:

say: CHIANG_1

You have a number of options in the say action parameters: tell, say, shout, universe, escort. I'm not really going to go into detail on these as for the most part they make sense. If you want your NPC to shout something you would use "shout" instead of "say". The second component, the CHIANG_1 is a phrase ID. Lets say you want Chiang to also say "Hey, by the way, Affero GPL is the best!" you would add a new say action with a phrase ID of something like CHIANG_5 or maybe CHIANG_AFFERO since the phrase ID is some what arbitrary. Let us assume you add CHIANG_5. Add your new action and set that for the parameter. Then you need to actually define that phrase somewhere. The details of translation are for another tutorial but to cut to the chase you would modify the phrase_XX.txt (where XX represents your various supported languages, e.g. en or fr) and add a new line there. It should be present in the phrase files on both the server and the client.

That's it, now Chiang says one more thing.


Mixing It Up


You can see how we can use a timer to quickly add repeatitive chatting but really you can use almost any NPC event. For example you could modify the NPCs In Motion tutorial so that the begin_state event handler has a multi_action where one action says a phrase like "Alright, lets get going" and the next action starts the guards in motion on the path.

Another popular alternative is to use the player_target_npc event handler - actions in this event handler get called whenever a player targets the NPC. When using this event handler type you have a player component and so instead of using the "say" parameter you could use the "tell" parameter.

Thursday, August 23, 2012

Tutorial: Settings NPCs In Motion

In this post I'm going to describe to a simple way to set your NPCs into motion. We'll be using NPC routes.

To begin with open up World Editor and make sure that the urban_newbieland primitive is loaded. It would be exceptionally helpful to have the newbieland.land file loaded as well so that you can visualize the continent as you draw your paths and zones.


Creating an NPC Path

  1. Navigate to rangers_starting_city (the npc_manager)
  2. Right click on rangers_starting_city and choose npc_route
    1. Provide a name, e.g. patrol_npcs
    2. Set AI Activity to either guard or normal.
    3. Set AI Movement to follow_route
    4. Set vertical_pos to auto.
  3. Ensure that patrol_npcs is selected
    1. Enter Edit Point mode
    2. Enable Add Points
    3. Draw your path.
  4. Right click on patrol_npcs and add a new NPC Group
  5. Name it "guard_npcs"
  6. Right click on guard_npcs and add a new NPC Bot
    1. Name it newbieland_guard_patrol - ensure the name is unique if you add multiple bots.
    2. Set the sheet_client, e.g. company_of_the_drill_loge_master_z_h_b1
    3. Set vertical_pos to auto
    4. You may also set chat_parameters if necessary and equipment if you want to customize equipment or colors. For reference see chiang_the_strong.
    5. Move the point representing the bot(s) to somewhere near the beginning of the path.
  7. Next you will have to enable the NPC event handling.
    1. Right click on patrol_npcs and add a new npc_state_event_handler
    2. Name it "destination_reached_all"
    3. Set the event to destination_reached_all
    4. Right click on the new event handler and add a new npc_event_handler_action
      1. Name it "begin_state"
      2. Set the action to begin_state
      3. Set the parameters to patrol_npcs
  8. Save the primitive and reboot your EGS and AIS. A full shard reboot is recommended to simplify potential problems during content development.

Monday, July 23, 2012

Featured: Tempest in the Aether

Ryzom Core is very frequently confused with the game Ryzom by pretty much everyone. The reality is that we're trying to make Ryzom Core be a platform for the creation of MMOs. We have one group whom has come to us and diligently worked their way through configuring a shard, creating custom UI elements, generating a new continent from scratch, configuring all of the essential patching services and more. They posted a gameplay video back in May which I hadn't seen. It's not exciting but it demonstrates that you can use Ryzom Core to begin creating your own MMO:


Check out their developers blog. If you're looking to contribute to a project and it's not Ryzom Core I'd suggest contributing to Tempest in the Aether. They're a great group of people with some very talented artists.

Friday, July 20, 2012

Summer of Code Midterm

So the mid-term for Summer of Code has come and gone. Just to remind everyone this is what we have students working on:

  • Ryzom GUI Editor
  • Character Achievements
  • Camera Animations and Sound Triggers
  • Guild Ranks

Guild Ranks

Zyklon has been working on implementing a new guild rank system - this will be a new system that will allow guild leaders to create arbitrary ranks and associate grades to them. So instead of being stuck with static grades you can create a hierarchy of your own.

Zyklon has had an awful lot of new technology to learn and was stuck with a pretty formidable server bug for the first two weeks of his project. But as of the midterm he has made substantial progress with the server-side data structure and implementing the persistence templates. He will button up much of that code this term and hopefully implement the action handlers on the client side.

His mentor is Ulukyn.

Camera Animations and Sound Triggers

Fabien has been working hard on adding a new system for level designers to be able to animate cameras and send sound trigger impulses to the client. It's been a lot of work and has exposed him to a huge variety of new parts of Ryzom Core. He took the path of allowing level designers to create animation scripts in World Editor and added the ability to trigger them in missions. This allowed him to harness the knowledge from his previous project - implementing guild missions - as well as used existing tools that the designers are familiar with.

So far Fabien has worked with his mentor to renovate the way the sound system IDs sounds (it used to use a map based on the name and now uses the universal sheet ID), has implemented the world_editor_classes.xml changes and implemented the loader code in the EGS and has begun implementation of the client impulses for sounds. By the end of the term he should have a full functioning sound trigger setup and basic server-driven camera animations.

His mentor is Kaetemi.



Character Achievements

SirCotare's character achievement work has been around porting an existing character achievements tool to use the newly developed and open sourced Ryzom API and WebIG source code. He's taken a tool that was external to Ryzom Core and rewritten it to use the new API and then has expanded the tool by implementing it in-game as well as implementing other features such as Facebook integration.

By the end of the term he plans on replacing the existing PHP achievement tracker responsible for determining if a player-character has made an achievement with code capable of performing the tracking in real time.

His mentor is ace.




Ryzom GUI Editor

dfighter has been working hard on the Ryzom Core GUI editor. But that's not entirely honest. The first stage of this project was to separate the GUI code in such a way that it could be used outside of the client code. All of this code was contained in a sub-folder called interface_v3 and so we naively assumed that it would straight-forward but time consuming to separate it out into a NeL library. I think even the most pessimistic of us under-estimated the amount of effort required to separate the core GUI from the client. At the end of the first term of Summer of Code dfighter has achieved this goal and has successfully separated the code out into its own NeL library: NLGUI. He has demonstrated it running outside of the Ryzom Core client in the beginnings of the actual GUI editor.

By the end of the term he plans on fully supporting loading and saving NeL GUI XML files and will implement rudimentary GUI editing capabilities.

His mentor is dnk-88.



Thank You!

I'd like to thank all of the students for their hard work. It's been a lot of fun helping out, discussing their work and just seeing the cool stuff they're working on start to come together!

Tuesday, June 19, 2012

Preview: World Editor Plugin

One of our former Google Summer of Code students has been diligently working his way through the massive task he took on last year doing some final touches. He re-wrote the landscape layout portion of the legacy MFC-based World Editor tool as a plugin to the OVQT Tool System and began the task of rewriting the World Editor portion. You can use the Lansdcape Editor today but there are still a number of finishing touches that need to completed before the World Editor is ready for the prime-time.

Check out this preview video and feel free to visit us on IRC if you have comments or questions!


Tuesday, May 29, 2012

Developer Notice: EOL Changes in Hg

Attention Ryzom Core Developers,

I've been spending an increasing amount of time developing on Linux using vi and have run into the ^M frustration enough that I decided to implement the Hg end-of-line extension. I converted the repository to use LF as the native line ending. You can alter what your local native is in your .hgrc or repository level .hg/hgrc file.

Everyone should enable the EOL extension in their Hg configuration file:
[extensions]
eol =

; Uncomment to change your local repository to CRLF for Windows
;[eol]
;native = CRLF



Here is the whole changeset if you want to see. It really is just a massive diff change CRLF to LF to nearly every file in the repository.

Please change your repository extensions and merge default into your branches as soon as possible!

Thursday, May 17, 2012

Ryzom Core Buildings

Ryzom Core provides two primary methods of placing inanimate objects such as buildings using bot-objects or importing the content as an instance group. In the Ryzom Core stock continent you can see both versions of object placement - there are several outlying buildings in the "newbieland" village which are placed statically using an instance group and on the top of the hill where the three stock NPCs are lurking is a guard tower which is placed using the bot-object variation.

Bot Object Buildings

I don't intend on giving a thorough tutorial on constructing and placing buildings but placing a building using a bot object is fairly simple. You can look at how this is accomplished by referencing the guard tower.
  1. Create your shape and ensure that it is in the media database (e.g. W:\database\Stuff...)
  2. Clone the object_watch_tower.creature sheet and change the shape used.
  3. Execute the build_gamedata pipeline to export the .shape file and update packed sheets.
  4. Add a new NPC bot using the new creature sheet. Place appropriately.
I can illustrate these steps in a future post or tutorial but this is the essence of how to do this. 

Pros: Quickly and easily place inanimate objects on the landscape. Provides a dynamic means for modifying and moving these objects without needing to patch the client.
Cons: Consume an entity slot and must be directly tracked as an entity on the server side. All lighting and effects are performed dynamically. No complex scene objects such as instance groups are supported - meaning no portal/cluster support and no PACS triggers for teleportation, elevators or doors.

NPCs standing in front of the bot object guard tower in Ryzom Core.


Bot Objects are very useful if you want to quickly (and dramatically) alter terrain and the layout with minimal effort and little or no patching required on the client. You can use them to quickly alter an area for an event, for example, and then revert the changes back assuming all of the relevant media is already distributed to the client.

Static Buildings

Static buildings are the best way to build large areas of inanimate objects such as a city or town. Because all of the data necessary to display these on a landscape zone are already on the client the client has a much greater ability to display and cull the geometry. When using the bot object method you may notice a "popping" of buildings - this is because the server has to make decisions based on priority, number of entities visible and entity view distance to determine whether or not to inform the client of the existence of the bot object. If you wander around Silan on the official Ryzom game servers you will know what I'm talking about. Using a static building leaves all of these decisions up to the 3D engine and removes the server as a component.

Pros: Advanced functionality and no reliance on the server for visibility. No "popping" due to priority or viewing distance.
Cons: Hard coded to the landscape and requires a full regeneration through the build pipeline. Cannot be dynamically manipulated. Substantial setup required within the 3D modelling package, in the build pipeline and in World Editor.

A custom placed static building on a development shard.


Unlike the bot objects which just use the pipeline to run an export and simple shape optimization a static building will require the landscape for the continent to be completely regenerated. The pipeline will place the instance group representing the building onto its target zone and then run it through a series of lighting and shading passing and ultimately ends up "baking" the building onto the landscape. 

Since bot objects tend to be simple objects the engine will just "snap" them to the landscape when it spawns them using the same technique that it uses to snap characters to the landscape. Static buildings tend to be more complex and have more reliance on the shape and position relative to the landscape in order to provide walk-able collision areas for things like doors. This means that process is more substantial:

  1. Assemble your building in a tool such as 3DSMAX.
  2. Import the building into a landscape brick using the building xref tools.
  3. Deform the landscape to accommodate the building.
  4. Use the pipeline to export the landscape brick and zone information.
  5. Copy the brick data generated above to the corresponding World Editor continent so that it is available.
  6. In landscape mode place (or replace) the zone.
  7. Run build_gamedata and update locations accordingly (e.g. data_shard, patch, client install, etc)

Thursday, May 10, 2012

Ryzom Ring Crash Resolved

After an epic 6 month long battle in the Ryzom Core community to set up a Ring shard and build enough data to test and debug the Ring crash we have finally done it and the resulting fix was pretty anti-climactic. In the end we changed one whole line of code but the journey exposed us to the vast underbelly of the Lua Reflection code within Ryzom Core's client.

Some people will look at the fix and wonder why it took so long to get to that resolution. I covered some of the details above - there was no official open source Ring shard and we didn't have the data to set one up. So we had to painstakingly piece this information together. Bearing in mind that the Ryzom Core Ring shard still doesn't fully function because we're still piecing the data together. At least now we have a client that doesn't crash.

But debugging the Lua scripts has proven to be extremely difficult as once we get passed CLuaState::executeFile debugging information is essentially a blackhole. We had to harness in code to iterate through the Lua files to disocover what method call was crashing us. This was quite literally logging after each method call or variable assignment to a log file. We discovered that it was an assignment the retrieval of a ucstring member which didn't really help us since there was almost no activity on CI18N or in any of the GetUCString helpers. Lua IHM was essentially untainted.

After some complete luck we put a breakpoint in CLuaIHM::luaUIIndex and were able to step through this function to the actual failure. In this function we could discover which class, methods and members were involved by inspecting the reflected property. In this case there was a class that had been changed: CGroupTree::SNode. Down the road this has been sanitized to have the getter/setter methods for const-reference sanity. Lua has no binding for "const ucstring &" and thus panicked late in the process.

So the fix? Remove const-ness and the reference from the return value. We deleted 6 characters from a header file.  Behold the fix.

Friday, May 4, 2012

Ryzom API and WebIG Framework Now Open Source!

So pretty big news in the world of Ryzom Core. In order to greater enable one of our Summer of Code students to succeed Winch Gate has graciously provided the full source to the server side components of the Ryzom API and Ryzom's WebIG system.

So this is great news for people developing games using Ryzom Core but it is also pretty awesome news for Ryzom players with development skills. The Ryzom API that is available to players for development of external applications is pretty robust but doesn't provide a wealth of low-level access and does not embed into the game the same way WebIG does.

Now Ryzom players have the ability to create and contribute in-game applications!


About Ryzom API and WebIG


The Ryzom API has two main components - a server side website and client library. The server side component is what was just released. The Ryzom API allows third-party developers to develop their own applications using a simple ReST-style web service. The client API provides a PHP interface for web developers.

The Ryzom WebIG (Web In Game) system provides the basic framework for providing rapid functional development in Ryzom Core without the need to modify the client and distribute patches. The WebIG framework is a powerful way to add a very large amount of functionality very quickly. It also provides a dual purpose platform as most WebIG apps can also be accessed via the web. This allows game developers to minimize the amount of development needed for applications


Configuration and Setup


The set up should be pretty straight forward. You will need to rename the config.php.default configuration files to config.php in their respective locations:
  • code/web/app/config.php.default
  • code/web/api/common/config.php.default
  • code/web/api/server/config.php.default
  • code/web/api/client/config.php.default
In the these files you will need to correctly set the RYAPI_URL and RYAPP_URL variables to the correct path, e.g. http://app.mygame.org/. In the API server configuration you will need to configure the RYAPI_NELDB_* variables to your nel and ring_open database. These are the same settings you would use when setting up the other shard configurations. Finally the RYAPI_WEBDB_* variables define the database host, user and password that will be used for application databases.

For example to the demo app app_test you'd create a new app_test database with a table called test with two columns: id and num_access. See this code for an example:

$db = ryDB::getInstance(APP_NAME);
$db->setDbDefs('test', array('id' => SQL_DEF_INT, 'num_access' => SQL_DEF_INT));
$db->update('test', array('num_access' => ++$num_access['num_access']), array('id' => $user['id']));


Getting Started


There's already a ton of information on the Ryzom API site for using the API and a number of great example applications created by Ryzom players available on places such as Github. Check out the contest submissions, there's a lot of great code and great ideas there!

Getting started writing a new WebIG app is pretty simple too. You'll need to copy app_test and then add your new app_whatever to code/web/app/lang.php and code/web/app/index.php so that the WebIG framework knows about your application. If your application uses a database you will need to create the new database, using your app name, using the host/user/pass specified in the RYAPI_WEBDB_* configuration variables.

Feel free to join us on irc.freenode.net in the channel #ryzom for more information or if you need help!

Tuesday, May 1, 2012

Tutorial: Creating a Guild Master

A lot of functionality in Ryzom Core relies on guilds existing. In the default shard information that is provided with Ryzom Core there is no NPC guild master. Creating a guild master is actually a really simple exercise. In this little tutorial I'll show you a couple quick tricks for development and troubleshooting and then jump right into the meat of creating a guild master and then founding a guild in the game.

Development Tricks

There are a couple quick and dirty tricks I used to make sure I had the necessary access and money to test the guild master out. The first one is to grant your player DEV privileges.

There are two main commands you will use to grant yourself DEV privileges. You can always access the data_shard folder and decipher your player ID from your PDR file name but it is much easier if you log into the shard and use the displayPlayers command. The player ID is pretty evident if you look at the example below. You then use the setPriv command to grant yourself privileges. The DEV privilege is the main one you need for this exercise: setPriv <uid> <priv>

displayPlayers
INF b71126d0 94.136.70.53/EGS-136 : Executing command : 'displayPlayers'
INF b71126d0 94.136.70.53/EGS-136 : Player: 1 Name: Karlin(Open) ID: (0x0000000010:00:00:87) FE: 135 Sheet:fyros.race_stats - 21 Priv: '' Pos: 10305,-11722,5 Session: 302
setPriv 1 :DEV:
INF b71126d0 94.136.70.53/EGS-136 : Executing command : 'setPriv 1 :DEV:'
INF b71126d0 94.136.70.53/EGS-136 : New priv for player 1 is ':DEV:'
displayPlayers
INF b71126d0 94.136.70.53/EGS-136 : Player: 1 Name: Karlin(Open) ID: (0x0000000010:00:00:87) FE: 135 Sheet:fyros.race_stats - 21 Priv: ':DEV:' Pos: 10305,-11722,5 Session: 302

Another one that is useful is the /a command from within the client. In this case you will need money to found the guild so use the /a command to execute Money like this:

/a Money 1000000

There are a slew of handy admin commands available in the client but that is a topic for another article.

Creating the Guild Master

You will have to create an NPC in World Editor that will be responsible for handing out guild creation requests. If you look at your shop_categories.cfg in data_shard you'll note that one of the available categories is "guild_creator." This is the shop category that enables an NPC to found guild for a player.

To place this NPC:
  1. Open up newbieland.worldedit in World Editor
  2. Add or expand the urban_newbieland.primitive
  3. Expand the rangers_starting_city npc_manager
  4. Expand the important_npcs npc_zone
  5. Add a new npc_group, accept the default parameters and set the name to guild_masters
  6. Under guild_masters add a new npc_bot
     
  7. Set the name to nbland_guild_master$fct_nb_guildmaster$
  8. Add two chat_parameters lines:
    1. shop:guild_creator
    2. menu: MENU_WHOAMI WHOAMI_GUILDMASTER
  9. Set the sheet_client to company_of_the_drill_loge_master_z_h_b1. Note that you can use any valid existing .creature sheet here. This just happens to be the one that is used for the existing NPCs on Ryzom Core's Newbieland.
  10. Move the Prim Point representing your NPC to where you want it located on the map.
  11. Save your changes.
  12. Restart your shard.
Bear in mind that we haven't discussed the menu options so nothing will be translated when interacting with the NPC (the whoami menu.)

Optionally you can customize the look of the NPC. You might want to do this since we're going to use the same creature sheet as the other default Newbieland NPCs. You do this by setting the color of the five equipment slots. If you look at the screenshot above you will see that we set each equipment slot to a number. These numbers (0 through 8) denote a color:
ColorValue
Red0
Orange1
Green2
Turquoise3
Blue4
Purple5
White6
Black7



Creating the Guild

Actually creating the guild is the easiest part of the process. Assuming you have enough money (see Development Tricks above) all you need to do is locate your NPC and choose the Create Guild action and begin entering the details.
Creating the guild. Give a name and design your flag.
Viewing your guild information.


Next Steps...


This is only the very basic of guild-based configuration. There are other NPC roles and topics to investigate such as guild_rolemasters, guild_caretakers and charges. Maybe next you'll drop a community building on your map and set up a caretaker and rolemaster in order to buy and customize guild halls. Maybe you'll create a guild-based mission.

Hope this helps get you started in guilds!

Wednesday, April 25, 2012

Google Summer of Code 2012 Accepted Students


Hopefully it's not news that Ryzom Core was accepted into Google Summer of Code 2012. The WorldForge project kindly hosted us and CEGUI under its umbrella. We had the privilege of having a number of great students proposals. Unfortunately as things go we didn't get to accept them all and we had to make a lot of hard decisions. We hope those of you that didn't get accepted join the community and apply next year!

We ended up being able to accept four student proposals and they're great proposals this year!

Ryzom Core GUI Editor


We had one brave student decide to take on this behemoth task. dfighter will be creating a basic GUI editor tool as a plugin to OVQT to create the interface XML files used by Ryzom Core's client. Additionally he will be separating out components of the client (CDB and the Core UI) into NeL for re-use by non-client projects and tools. dfighter began this refactoring process awhile ago and has made substantial progress. dnk-88 will be mentoring him.

Character Achievements


SirCotare comes to us from the Ryzom players community, which is a real treat. His project will bring in-house the character achievements work he has already accomplished using the Ryzom API for the Ryzom Armory. His proposal will be moving the existing achievements system into Ryzom, refactoring it for direct access (bypassing the API), releasing the entire server-side API to AGPLv3 (presently only the client API for PHP is available) and finally improving the "triggers" for achievements to have more flexibility. acemtp will be mentoring him.

Camera Animations and Sound Triggers


Fabien is a student from last year who worked on the guild-based missions code. This year he decided to take on something a little different - but not too different. He was interested in the sound triggers idea which implements a greater ability for content designers to relay requests to play sound effects to the client. The idea adds the ability to play sounds from mission steps, via AI scripts and through the dialog tree system. Looking at what he was going to be working on the idea morphed to bring in more capabilities and thus will introduce rudimentary camera animation that can be scripted in the mission editor. By the end of the project content designers will be able to script miniature cut-scenes as part of their mission tree. He will be mentored by Kaetemi.

Guild Ranks and Management


Zyklon is a new arrival to the Ryzom Core community. He will be adding the ability for guild officers and/or leaders to create arbitrarily named ranks within their guilds. At a functionality level guilds will still maintain the existing grades (leader, high officer, officer, member) but will be able to generate their own internal ranking system (e.g. PFC, Sgt, Cpt, etc). He will be faced with multiple challenges - designing a usable UI, creating an efficient mechanism for synchronizing the guild ranks and more but he will have a great support team - he will be mentored by Ulukyn.

Everyone Else

Again I really wish we had an unlimited number of slots with which to accept students, we had many great proposals. To the students who were not accepted we'd love for you to come join the community and hang out. If you're interested in applying next year this will provide you with many benefits in the application process and will lead to a stronger proposal. Plus we're really fun guys to hang out on IRC with.

Thank you again to everyone who applied and to WorldForge for hosting us again!

Monday, April 16, 2012

An Example of Community

A lot of open source projects that are tightly aligned with a commercial entity often lead people to have an incorrect perception of the community. For example when I was posting around to inform people (students) that Ryzom Core was in Google Summer of Code I naturally posted on the Ryzom player forums. I said something like "ever wanted to add feature XYZ to the game? Now's your chance!" A snarky player replied to me "because we paid you to make it." It is easy to make that assumption but I'd like to take time in this post to point out some of the great things that have come from the community recently.

Improved OSX Builds

One of Ryzom and Ryzom Core's most prolific contributors, kervala, applied a patch provided to us by GelluleX. Kervala and GelluleX's patches and work have reduced a massive amount of warnings that people working on OSX encounter but have also provided us with the ability to build using CLang. This is pretty important for people developing on OSX as CLang/LLVM is Apple's preferred method and they're no longer maintaining GCC. In addition to this you can use CLang on the other platforms we officially support and it provides faster builds, faster code and much more accurate debugging and output.
CLang build on OSX - detailed error messages.
If you want to build using CLang either on OSX or Linux and CMake has not chosen it as your default compiler you can force it to do so using these CMake command line options:

-DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++

Sound System Improvements

Kaetemi has been a busy guy working on the sound system over the past couple weeks. He has fixed a number of bugs and problems with the sound system but is planning a three stage re-implementation of the NeL music system. You can link into his detailed information about what he is doing but you can see that he has finished the first stage of the process which included implementing a streaming sound, a sound group controller interface, various performance improvements and bug fixes. In addition he uncovered some substantial fixes to the threading logic. He added thread priority and he fixed the isRunning method which used to have this lovely comment in it:

// TODO : need a real implementation here that check thread status
Long term this implementation will enable a greater ability to use music sources in game. For example for Ryzom players this feature will enable in-game items such as the jukebox in the Pyr bar to actually play back music.

Linux Patching Improvements

Botanic from the Tempest in the Aether project provided a fairly complete patch enabled the built-in client patcher on Linux and OSX. It works as well as it does on Windows and will hopefully be applied very soon. Due to the differences between the three main OSs we support and even between various distributions of Linux the answer of how to universally handle patching is still being discussed.

Tempest in the Aether patching on Linux.


Botanic's patch works wonderfully if the client is installed into the user's home directory - where the user has full privileges to update all of the content. The debate comes in for situations such as distributing the game binary through a package manager or App Store. In the case of Linux the binary is then in an area of the file system which normal users cannot overwrite. In the case of OSX the binary is not allowed to be patched outside of the App Store.

Friday, April 13, 2012

Welcome to the Ryzom Core Developers Blog

One of the problems that Ryzom Core struggles with frequently is the perception that it is dormant and no longer developed. There are a lot of reasons for this throughout the long and tumultuous history of the NeL and Ryzom Core history but the fact of the matter is that we're pretty terrible at two big things: communication and releases.

The group that runs the Ryzom game make their fair share of releases and have a lively mechanism for getting that out. That's part of their business and it is their obligation to their players. Getting releases out is also an obligation to their players. Most people who use Ryzom Core are still running pretty bleeding edge and haven't expressed a need for a regular cyclic release cycle. There hasn't been an outcry of desire for long term stable releases. This just isn't a reality for us right now so we don't bother releasing "early and often" as is so often suggested. This is a big reason why there's a perception that we're dormant - that we don't have very many releases. Our last major release was 0.8.0 and that was probably more than a year ago now.

We also don't have a lot of big "news" to talk about so we very rarely post new items on the Ryzom Core developer site. This means that the new is concise and really limited to big deal items. I think that this is kind of important but it also means that there's only a handful of posts per year. There are a lot of tiny initiatives and efforts that go on behind the scenes. Things that following the commit log and the issue history will tell. Most people won't do this. It's often too difficult to try and troll through the myriad of commits explaining what's been changed and then try to make a summary of what those changes amount to - unless you are one of the people making those changes.

So for these reasons I've decided to make an official Ryzom Core developers blog. Here's a place where myself and other Ryzom Core contributors can come and post updates of projects they're working on, announce new patches that have been applied, provide mini-tutorials or use cases in Ryzom Core or sometimes we might just use it as a sort of bully pulpit just to rant.

This past week a couple big things have come. So in the next day or two expect a post here about what those things are what it might mean to you as someone using the Ryzom Core platform. In about two weeks we'll be able to announce who our Google Summer of Code students are and then we'll take the time to highlight each one of their projects. Hopefully the things you find here are useful, informative and go a long way to proving that Ryzom Core isn't dead or dormant.