Hi Glenn, I tried to integrate libyojimbo with unreal engine, after successfuly sending/receiving message with bare windows client to linux server, it's failed doing excactling the same thing in Unreal Engine tutorial scene. I did some network sniffing with Wireshark, it's weird the client side sends 10 UDP packets of 18 bytes payload to server, and server logged with "ignored encrypted packet, no read packet key for this address", any ideas? Here's my code (in Unreal).

// Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.

#include "physxClient.h"
#include "physxClientGameMode.h"
#include "physxClientHUD.h"
#include "physxClientCharacter.h"
#include "../ThirdParty/libyojimbo/include/yojimbo.h"
#include "../ThirdParty/libyojimbo/include/shared.h"
#include <signal.h>

using namespace yojimbo;

AphysxClientGameMode::AphysxClientGameMode()
	: Super()
{
	// set default pawn class to our Blueprinted character
	static ConstructorHelpers::FClassFinder<APawn> PlayerPawnClassFinder(TEXT("/Game/FirstPersonCPP/Blueprints/FirstPersonCharacter"));
	DefaultPawnClass = PlayerPawnClassFinder.Class;

	// use our custom HUD class
	HUDClass = AphysxClientHUD::StaticClass();
}
double ti = 100.0;

Client* client ;

void AphysxClientGameMode::StartPlay() {
	Super::StartPlay();
	InitializeYojimbo();
	OgameMessageFactory messageFactory(GetDefaultAllocator());
	uint64_t clientId = 1;

	Address clientAddress("0.0.0.0", 6667);
	Address serverAddress("192.168.0.8", 6666);
		 
	ClientServerConfig config;
	config.numChannels = 1;
	config.channel[0].type = CHANNEL_TYPE_UNRELIABLE_UNORDERED;

	client = new Client(GetDefaultAllocator(), clientAddress, config, adapter, ti);

	uint8_t privateKey[KeyBytes];
	memset(privateKey, 0, KeyBytes);
	client->InsecureConnect(privateKey, clientId, serverAddress);
	client->AdvanceTime(ti);
}

void AphysxClientGameMode::Tick(float f) {
	Super::Tick(f);
	
	const double deltaTime = 0.1;

	JoinMessage* message = (JoinMessage*)(client->CreateMessage(JOIN_MESSAGE));
	message->teamId = 1;
	client->SendMessage(0, message);
	client->SendPackets();
	client->ReceivePackets();
	ti += deltaTime;
	client->AdvanceTime(ti);
	//messageFactory.ReleaseMessage(message);

	yojimbo_sleep(deltaTime);

	return;
}

If you checkout a fresh copy of yojimbo and add the following to the end of the while() loop in the loopback.cpp example, you'll see the round trip time value increases slowly (screenshot attached)

NetworkInfo networkInfo;
client.GetNetworkInfo(networkInfo);
printf("RTT: %f\n", networkInfo.RTT);

(This is running on windows btw)

Max

I spent a few hours digging through reliable.io and yojimbo source code, and I can't seem to find the cause of this error: [server endpoint] packet too large to send. packet is 8330 bytes, maximum is 8192

As far as I can tell, yojimbo has a buffer for a single packet. When SendPackets() is called, it loops through each channel and asks it to fill the buffer up with as many messages as it can without going over the packet size limit.

However, reliable.io seems to think it's still going over. The few times I've been able to trigger this error, it's only ever over by ~150 bytes. That seems too high for something like the header size not being taken into account, but I can't figure out what's causing it exactly.

Any ideas?

Max

I made a little first version of a CMake script to build Yojimbo with CMake. It works on Windows and Linux. Improvements are surely possible. However - I'm dropping it here in case someone finds it useful. If there is an interest in CMakeifying Yojimbo I'm willing to help with that and work on a PR.

Instructions are below this comment

Cheers

Provided -as-is-: No guarantees whatsoever

CMakeLists.txt

cmake_minimum_required(VERSION 3.16)

include(FetchContent)

MESSAGE(STATUS "***")
MESSAGE(STATUS "***  Yojimbo -- START --")
MESSAGE(STATUS "***")

#############################################################
## Project Definition
#############################################################
project(Yojimbo C CXX)

############################################################
## Settings
############################################################

