devblog RAGE Multiplayer 1.0 Developer Preview #1 Release

[ragempdev]

1.0. Yep. Developer Preview #1. Yupper. Let's start now!

 

 

UI

• New launcher UI

• New in-game menu UI based on the launcher, with a few updates to provide better fullscreen experience
• Favourites Tab has been added
• History Tab has been added
• Launcher masterlist displays unicode server names correctly now
• UI supports more than 25 languages now - and more yet to come (feel free to contribute to translations)!
• Launcher window is now draggable! 👌
• New loading screen has been added, it's going to be customisable for every server you're joining to in the future!
• Server browser now measures only ping to the servers from your history and favourites
• Microphone access and CEF debugging port options are now configurable through UI
• Red Dead Redemption 2 compatibility mode also added!

 

SYNCHRONISATION

On-foot, combat and shooting synchronisation has been overhauled: there shouldn't be those animation jitters, lack of synchronisation in specific scenarios and most of the issues should be gone. Vehicle synchronisation has been extended with unoccupied vehicle synchronisation, with both now featuring vehicle damage and vehicle door states synchronisation.

 

Here's a quick gun fight game play footage recorded with 1.0:

 

Client console

A few of you must've used client console resource by @Kasimir released back in 2018. It's been integrated into the new UI, with some handy file sync/async logging API being added.

• Added: client-side mp.console.clear()
• Added: client-side mp.console.reset()
• Added: client-side mp.console.verbosity
• Added: client-side mp.console.logInfo/logWarning/logError/logFatal(message[, save = false[, saveAsync = true]]);
• Added: client-side event "consoleCommand"

mp.events.add('consoleCommand', command => {
  mp.console.verbosity = 'info';
  mp.console.logInfo(`Received a command: ${command}`, true, true);
});

 

P2P

