ProudNet.Eng
WebsiteProud ConsoleLanguage
  • 🌐ProudNet
    • ProudNet Introduction
    • Download and Install
      • How to verify your ProudNet license
      • AMI
    • Project Settings
      • C++
      • C#
      • Mac Xcode
      • Linux
      • Unity3D
        • iOS Build
      • Unreal Engine 4
      • Running the PIDL Compiler
    • Using ProudNet
      • Server and Client
        • Utilization of Server
        • Utilization of Client
      • RMI
        • Utilization of RMI
      • PIDL
        • Utilization of PIDL
      • Event handling
      • Communication messages
      • P2P Communication
        • Using P2P communication
    • Utilization of ProudNet
      • How to use
      • Tips for performance
    • Using DB in ProudNet
      • DB Cache System ver.2
        • DB Cache Theory and Understanding
        • Install DB Cache and Set Up Network
        • DB Cache Server and Client
        • DB Cache usage and application
          • Utilization of DB Cache
      • ADO API
      • ODBC API
    • ProudNet Utility
  • ProudNet Note
    • Technical Notes
      • Main Loop
      • Setting up a server firewall
      • Encryption and decryption
      • What to do in case of an error
      • List of error messages
      • Synchronizing Character Position
      • Client-Server Communication
      • MiniDump (Error Dump System)
      • [Version 1.6] Server-to-Server LAN Communicator
    • Glossary
    • Sample examples
  • 🌐Proud Service
    • Guide for Console
    • ProudChat
      • Download SDK
        • C++
        • C#
        • Unity3D
        • Unreal Engine 4
      • Features in Console
Powered by GitBook
On this page
  • RMI function groups
  • RMI method argument properties
  • - byval properties
  • - mutable properties
  • Communicating between programs in different languages
  • RMI message scope
  • Usage
  1. ProudNet
  2. Using ProudNet

RMI

ProudNet is a self-developed Remote Method Invocation (RMI) system that is much faster and lighter than the more popular IDL formats and RMI systems. For game development, we only support asynchronous RMI, i.e. RMI that does not wait for a 'function call return value'.

RMI function groups

A collection of zero or more RMI functions. In a PIDL file, it takes the form of a global construction block.

global SimpleC2S
{
    ...;
}

When you call a RMI function on the proxy, it returns immediately, and you do not have to wait to receive the results of the RMI function execution on the proxy side.

RMI method argument properties

Method arguments contain property definitions, and you can write one or more for each parameter.

in : It means that it is an input format argument and must be used. 'out' is not supported in the current version.

// For example, if you declare the RMI method as follows 
Test([in] Proud::String a,[in] int b,[in] float c);

// the following C++ code is generated.
Test(Proud::HostID remote, Proud::RmiContext& rmiContext, const Proud::String& a, const int& b, const float& c);
// When used as a cs file, this means replacing Proud::String with System.String
rename cs(Proud::String, System.String);

...

// For example, you can declare an RMI method like this 
Test([in] Proud::String a,[in] int b,[in] float c);

// This will generate the following C# code
Test(Nettention.Proud.HostID remote,Nettention.Proud.RmiContext rmiContext, String a, int b, float c);

In most cases, the attributes of the arguments to RMI methods use only in.

- byval properties

This means that the argument is passed by value, and when this is used, the & sign is omitted from the argument format in C++ proxy and stub. It is suitable for small argument types such as int or float.

// If you declare an RMI function like this,
Foo([in] int a);

// Function parameters are passed by reference to the created C++ Proxy and Stub. 
// This is the const int& a below.
SimpleC2S.Foo = [](Proud::HostID from, Proud::RmiContext& rmiContext, const int& a) = { ... };

// If you declare an RMI function by adding a byval attribute like this,
Foo([in, byval] int a);

// it is changed to by value.
SimpleC2S.Foo = [](Proud::HostID from, Proud::RmiContext& rmiContext, int a) = { ... };

- mutable properties

This means that the argument is not const type, and when used, the C++ proxy and stub will omit the const keyword from the argument type. This is appropriate when you want to change the value of an argument received from an RMI stub.

// If you add a mutable property like this
Foo([in, mutable] int a);

// it changes to a variable that can be changed. The const will be missing.
SimpleC2S.Foo = [](Proud::HostID from, Proud::RmiContext& rmiContext, int& a) = { ... };

Communicating between programs in different languages

There may be times when you want two programs to communicate over ProudNet, but in different programming languages. In this case, the PIDL compiler creates proxy and stub in two or more languages, and then each program can use what it needs.

Basic types such as int, double and string are already provided in ProudNet's wrapping module for languages other than C++. However, in different languages, the names of these basic types tend to be different. For example, in C# the string class is System.String, while in C++ it is std::string, std::wstring, ATL::CString and Proud::String.

To address this, the PIDL compiler provides the ability to change the type of variables in generated proxy and stub to be language specific if desired.

Below is an example of usage.

rename cs(TypeA,TypeB);     // 1
 
rename cpp(TypeC,TypeD);    // 2
 
global XXX 2000
{
    Foo([in]TypeA a);  // 3
    Goo([in]TypeC c);  // 4
}

RMI message scope

Each RMI function declaration has one message type. The message type in ProudNet is determined by the user in a range of 60,000 or less, which is done when the user writes the .pidl file.

For versions earlier than 1.7.42965-master, you should use values in the range of 1,300 to 60,000.

Examples of message type values for each RMI are shown below.

global SampleRMI 2000
{
    Foo1(...); // Assigned Message Type ID = 2001
    Foo2(...); // Assigned Message Type ID = 2002
    Foo3(...); // Assigned Message Type ID = 2003
}

Each function increases the message type value by one. And we will refer to the type value assigned to the last declared RMI function as the message range. In the example above, 2,000 to 2,003 is the message range for SampleRMI.

When you attach the created Proxy and Stub to Proud.CNetClient , Proud.CNetServer , Proud.CLanClient , Proud.CLanServer, the message scope of each RMI function group is reserved to RMI message scope Proud.CNetClient , Proud.CNetServer , Proud.CLanClient , Proud.CLanServer .

If the message scopes of the proxy and stub to be attached overlap, AttachProxy() or AttachStub() will raise an exception.

C#: CNetClient -> NetClient

CNetServer -> NetServer


Usage

Last updated 1 year ago

🌐
Utilization of RMI