## Where to install yojimbo
#SET(YOJIMBO_INSTALL_DIR "${CMAKE_CURRENT_LIST_DIR}/install/${CMAKE_BUILD_TYPE}")
## Want Tests?
#SET(YOJIMBO_TESTS TRUE )
## Where to put the .git clone
#SET( YOJIMBO_SOURCE_DIR     "${CMAKE_CURRENT_LIST_DIR}/download/yojimbo"                   )
## Git tag to check out. 
## Can be a branch ("master"), tag ("v1.2.1") or commit hash ("af30b7c3ab3329e69d0c5cfe22b7644a13e7c838")
#SET( YOJIMBO_TAG "master")
## Root of your vcpkg installation
# SET(VCPKG_ROOT "F:/vcpkg")

############################################################
## Derived Settings
############################################################
##
  if(NOT DEFINED YOJIMBO_INSTALL_DIR)
      SET(YOJIMBO_INSTALL_DIR ${CMAKE_INSTALL_PREFIX} )
  endif()
  
  if(NOT DEFINED YOJIMBO_TESTS)
      SET(YOJIMBO_TESTS FALSE)
  endif()

  if(NOT DEFINED YOJIMBO_SOURCE_DIR)
      SET(YOJIMBO_SOURCE_DIR "${CMAKE_CURRENT_LIST_DIR}/download/yojimbo")
  endif()
  
  if(NOT DEFINED YOJIMBO_TAG)
      SET(YOJIMBO_TAG "master")
  endif()

  if(NOT DEFINED VCPKG_ROOT)
    MESSAGE(      "Cannot proceed without VCPKG_ROOT being defined. Please correct your settings.")
    MESSAGE(FATAL "You can get vcpkg from https://github.com/Microsoft/vcpkg")
  endif()

  ## Debug output
  MESSAGE("YOJIMBO_INSTALL_DIR = " ${YOJIMBO_INSTALL_DIR})
  MESSAGE("YOJIMBO_TESTS       = " ${YOJIMBO_TESTS})
  MESSAGE("YOJIMBO_SOURCE_DIR  = " ${YOJIMBO_SOURCE_DIR})
  MESSAGE("YOJIMBO_TAG         = " ${YOJIMBO_TAG})
  MESSAGE("VCPKG_ROOT          = " ${VCPKG_ROOT})


#############################################################
## Fetch Yojimbo
#############################################################
##
  FetchContent_Declare( YojimboGit )
  FetchContent_Populate(YojimboGit
      SOURCE_DIR     ${YOJIMBO_SOURCE_DIR}
      GIT_REPOSITORY "https://github.com/networkprotocol/yojimbo.git"
      GIT_TAG        ${YOJIMBO_TAG}
  )