Partial Peer To Peer connectivity is now present in 1.0. While this feature is great for private lobbies (for example, there's a server hosted in Europe, but you and your American friend are playing from the same city, in these cases latency should drastically decrease), it is disabled by default due to user privacy considerations, at least until we add support for relay server networks. P2P triggers work even if P2P is disabled though, and requests are sent through the server.

• Added: client-side Player.call
• Added: client-side Player.p2pEnabled
• Added: client-side Player.p2pConnected

// client 2
mp.events.add("private_message", (player, msg) =>
{
    mp.gui.chat.push(`${player.name} [${player.remoteId}]: ${msg}`);
});

// client 1
let receiver = mp.players.atRemoteId(playerId);

if(mp.players.local.p2pEnabled) // check if the player (local player in that case) allows p2p connections
{
  if(receiver.p2pConnected) // check if direct client-to-client connection is established
  {
      receiver.call("private_message", ["hello beast"]);
  }
}

 

Streamer

Client-side entity streamer, of which you might've seen before, has been ported into this branch, having had intensive testing sessions resulting in its improvements. It also introduces new client-side API to let you configure streaming per every object. There are also some tweaks to make streaming of huge maps that consist of many different models a bit quicker, or at least provide zero effect on player and vehicle streaming.

 

 

Resource Subsystem Updates

• In addition to the in-game resource downloader, we have added yet another downloader right into the launcher. It is actually faster than the in game downloader since it doesn't have to share your PC resources with the game. No worries: in game downloader is still there!

• Encryption has been added. Note: you should consider that once data is downloaded to a 3rd-party PC, you can never be sure if it's going to be decrypted, therefore you should not share any sensitive data.
• Resource compression with configurable compression level has been added. It decreases not just data transfer bandwidth, but taken HDD space as well!
• Client packages CDN mechanism has been reimplemented, it's now cool to use!
• Outdated resource removal has been added: once in-launcher downloading gets finished, it also checks out the whole resources folder for expired files.

 

 

Developer Preview #1 API Updates

• Added: bool OnIncomingConnection(ip, serial, rgscName, rgscId) which is called before the final handshake happens
• Added: "serverShutdown" event for graceful shutdown, in JS you could use mp.events.delayShutdown to let all async calls get done (in C#/C++ you don't need it due to  obvious reasons):

mp.events.add("serverShutdown", async () =>
{
  mp.events.delayShutdown = true;
  await yourAsyncFunction();
  mp.events.delayShutdown = false;
});

 

• Added: unreliable event triggers that _are_ affected by potential packet loss but are way more faster when you need frequent triggers

// Server-side
player.callUnreliable(eventName[, args]);

mp.players.callUnreliable([players,] eventName, ...);
mp.players.callUnreliableInRange(eventName, ...);
mp.players.callUnreliableInDimension(eventName, ...);

// Client-side
mp.events.callRemoteUnreliable(eventName, args);

• Added: client-side player to player triggers API
• Added: dummy entities. Here's an example of dummy entities usage to make simple server-sided peds:

// client-side
function initializeStaticPeds()
{
	mp.dummies.forEachByType(1337, (entity) => // loop though dummy entities with "dummy" id 1337
	{
      if(!entity.pedInstance)
      {
        entity.pedInstance = mp.peds.newLegacy(entity.getVariable("position"), entity.getVariable("heading"), (function(ped)
        {
          ped.taskPlayAnim(this.getVariable("animationDict"), this.getVariable("animation"), 8.0, 1.0, -1, this.getVariable("animationFlag"), 1.0, true, true, true);
        }).bind(entity), entity.dimension);
        
        entity.pedInstance.parentEntity = entity;
      }
	});
}

// server-side
function addStaticPed(model, position, heading, animationDict, animationFlag, animation, dimension)
{
  let entity = mp.dummies.new(1337, // dummy entity type
    dimension,
    { // initial shared variables
    	heading: heading,
    	animationDict: animationDict,
    	animationFlag: animationFlag,
    	animation: animation
  	});
  
  entity.playAnimation = function(dict, anim) { this.setVariables({ animationDict: dict, animation: animation }); };
  
  return entity;
}

• Added: mp.objects.newWeak (client-side)
• Added: bool mp.Object.hidden (client-side)
• Added: float mp.Object.streamingRange (client-side)
• Added: bool mp.Object.notifyStreaming (client-side)
• Added: bool mp.Object.isWeak (client-side)
• Added: player.rgscId (do not confuse with player.socialClub which is name, not an ID)
• Added: mp.game.graphics.enableLights (client-side)
• Added: entity.forceStreamingUpdate() (for an entity)
• Added: mp.game.streaming.forceStreamingUpdate() (for the whole streaming)
• Added: player.setOwnVariable(key, value) - an alternative to entity.setVariable, which makes the data to be exclusively known by the player. At the player's client-side it's handled as regular shared data, through regular methods and events.
• Added: player.setOwnVariables(keyValuesObject)
• Added: player.getOwnVariable(key)
• Added: local inter-runtime server-side calls (similar to what client-side got with 0.3.7's C# introduction):

// JS
mp.events.callLocal("event_name", [0, 5]);

// C#
NAPI.LocalEvents.Trigger("event_name", 0, 5);

• Updated: clothes API now supports the whole draw-able models range
• Added: player.setHeadBlendPaletteColor(rgbColor, type); type value range is 0 to 3
• Added: player.getHeadBlendPaletteColor(type)
• Added: vehicle.customTires
• Updated: client-side entities are now being processed by the streamer on the frame after creation, to make a few things more predictable for resource developers. Check entity.forceStreamingUpdate() for immediate processing, though.
• Updated: data change handlers now have old value param added after new value one
• Added: you can now transfer binary buffers (ArrayBuffer for JS, byte[] for C#) through triggers and shared data
• Added: you can now transfer 64 bit integers (BigInt for JS, long for C#) through triggers and shared data
• Added: Client-side: mp.game.gxt.add(labelNameOrHash, newLabelValue)
• Added: Client-side: mp.game.gxt.get(labelNameOrHash)
• Added: Client-side: mp.game.gxt.getDefault(labelNameOrHash)
• Added: Client-side: mp.game.gxt.reset()
• Added: mp.Pool.getClosest(position[, num])

let player = mp.players.getClosest([0,0,0]);
console.log(player.id);

let players = mp.players.getClosest([0,0,0], 2);
console.log(players[0].id);

let allPlayersSortedByDistanceToPoint = mp.players.getClosest([0,0,0], mp.players.length);

• Server-side player weapon's API has been reworked to behave properly with the server's custom addon weapons, as well as fix a few related issues. All changes were internal and didn't break resource compatibility.
• Server-side vehicle occupants handling has been reworked to improve security and reliability, and all related bugs have been fixed; key changes are: improved performance; setOccupant(seat, null) now removes the player in the seat specified, if any; updated vehicle dimension handling; occupant limit has been increased to 16 per vehicle to cover busses; seat ids now start at 0 instead of -1 like it used to be.

 

API: CEF Updates

CEF event system, similar to the existing JS API event system, has been added which is a more secure and better performing (not in every single case at the moment though) alternative to Browser.execute.

• Added: CEF: mp.events.add(string eventName, function handler)
• Added: CEF: mp.events.reset()
• Added: CEF: mp.events.remove(string eventName)
• Added: CEF: mp.events.call(string eventName) (an alias of mp.trigger, for API design consistency purposes)
• Added: Client-side: Browser.call(eventName, arguments...)

There's also now the possibility to cache your evaluated browser code, so as not recompile the same browser JavaScript code again and again:

• Added: Client-side: Browser.executeCached(string code)

 

API: JS Updates

• General JavaScript runtime optimisations, especially syntactic sugar in the API, pools and more
• Fix player.eval when JS runtime is disabled
• Fix vehicle.dimension setter
• Updated: entity.setVariable now supports objects to set multiple variables at once
• Added: clientside read-only property Array mp.vehicles/players/markers/checkpoints/labels/colshapes.streamed
• ES6 modules are supported now: use mjs file extension to enable it for scripts, e.g. index.mjs. "require()" is still compatible and it works even in an "ES6 module" context.
• Added: event "packagesLoaded" for a better entry point when all packages are loaded and getting started, use mp.events.delayInitialization to make sure your async calls are completed before "packagesLoaded" gets triggered:

// packages/module/index.js
mp.events.delayInitialization = true;

let asyncDone = false;

getAsync(() => 
{
	// async calls done, now let it invoke "packagesLoaded"
	mp.events.delayInitialization = true;

	asyncDone = true;
});

mp.events.add('packagesLoaded', () =>
{
	console.log(`async done: ${asyncDone}`);
});

• Updated: mp.game.invoke has been greatly overhauled and now supports different return values and variable types (we still recommend to use *official* API whenever possible though, for the best stability and performance)

//
let phoneGestureAnimTime = mp.game.invokeFloat('0x47619ABE8B268C60', mp.players.local.handle);
let stateString = mp.game.invokeString('0x717E4D1F2048376D', mp.players.local.handle);
let bonePosVector = mp.game.invokeVector('0x44A8FCB8ED227738', mp.players.local.handle, boneId);

// You should use arrays with one element of required type to pass variable as a reference
let posixTime = { year: [0], month: [0], day: [0], hour: [0], minute: [0], second: [0] };
mp.game.invoke('0xDA488F299A5B164E', posixTime.year, posixTime.month, posixTime.hour, posixHour.minute, posixHour.second);

mp.gui.chat.push(`Year: ${posixTime.year[0]}`);

// that works for all types
let matrix = { r: [[0, 0, 0]], f: [[0, 0, 0]], u: [[0, 0, 0]], p: [[0, 0, 0]] };
mp.game.invoke('0xECB2FC7235A7D137', handle, matrix.r, matrix.f, matrix.u, matrix.p);

// ArrayBuffers could be used too
let outDataBuffer = [new ArrayBuffer(256)];
mp.game.invoke('0x79923CD21BECE14E', 0, outDataBuffer);

API: C# Updates

• Server-side .NET Core dependency has been updated to .NET Core 3.0; client-side .NET Core has yet to be updated because of our sand-boxed .NET Core fork
• "Deprecated" methods have been removed; some of them are coming back though, with new implementation
• C# API core has been moved into the server codebase to achieve better flexibility and to use better API implementations wherever possible. "Bridge" folder has been renamed into "dotnet", keep this in mind. C# API is still optional though and you have to enable it via server configuration files first.
• Entity system has been re-implemented and is akin to client-side C# entity system now, which is more performant. User API wasn't affected by this change.
• Updated: event system performance has been improved
• Updated: entity.ResetData now returns a boolean according to existence of data with given key
• Updated: entity != and == operators now compare object reference instead of id
• Added: entity.IsInstanceAlive (gets set to false when "entity" object gets destroyed)
• Added: explicit entity.SetVariable non-object overloads for compile time type detection
• Updated: NAPI entity data API now uses Entity instead of NetHandle. OOP API didn't change
• Updated: triggers/shared data objects are now serialised through MsgPack, instead of the Json serialiser we used before. Be sure to update all your classes with proper attributes. Bonus feature: you can utilise new byte[] transfer feature to use typed MsgPack serialisation for the best performance
• Updated: entity data has been updated to utilise the new entity system's features and performs better now
• Added: per-entity external data (up to 16 objects) for the fastest & cheapest possible data access:

//
MyGamemodePlayerData obj = new MyGamemodePlayerData();

obj.level = 10;
obj.uid = 512;
obj.faction = 12;

player.SetExternalData(0, obj);

//
MyGamemodePlayerData obj = player.GetExternalData<MyGamemodePlayerData>(0);

 

• Fixed: player.SetClothes (dictionary variant)
• Added: Methods to register Commands at runtime using NAPI.Command.Register and NAPI.Command.Unregister
• Added: Ability to register RemoteEvents at runtime using NAPI.ClientEvent.Register and NAPI.ClientEvent.Unregister
• Updated: all the enums are up to date now
• Fixed: a few keybind-related crashes
• Updated: world data, entity data and shared entity data received performance improvements thanks to a bunch of lower level optimisations, especially in the case of Shared Data which means server C++ to C# API transfer.

* Note: 1KK stands for 1KK benchmark iterations, it's not related to the amount of data used. Every type of data has its own different benchmark code.

• Updated: remote events perform faster for both incoming and outgoing triggers
• Updated: server-side NetHandle pools API that have been marked for deprecation since 0.3.3, has been removed
• Added: thread-safe remote event triggers implementation has been added for: 1) global broadcast; 2) specific players; 3) specific player. Note that it's not just thread-safe implementation with internal locks but an actual overhead-free implementation.

NetHandle netHandle = client.HandleCopy;

Task.Run(() =>
{
  // ....
  NAPI.ClientEvents.ThreadSafe.TriggerForAll("test_event", 0);
  NAPI.ClientEvents.ThreadSafe.TriggerFor(netHandle, "test_event", 1);
  NAPI.ClientEvents.ThreadSafe.TriggerToPlayers(netHandles, "test_event", 1);
});

• Updated: C# command processing performance has been improved
• Added: NAPI.Server.SetLogCommandParamParserExceptions
• Added: NAPI.Server.SetLogRemoteEventParamParserExceptions
• Updated: NAPI.Vector3 has been changed from "class" to "struct"
• Fixed: clothes set via SetCustomization

 

API: Client-side C# Updates

• Client-side C# is now enabled by default! 🎉
• Our internal "sand-boxed" .NET Core fork has been updated to deliver sand-boxing at lower performance penalty
• Detailed C# troubleshooting tutorial alert has been added popping up in case if client-side .NET Core did not manage to initialise

 

 

• Fixed: RAGE.Game.Invoker.Invoke
• Added: RAGE.NUI.UIMenuSliderItem
• Fixed: typo in marker.Visble in C#
• Fixed: client-side C# entity transfer in remote events
• Fixed: pool.GetAtHandle
• Fixed: pool.Streamed
• Added: entity.ResetData
• Added: entity.HasData
• Updated: added more game API functions, check rage-sharp.xml for more information

 

Server-sided Modding

• OpenIV-ish RPF encryption is now compatible with RAGE Multiplayer, without any additional manual labour of re-encoding it.
• Server-sided DLC Pack loader has been reimplemented to make the loading faster. It now should load all server-sided mods in a moment
• All the game-modding related files are moved into /game_resources now. E.g., your DLC pack path should look like: /client_packages/game_resources/dlcpacks/customdlcpack/dlc.rpf
• Complete Server-Sided Modding™ has been added: you are now able to edit every single game file, and load it just like a regular *modded* game before the game starts. Your players will have to restart the game on every content update if this feature is enabled on your server, though. Example: /server/client_packages/game_resources/common/data/gameconfig.xml
• Local client-sided game engine limit adjuster feature has been added. Use "pool_overrides.ml" in ragempfolder/clientdata to adjust any game limit you wish, by its name or hash. You can't decrease existing limits. Here's a quick example:

<overrides>
  <pool name="fwLodNode">30000</pool>
  <pool hash="B81A5FEA">10000</pool>
</overrides>

 

DIAGNOSTICS

Launcher now has built-in diagnostics tool to automatically detect:

• Software conflicts
• Bad installation
• Bad client-side packages
• A few more user-related issues

In case an issue is detected, you will be offered with steps to fix it.

 

MISC

• Fixed "undefined" JavaScript errors not related to client-side scripts nor RAGE Multiplayer
• CEF rendering has been optimised
• NodeJS dependency has been updated to 13.0.1
• Client-side V8 dependency has been updated to v7.8
• CEF dependency updated to CEF 78.2.10 (Chromium 78.0.3904.70)
• Internal entity pool optimisations resulting in performance improvements of our internals, but of some entity-related APIs as well
• Added "node-commandline-flags" server configuration param, e.g. "node-commandline-flags": "--inspect"
• Added "resources-compression-level" server configuration param. Default value is 1. Use 0 for local server, or a higher value for bandwidth optimisation.
• Added "fqdn" server configuration param, e.g. "fqdn": "game-srv.rage.mp". Thanks to this option your players won't notice any server IP change, including the re-utilisation of downloaded packages.
• Added "api-threading-debugging" server configuration param, e.g. "api-threading-debugging": true. If set to true, it'll report every single usage of the API out of proper thread. Use it only for debugging since it adds some CPU overhead.
• Game native function invoker implementation has been optimised: up to 2x more performant now! Here's a comparison table that we've posted in our Discord a few months ago:

 

• Voice chat recorder has been re-implemented to provide better performance and stability
• Internal refactoring has been done to prepare JS scripting runtime codebase for an updated game API in the next updates (one which is currently used in C#)
• Client-side part of player and vehicle streaming has been improved to decrease the time interval from "stream in" notification, to an actual physical creation, especially when it comes to handling many entities at once
• Rockstar Editor crash has been fixed
• CEF input handling has been improved to fix specific charset issues

 

Downloads

• Client (includes Windows Server)
• Linux Server (not available for testing release)
• C# Package (Windows)
• C# Package (Linux) (not available for testing release)

 

Download links will be available starting from 6 Nov, 8pm GMT, as we have determined that this is the best time to provide interactive help and will be able assist people with issues with this release. The public bug tracker will be back online for any issues you wish to report (so it doesn't get lost in the chain of messages on discord). This announcement is being posted in advance to provide the syntax and expected features, especially for those epic wiki contributors. See ya! 🎉

 

[JamesBeast]

WAOW GEORGE TNX SO MUCH THIS IS MADE MY LIFE

BEASTEST UPDATE EVER

heart racing
sweat dripping
dick hardening
buttsack assing

[hubba]

beast

[Brophy]

Beast 

[hartority]

BEST

[Muphy]

woaw

[rgnbgnhnd]

Oh my god...i'm crying. Never saw something as beautiful as this....thanks.....

Edited November 6, 2019 by rgnbgnhnd

[Hazes]

Beast ! That's a lot of great work. Thanks!

Edited November 6, 2019 by Hazes

[ScrashOff]

You guys are f****** awesome. BEAST

[Zeeky]

beast