1
0
KF2-Dev-Scripts/IpDrv/Classes/MeshBeacon.uc

259 lines
8.7 KiB
Ucode
Raw Normal View History

2020-12-13 15:01:13 +00:00
/**
* Copyright 1998-2013 Epic Games, Inc. All Rights Reserved.
*/
/**
* This class is the base class for the client/host mesh beacon classes.
*/
class MeshBeacon extends Object
native
inherits(FTickableObject)
config(Engine);
/** Packet ids used to communicate between host & client mesh beacons */
enum EMeshBeaconPacketType
{
// 0 packet type treated as undefined
MB_Packet_UnknownType,
// Sent by a client when a new connection is established and to send history from past bandwidth tests
MB_Packet_ClientNewConnectionRequest,
// Sent by a client when starting a bandwidth test to the host. Immediately followed by dummy buffer based on test size
MB_Packet_ClientBeginBandwidthTest,
// Sent by a client in response to a host request to create a new session
MB_Packet_ClientCreateNewSessionResponse,
// Sent by the host to acknowledge it received the connection request with bandwidth history from a client
MB_Packet_HostNewConnectionResponse,
// Sent by the host to a client to request a new bandwidth test
MB_Packet_HostBandwidthTestRequest,
// Sent by the host to a client that had initiated the bandwidth test, followed by the results of the test
MB_Packet_HostCompletedBandwidthTest,
// Sent by the host to all clients to initiate travel to a new session
MB_Packet_HostTravelRequest,
// Sent by the host to a client to request a new session to be created on the client. A list of players is sent to register with the new session.
MB_Packet_HostCreateNewSessionRequest,
// Used to flag dummy buffers sent for bandwidth testing
MB_Packet_DummyData,
// Sent periodically to tell the host/client that the other end is there
MB_Packet_Heartbeat
};
/** Result of a new client connection request */
enum EMeshBeaconConnectionResult
{
// Client was able to connect successfully
MB_ConnectionResult_Succeeded,
// Client already has a connection, duplicate
MB_ConnectionResult_Duplicate,
// Client connection request failed due to timeout
MB_ConnectionResult_Timeout,
// Client connection request failed due to socket error
MB_ConnectionResult_Error
};
/** State of current bandwidth testing on a client connection */
enum EMeshBeaconBandwidthTestState
{
// Bandwidth test for a connection has not been started/completed yet
MB_BandwidthTestState_NotStarted,
// Bandwidth test has been requested for the connection but the start request hasn't been to the client yet
MB_BandwidthTestState_RequestPending,
// Start request has been sent to client from host but test hasn't been started by client yet
MB_BandwidthTestState_StartPending,
// Test has been started for client and is currently in progress
MB_BandwidthTestState_InProgress,
// Test has completed for the client successfully
MB_BandwidthTestState_Completed,
// Test never completely finished, but didn't error either. Bandwidth results based on incomplete data
MB_BandwidthTestState_Incomplete,
// Test never finished due to timeout waiting for client.
MB_BandwidthTestState_Timeout,
// Test was started but never completed due to error
MB_BandwidthTestState_Error
};
/** Result of a bandwidth test between host/clietn connection */
enum EMeshBeaconBandwidthTestResult
{
// Test has completed for the client successfully
MB_BandwidthTestResult_Succeeded,
// Test never finished due to timeout waiting for client.
MB_BandwidthTestResult_Timeout,
// Test was started but never completed due to error
MB_BandwidthTestResult_Error
};
/** Bandwidth tests that are supported */
enum EMeshBeaconBandwidthTestType
{
// Test for rate at which data can be uploaded
MB_BandwidthTestType_Upstream,
// Test for rate at which data can be downloaded
MB_BandwidthTestType_Downstream,
// Test for time it takes to send/receive a packet
MB_BandwidthTestType_RoundtripLatency,
};
/** Bandwidth data for a connection */
struct native ConnectionBandwidthStats
{
/** Upstream rate in bytes per second */
var int UpstreamRate;
/** Downstream rate in bytes per second */
var int DownstreamRate;
/** Roundtrip latency in milliseconds */
var int RoundtripLatency;
structcpptext
{
/** Constructors */
FConnectionBandwidthStats() {}
FConnectionBandwidthStats(EEventParm)
{
appMemzero(this, sizeof(FConnectionBandwidthStats));
}
/**
* Serialize from NBO buffer to FConnectionBandwidthStats
*/
friend FNboSerializeFromBuffer& operator>>(FNboSerializeFromBuffer& Ar,FConnectionBandwidthStats& BandwidthStats);
/**
* Serialize from FConnectionBandwidthStats to NBO buffer
*/
friend FNboSerializeToBuffer& operator<<(FNboSerializeToBuffer& Ar,const FConnectionBandwidthStats& BandwidthStats);
}
};
/** Player that is to be a member of a new session */
struct native PlayerMember
{
/** The team the player is on */
var int TeamNum;
/** The skill rating of the player */
var int Skill;
/** The unique net id for the player */
var UniqueNetId NetId;
structcpptext
{
/** Constructors */
FPlayerMember() {}
FPlayerMember(EEventParm)
{
appMemzero(this, sizeof(FPlayerMember));
}
/**
* Serialize from NBO buffer to FPlayerMember
*/
friend FNboSerializeFromBuffer& operator>>(FNboSerializeFromBuffer& Ar,FPlayerMember& PlayerEntry);
/**
* Serialize from FPlayerMember to NBO buffer
*/
friend FNboSerializeToBuffer& operator<<(FNboSerializeToBuffer& Ar,const FPlayerMember& PlayerEntry);
}
};
/** The port that the mesh beacon will listen on */
var config int MeshBeaconPort;
/** The object that is used to send/receive data with the remote host/client */
var native transient pointer Socket{FSocket};
/** Used to determine whether to use deferred destruction or not */
var transient bool bIsInTick;
/** The maximum amount of time to pass between heartbeat packets being sent */
var config float HeartbeatTimeout;
/** The elapsed time that has passed since the last heartbeat */
var float ElapsedHeartbeatTime;
/** True if the beacon should be destroyed at the end of the tick */
var transient bool bWantsDeferredDestroy;
/** Whether to the socket(s) or not (not during travel) */
var bool bShouldTick;
/** The name to use when logging (helps debugging) */
var name BeaconName;
/** Size of socket send buffer. Once this is filled then socket blocks on the next send. */
var config int SocketSendBufferSize;
/** Size of socket recv buffer. Once this is filled then socket blocks on the next recv. */
var config int SocketReceiveBufferSize;
/** Maximum size of data that is allowed to be sent for bandwidth testing */
var config int MaxBandwidthTestBufferSize;
/** Minimum size of data that is required to be sent for acurate bandwidth testing */
var config int MinBandwidthTestBufferSize;
/** Maximum time allowed to send the buffer for bandwidth testing */
var config float MaxBandwidthTestSendTime;
/** Maximum time allowed to receive the buffer for bandwidth testing */
var config float MaxBandwidthTestReceiveTime;
/** Maximum number of entries allowed for the bandwidth history of a client connection */
var config int MaxBandwidthHistoryEntries;
cpptext
{
// FTickableObject interface
/**
* Returns whether it is okay to tick this object. E.g. objects being loaded in the background shouldn't be ticked
* till they are finalized and unreachable objects cannot be ticked either.
*
* @return TRUE if tickable, FALSE otherwise
*/
virtual UBOOL IsTickable() const
{
// We cannot tick objects that are unreachable or are in the process of being loaded in the background.
return !HasAnyFlags( RF_Unreachable | RF_AsyncLoading );
}
/**
* Used to determine if an object should be ticked when the game is paused.
*
* @return always TRUE as networking needs to be ticked even when paused
*/
virtual UBOOL IsTickableWhenPaused() const
{
return TRUE;
}
/**
* Ticks the network layer to see if there are any requests or responses to requests
*
* @param DeltaTime the amount of time that has elapsed since the last tick
*/
virtual void Tick(FLOAT DeltaTime);
/**
* Sends a heartbeat packet to the specified socket
*
* @param Socket the socket to send the data on
*
* @return TRUE if it sent ok, FALSE if there was an error
*/
UBOOL SendHeartbeat(FSocket* Socket);
/**
* Handles dummy packets that are received by reading from the buffer until there is no more data or a non-dummy packet is seen.
*
* @param FromBuffer the packet serializer to read from
*/
void ProcessDummyPackets(FNboSerializeFromBuffer& FromBuffer);
}
/**
* Stops listening for requests/responses and releases any allocated memory
*/
native event DestroyBeacon();
defaultproperties
{
bShouldTick=true
}