############################################################
## External imports: libsodium and mbedtls
############################################################
##
  ## We require an installation of VCPKG here and VCPKG_ROOT set to the installation folder
  ## The dependecies are installed with vcpkg as follows (Windows x64):
  ## cd ${VCPKG_ROOT}
  ## vcpkg install libsodium:x64-windows-static
  ## vcpkg install mbedtls:x64-windows-static
  ## On Linux the triplet distinction between static and dynamic libraries is not existent
  
  # External library paths
  if(WIN32)
    SET(VCPKG_LIBSODIUM_BASE "${VCPKG_ROOT}/packages/libsodium_x64-windows-static" )
    SET(VCPKG_MBEDTLS_BASE   "${VCPKG_ROOT}/packages/mbedtls_x64-windows-static" )
  elseif(UNIX)
    SET(VCPKG_LIBSODIUM_BASE "${VCPKG_ROOT}/installed/x64-linux")
    SET(VCPKG_MBEDTLS_BASE   "${VCPKG_ROOT}/installed/x64-linux")
  else()
    MESSAGE(FATAL "Inrecognized Operating System. I understand either WIN32 or UNIX to be set to true.")
  endif()
  
  ## External libraries and headers
  add_library( sodium STATIC IMPORTED)
  target_include_directories( sodium INTERFACE "${VCPKG_LIBSODIUM_BASE}/include"  )
  
  add_library( mbedtls STATIC IMPORTED)  
  target_include_directories( mbedtls INTERFACE "${VCPKG_MBEDTLS_BASE}/include"  )
    
  add_library( mbedx509 STATIC IMPORTED)  
  target_include_directories( mbedx509 INTERFACE "${VCPKG_MBEDTLS_BASE}/include"  )
  
  add_library( mbedcrypto STATIC IMPORTED)  
  target_include_directories( mbedcrypto INTERFACE "${VCPKG_MBEDTLS_BASE}/include"  )
  
  ## External library binaries
  if(WIN32)
    set_target_properties(sodium     PROPERTIES IMPORTED_LOCATION ${VCPKG_LIBSODIUM_BASE}/lib/libsodium.lib )
    set_target_properties(mbedtls    PROPERTIES IMPORTED_LOCATION ${VCPKG_MBEDTLS_BASE}/lib/mbedtls.lib     )
    set_target_properties(mbedx509   PROPERTIES IMPORTED_LOCATION ${VCPKG_MBEDTLS_BASE}/lib/mbedx509.lib    )
    set_target_properties(mbedcrypto PROPERTIES IMPORTED_LOCATION ${VCPKG_MBEDTLS_BASE}/lib/mbedcrypto.lib  )
  ELSEIF(UNIX)
    set_target_properties(sodium     PROPERTIES IMPORTED_LOCATION ${VCPKG_LIBSODIUM_BASE}/lib/libsodium.a   )
    set_target_properties(mbedtls    PROPERTIES IMPORTED_LOCATION ${VCPKG_MBEDTLS_BASE}/lib/libmbedtls.a    )
    set_target_properties(mbedx509   PROPERTIES IMPORTED_LOCATION ${VCPKG_MBEDTLS_BASE}/lib/libmbedx509.a   )
    set_target_properties(mbedcrypto PROPERTIES IMPORTED_LOCATION ${VCPKG_MBEDTLS_BASE}/lib/libmbedcrypto.a )
  ENDIF()
  


############################################################
## Yojimbo Static Library
############################################################
##
  add_library(yojimbo STATIC
      ${YOJIMBO_SOURCE_DIR}/yojimbo.cpp
      ${YOJIMBO_SOURCE_DIR}/tlsf/tlsf.c
      ${YOJIMBO_SOURCE_DIR}/netcode.io/netcode.c
      ${YOJIMBO_SOURCE_DIR}/reliable.io/reliable.c
  )
  target_link_libraries( yojimbo sodium mbedtls mbedx509 mbedcrypto )
  target_compile_definitions( yojimbo PUBLIC NETCODE_ENABLE_TESTS=0 RELIABLE_ENABLE_TESTS=0 )      
  target_include_directories( yojimbo 
    INTERFACE
        $<BUILD_INTERFACE:${YOJIMBO_SOURCE_DIR}> 
        $<INSTALL_INTERFACE:${YOJIMBO_INSTALL_DIR}/include> 
    PRIVATE 
        ${YOJIMBO_SOURCE_DIR}/netcode.io 
        ${YOJIMBO_SOURCE_DIR}/reliable.io 
  )

############################################################
## Yojimbo Static TEST Library and Test App
############################################################
##
  if(${YOJIMBO_TESTS})  
        ## library
        add_library(yojimbo_test STATIC
          ${YOJIMBO_SOURCE_DIR}/yojimbo.cpp
          ${YOJIMBO_SOURCE_DIR}/tlsf/tlsf.c
          ${YOJIMBO_SOURCE_DIR}/netcode.io/netcode.c
          ${YOJIMBO_SOURCE_DIR}/reliable.io/reliable.c
        )
        target_link_libraries( yojimbo_test sodium mbedtls mbedx509 mbedcrypto )    
        target_compile_definitions( yojimbo_test PUBLIC NETCODE_ENABLE_TESTS=1 RELIABLE_ENABLE_TESTS=1 )    
        target_include_directories( yojimbo_test 
          INTERFACE
              $<BUILD_INTERFACE:${YOJIMBO_SOURCE_DIR}> 
              $<INSTALL_INTERFACE:${YOJIMBO_INSTALL_DIR}/include> 
          PRIVATE 
              "${YOJIMBO_SOURCE_DIR}/netcode.io" 
              "${YOJIMBO_SOURCE_DIR}/reliable.io" 
        )
        
        target_include_directories( yojimbo PRIVATE "${VCPKG_LIBSODIUM_BASE}/include"  )
        target_include_directories( yojimbo PRIVATE "${VCPKG_MBEDTLS_BASE}/include"  )
                
        ## executable
        add_executable(testapp ${YOJIMBO_SOURCE_DIR}/test.cpp )
        target_link_libraries(testapp yojimbo_test)    
        ##
  endif()  

############################################################
## Client App Target
############################################################
##
  add_executable(client ${YOJIMBO_SOURCE_DIR}/client.cpp )
  target_link_libraries( client yojimbo )

############################################################
## Server App Target
############################################################
##
  add_executable(server ${YOJIMBO_SOURCE_DIR}/server.cpp )
  target_link_libraries( server yojimbo )

############################################################
## Secure Client App Target
############################################################
##
  add_executable(secure_client ${YOJIMBO_SOURCE_DIR}/secure_client.cpp )
  target_link_libraries( secure_client yojimbo )

############################################################
## Secure Server App Target
############################################################
##
  add_executable(secure_server ${YOJIMBO_SOURCE_DIR}/secure_server.cpp )
  target_link_libraries( secure_server yojimbo )

############################################################
## Client Server App Target
############################################################
##
  add_executable(client_server ${YOJIMBO_SOURCE_DIR}/client_server.cpp )
  target_link_libraries( client_server yojimbo )

############################################################
## Loopback App Target
############################################################
##
  add_executable(loopback ${YOJIMBO_SOURCE_DIR}/loopback.cpp )
  target_link_libraries( loopback yojimbo )

############################################################
## Soak App Target
############################################################
##
  add_executable(soak ${YOJIMBO_SOURCE_DIR}/soak.cpp )
  target_link_libraries( soak yojimbo )

############################################################
## Install
############################################################
##
  if(YOJIMBO_TESTS)
      SET(TEST_INSTALL testapp)
  endif()
  
  ## yojimbo + EXPORT
  install(
      TARGETS
          yojimbo
      EXPORT yojimboConfig 
      RUNTIME  DESTINATION ${YOJIMBO_INSTALL_DIR}/bin
      LIBRARY  DESTINATION ${YOJIMBO_INSTALL_DIR}/lib
      ARCHIVE  DESTINATION ${YOJIMBO_INSTALL_DIR}/lib     
      INCLUDES DESTINATION ${YOJIMBO_INSTALL_DIR}/include  
  )
  ## The rest
  install(
      TARGETS
          ${TEST_INSTALL}
          client
          server
          secure_client
          secure_server
          client_server
          loopback
          soak
      RUNTIME  DESTINATION ${YOJIMBO_INSTALL_DIR}/bin
      LIBRARY  DESTINATION ${YOJIMBO_INSTALL_DIR}/lib
      ARCHIVE  DESTINATION ${YOJIMBO_INSTALL_DIR}/lib     
      INCLUDES DESTINATION ${YOJIMBO_INSTALL_DIR}/include  
  )
  install(  FILES   ${YOJIMBO_SOURCE_DIR}/yojimbo.h 
                    ${YOJIMBO_SOURCE_DIR}/shared.h 
            DESTINATION 
                    ${YOJIMBO_INSTALL_DIR}/include  
  )
  ## install cmake files for find_package
  install(EXPORT yojimboConfig DESTINATION ${YOJIMBO_INSTALL_DIR}/lib/cmake  )

#### DONE ####


MESSAGE(STATUS "***")
MESSAGE(STATUS "***  Yojimbo -- DONE --")
MESSAGE(STATUS "***")

EDIT: Changed EXPORT name to work with find_package( yojimbo ) when yojimbo_DIR is set to /lib/cmake in the install destination.

Currently, if you try to send a message with a size that happens to exceed the packet budget on it's channel, then the message itself will be silently dropped after failing to fit into a packet. This is impossible to see from the applications point of view, as no counters are affected, no error state is set, and the packet itself sends correctly - albeit without the oversized message.

Some kind of notification when this happens would be appreciated, instead of the oversized message silently disappearing into the ether.

I think that is very important to create a wrapper for 3D Engine: Unity 3D will be the perfect 3D engine to start.

It is possible to start a Patreon campaign where I would like to contribute.

Would you accept a cmake version of the build system? If I made one? Not sure how to deal with two versions of the build system though because one be outdated.

Is there any documentation on how to integrate yojimbo into cocos2d-x or any other c++ game engine? I'm talking about a basic scenario including send/receive/serialize. Thanks!

The following code:

rce->server->yj_transport = std::make_unique<yojimbo::NetworkTransport>(
            yojimbo::GetDefaultAllocator(),
            yojimbo::Address(),
            PROTOCOL_VERSION,
            cur_time
    );

yields this error in GCC 6.3.1 on Linux error: call of overloaded ‘swap(yojimbo::NetworkTransport*&, yojimbo::NetworkTransport*&)’ is ambiguous

It looks like the swap function in yojimbo_common.h is interfering with the swap function from the standard library.

This PR just removes the definition on C++11 or newer compilers using the __cplusplus macro. That being said, it's totally possible I'm doing something wrong, as both my C++ and knowledge of the standard are a little rusty these days.

Any thoughts?

Also thanks so much for this library, I expect to learn tons by studying and using it!

Hello everyone, here is my issue, I'm trying to make a server for a video game project so I tested my server in localhost and everything is working but when I want a friend to connect to my server that's not working ! Just to be clear I opened the server port on my internet box !

So my server code is like that:

if (!InitializeYojimbo())
{
	printf("Failed to initialize 'Yojimbo'\n");

	return EXIT_FAILURE;
}

yojimbo_log_level(YOJIMBO_LOG_LEVEL_INFO);

yojimbo::Address serverAddress("127.0.0.1", 4674); // <---- Server ip & port to listen.

GameConnectionConfig config;

GameServer gameServer(serverAddress, config);

gameServer.Run();

When I have 127.0.0.1 in server address I can connect with my client in localhost without any issues but when I put my internet box IP my friend can connect but I can no longer on my side !

I don't really understand why we need to put an IP Address to create the server, why just not only a port, and the server listen for all IP (Localhost & Internet at same time !).

Sorry in advance for my english, I'm not a native english speaker.

Thx for your help !

I was wondering what the feasibility is of being able to use a custom socket implementation, i.e. I am working on a restricted hardware platform where instead of normal sockets, there is a vendor provided socket implementation (different functions/params but very similar), which has the same properties of UDP (however I'd like to have reliable, ordered packets). Essentially, rather than passing in an address for yojimbo to open, I'd like to open the socket myself, and then pass yojimbo my socket (as a void* or whatever), and then register functions with yojimbo for sending, receiving and closing said socket.

What are your thoughts?

I attempted to clone and compile Yojimbo, and it failed, but I'm not sure why. I would appreciate help figuring out my issue. I have the pastebin of terminal logs here: https://pastebin.com/BEzmZraj Although, important to note I am using an aarch64 M1 Pro. I'm not sure why make isn't recognizing mbedtls and libsodium, but any help is appreciated!

This occurred on a configuration with .maxPacketSize == 8192. A message was generated, which serialized to 119500 bits. In Connection::GeneratePacket(), the availableBits is 65520, and as that makes the call to ReliableOrderedChannel::GetMessagesToSend(), the condition at https://github.com/networkprotocol/yojimbo/blob/master/yojimbo.cpp#L1828 never fires since entry->messageBits is 119500 and so availableBits >= (int) entry->measuredBits always evaluates to false.

What do you think the behavior should be here? That packet is too large, but an early error would be much preferred to a quiet clog of the channel for the rest of the connection's lifetime.

You already have a port made but it's not findable here https://vcpkg.io/en/packages.html and it's harder to consume than all the other vcpkg libraries. Ideally it should reside in this repo https://github.com/microsoft/vcpkg/tree/master/ports so yojimbo would become available to install right after installing vcpkg. For example GameNetworkingSockets by Valve is easily findable there and much easier to consume than yojimbo.

While working on the cmake/vcpkg port of yojimbo I stumbled over the fact that yojimbo is built as a static library only. Is there a reason for that? Or could yojimbo be built as a .dll/.so as well? On Windows cmake could export all symbols by default like:

SET(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS true)