public void Send <TParameters>(byte code, TParameters parameters, MessageSendOptions messageSendOptions)
where TParameters : struct, IParameters
{
if (clientPeerProvider.Peer.IsConnected)
{
eventSender.Send(new MessageData <TParameters>(code, parameters), messageSendOptions);
}
}
/// <summary>
/// Forwards previously sent messages. Returns the forwarded messages in the same order as the message identifiers passed in message_ids. If a message can't be forwarded, null will be returned instead of the message
/// </summary>
public static Task <Messages> ForwardMessagesAsync(
this Client client, long chatId = default, long fromChatId = default, long[] messageIds = default,
MessageSendOptions options = default, bool sendCopy = default, bool removeCaption = default)
{
return(client.ExecuteAsync(new ForwardMessages
{
ChatId = chatId, FromChatId = fromChatId, MessageIds = messageIds, Options = options,
SendCopy = sendCopy, RemoveCaption = removeCaption
}));
}
/// <summary>
/// Sends 2-10 messages grouped together into an album. Currently only audio, document, photo and video messages can be grouped into an album. Documents and audio files can be only grouped in an album with messages of the same type. Returns sent messages
/// </summary>
public static Task <Messages> SendMessageAlbumAsync(
this Client client, long chatId = default, long messageThreadId = default, long replyToMessageId = default,
MessageSendOptions options = default, InputMessageContent[] inputMessageContents = default)
{
return(client.ExecuteAsync(new SendMessageAlbum
{
ChatId = chatId, MessageThreadId = messageThreadId, ReplyToMessageId = replyToMessageId,
Options = options, InputMessageContents = inputMessageContents
}));
}
/// <summary>
/// Sends the result of an inline query as a message. Returns the sent message. Always clears a chat draft message
/// </summary>
public static Task <Message> SendInlineQueryResultMessageAsync(
this Client client, long chatId = default, long messageThreadId = default, long replyToMessageId = default,
MessageSendOptions options = default, long queryId = default, string resultId = default,
bool hideViaBot = default)
{
return(client.ExecuteAsync(new SendInlineQueryResultMessage
{
ChatId = chatId, MessageThreadId = messageThreadId, ReplyToMessageId = replyToMessageId,
Options = options, QueryId = queryId, ResultId = resultId, HideViaBot = hideViaBot
}));
}
/// <summary>
/// Sends a message. Returns the sent message
/// </summary>
public static Task <Message> SendMessageAsync(
this Client client, long chatId = default, long messageThreadId = default, long replyToMessageId = default,
MessageSendOptions options = default, ReplyMarkup replyMarkup = default,
InputMessageContent inputMessageContent = default)
{
return(client.ExecuteAsync(new SendMessage
{
ChatId = chatId, MessageThreadId = messageThreadId, ReplyToMessageId = replyToMessageId,
Options = options, ReplyMarkup = replyMarkup, InputMessageContent = inputMessageContent
}));
}
private void OnSubscriberAdded(ISceneObject sceneObject)
{
var positionTransform = sceneObject.Components.GetComponent <IPositionTransform>().AssertNotNull();
var directionTransform = sceneObject.Components.GetComponent <IDirectionTransform>().AssertNotNull();
var sharedSceneObject = new SceneObjectParameters(sceneObject.Id, sceneObject.Name,
positionTransform.Position.X, positionTransform.Position.Y, directionTransform.Direction.GetDirectionsFromDirection());
var parameters = new SceneObjectAddedEventParameters(sharedSceneObject);
eventSender.Send((byte)GameEvents.SceneObjectAdded, parameters, MessageSendOptions.DefaultReliable());
}
public async Task Send <T>(T message, MessageSendOptions options)
{
var serializedMessage = ServiceBusMessageXmlSerializer.Instance.Serialize(message);
var queueMessage = new CloudQueueMessage(serializedMessage);
await _queue.AddMessageAsync(queueMessage,
timeToLive : options.MessageTimeToLiveInSeconds.HasValue?(TimeSpan?)TimeSpan.FromSeconds(options.MessageTimeToLiveInSeconds.Value) : null,
initialVisibilityDelay : options.MessageSendDelayInSeconds.HasValue?(TimeSpan?)TimeSpan.FromSeconds(options.MessageSendDelayInSeconds.Value) : null,
options : new QueueRequestOptions(),
operationContext : new OperationContext()
);
}
public void SendOperation <TParams>(byte operationCode, TParams parameters, MessageSendOptions messageSendOptions)
where TParams : struct, IParameters
{
if (!IsConnected())
{
return;
}
var code = (TOperationCode)Enum.ToObject(typeof(TOperationCode), operationCode);
operationRequestSender.Send(code, parameters, messageSendOptions);
}
private void OnSubscribersRemoved(ISceneObject[] sceneObjects)
{
var sceneObjectsIds = new int[sceneObjects.Length];
for (var i = 0; i < sceneObjectsIds.Length; i++)
{
sceneObjectsIds[i] = sceneObjects[i].Id;
}
var parameters = new SceneObjectsRemovedEventParameters(sceneObjectsIds);
eventSender.Send((byte)GameEvents.SceneObjectsRemoved, parameters, MessageSendOptions.DefaultReliable());
}
public void SendOperation <TParams>(byte operationCode, TParams parameters)
where TParams : struct, IParameters
{
var code = (TOperationCode)Enum.ToObject(typeof(TOperationCode), operationCode);
if (!IsConnected())
{
LogUtils.Log($"Failed to send {code} operation because there is no connection with a server.");
return;
}
operationRequestSender.Send(code, parameters, MessageSendOptions.DefaultReliable());
}
public short Send <TParam>(MessageData <TParam> data, MessageSendOptions sendOptions)
where TParam : struct, IParameters
{
if (sendOptions.Flush)
{
LogUtils.Log(MessageBuilder.Trace("sendOptions::Flush is not supported!"), LogMessageType.Warning);
}
var currentRequestId = requestId++;
var operationRequest = Utils.ToPhotonOperationRequest(data, currentRequestId);
var result = RawPeer.OpCustom(operationRequest, sendOptions.Reliable, sendOptions.ChannelId, sendOptions.Encrypted);
LogUtils.Assert(result, "Could not send operation request");
return(currentRequestId);
}
public EmptyParameters?Handle(MessageData <UpdatePlayerStateRequestParameters> messageData, ref MessageSendOptions sendOptions)
{
var playerState = messageData.Parameters.PlayerState;
var playerPositionController = sceneObject.Components.GetComponent <IPlayerPositionController>();
if (playerPositionController != null)
{
playerPositionController.PlayerState = playerState;
}
var parameters = new PlayerStateChangedEventParameters(playerState, sceneObject.Id);
var messageSendOptions = MessageSendOptions.DefaultReliable((byte)GameDataChannels.Animations);
interestAreaNotifier.NotifySubscribers((byte)GameEvents.PlayerStateChanged, parameters, messageSendOptions);
return(null);
}
public void SendChatMessage(string message)
{
foreach (var peerWrapper in peerContainer.GetAllPeerWrappers())
{
if (peerWrapper.PeerId == clientPeerProvider.PeerId)
{
continue;
}
RaiseChatMessage(peerWrapper);
}
void RaiseChatMessage(IClientPeerWrapper peerWrapper)
{
var eventSenderWrapper = peerWrapper.PeerLogic.Components.GetComponent <IEventSenderWrapper>().AssertNotNull();
var parameters = new ChatMessageEventParameters(message);
eventSenderWrapper.Send((byte)ChatEvents.ChatMessage, parameters, MessageSendOptions.DefaultReliable());
}
}
public Task Send(T message, MessageSendOptions options)
{
if (_isDisposed)
{
throw new ObjectDisposedException("InMemoryMessageSender");
}
if (options.MessageSendDelayInSeconds.HasValue)
{
Task.Run(async() =>
{
await Task.Delay(TimeSpan.FromSeconds(options.MessageSendDelayInSeconds.Value));
_channel.Send(message);
});
}
else
{
_channel.Send(message);
}
return(Task.CompletedTask);
}
private void OnSubscribersAdded(IReadOnlyList <ISceneObject> sceneObjects)
{
var sharedSceneObjects = new SceneObjectParameters[sceneObjects.Count];
for (var i = 0; i < sceneObjects.Count; i++)
{
sharedSceneObjects[i].Id = sceneObjects[i].Id;
sharedSceneObjects[i].Name = sceneObjects[i].Name;
var positionTransform = sceneObjects[i].Components.GetComponent <IPositionTransform>().AssertNotNull();
sharedSceneObjects[i].X = positionTransform.Position.X;
sharedSceneObjects[i].Y = positionTransform.Position.Y;
var directionTransform = sceneObjects[i].Components.GetComponent <IDirectionTransform>().AssertNotNull();
sharedSceneObjects[i].Direction = directionTransform.Direction.GetDirectionsFromDirection();
}
var parameters = new SceneObjectsAddedEventParameters(sharedSceneObjects);
eventSender.Send((byte)GameEvents.SceneObjectsAdded, parameters, MessageSendOptions.DefaultReliable());
}
public ChangeSceneResponseParameters?Handle(MessageData <ChangeSceneRequestParameters> messageData, ref MessageSendOptions sendOptions)
{
// Getting a current scene before the teleportation.
var presenceSceneProvider = playerGameObject.Components.GetComponent <IPresenceSceneProvider>().AssertNotNull();
// Getting portal info.
var portalSceneObjectId = messageData.Parameters.PortalId;
var portalSceneObject = presenceSceneProvider.GetScene().GetSceneObject(portalSceneObjectId).AssertNotNull();
var portalInfoProvider = portalSceneObject.Components.GetComponent <IPortalInfoProvider>().AssertNotNull();
// Removing body from the old physics world.
DestroyBodyFromOldWorld();
// Removing a character from his old scene.
RemoveSceneObject();
// Setting the character's position in the destination scene.
ChangeTransform();
// Adding a character to the destination scene.
AddSceneObject();
// Setting the character's interest area in the destination scene.
FixInterestAreaSize();
// Creating a new body in the new physics world.
CreateBodyToNewWorld();
// Change last map of the character.
ChangeCharacterLastMap();
return(new ChangeSceneResponseParameters(portalInfoProvider.Map));
void DestroyBodyFromOldWorld()
{
playerGameObject.RemoveBody();
}
void RemoveSceneObject()
{
presenceSceneProvider.GetScene().RemoveSceneObject(playerGameObject);
presenceSceneProvider.SetScene(null);
}
void ChangeTransform()
{
var spawnPositionDetails = CharacterSpawnDetailsProvider.GetCharacterSpawnDetails(portalInfoProvider.Map);
var positionTransform = playerGameObject.Components.GetComponent <IPositionTransform>().AssertNotNull();
positionTransform.Position = spawnPositionDetails.Position;
var directionTransform = playerGameObject.Components.GetComponent <IDirectionTransform>().AssertNotNull();
directionTransform.SetDirection(spawnPositionDetails.Direction);
}
void AddSceneObject()
{
var destinationScene = sceneContainer.GetSceneWrapper(portalInfoProvider.Map).AssertNotNull($"Could not find a scene with map {portalInfoProvider.Map}");
destinationScene.GetScene().AddSceneObject(playerGameObject);
// Setting a new scene.
presenceSceneProvider.SetScene(destinationScene.GetScene());
}
void FixInterestAreaSize()
{
var interestArea = playerGameObject.Components.GetComponent <IInterestArea>().AssertNotNull();
interestArea.SetSize();
}
void CreateBodyToNewWorld()
{
playerGameObject.CreateBody();
}
void ChangeCharacterLastMap()
{
characterServiceApi.ChangeCharacterMap(new ChangeCharacterMapParameters(userId, portalInfoProvider.Map));
}
}
public CreateCharacterResponseParameters?Handle(MessageData <CreateCharacterRequestParametersEx> messageData, ref MessageSendOptions sendOptions)
{
var userId = messageData.Parameters.UserId;
var characterClass = messageData.Parameters.CharacterClass;
var name = messageData.Parameters.Name;
var characterIndex = messageData.Parameters.Index;
if (databaseCharacterExistence.Exists(userId, characterIndex))
{
return(new CreateCharacterResponseParameters(CharacterCreationStatus.Failed));
}
if (databaseCharacterNameVerifier.Verify(name))
{
return(new CreateCharacterResponseParameters(CharacterCreationStatus.NameUsed));
}
databaseCharacterCreator.Create(userId, name, characterClass, characterIndex);
return(new CreateCharacterResponseParameters(CharacterCreationStatus.Succeed));
}
public async Task <TResponseParams> SendOperation <TRequestParams, TResponseParams>(IYield yield, byte operationCode, TRequestParams parameters)
where TRequestParams : struct, IParameters
where TResponseParams : struct, IParameters
{
var code = (TOperationCode)Enum.ToObject(typeof(TOperationCode), operationCode);
if (!IsConnected())
{
LogUtils.Log($"Failed to send {code} operation because there is no connection with a server.");
return(default(TResponseParams));
}
try
{
var requestId = operationRequestSender.Send(code, parameters, MessageSendOptions.DefaultReliable());
var responseParameters = await subscriptionProvider.ProvideSubscription <TResponseParams>(yield, requestId);
return(responseParameters);
}
catch (OperationNotHandledException)
{
LogUtils.Log($"Operation {code} not handled; sent a default operation response.");
return(default(TResponseParams));
}
}
public Task <ValidateCharacterResponseParameters?> Handle(IYield yield, MessageData <ValidateCharacterRequestParameters> messageData, ref MessageSendOptions sendOptions)
{
var parameters = new GetCharacterRequestParametersEx(userId, messageData.Parameters.CharacterIndex);
return(GetCharacter(yield, parameters));
}
private void UpdatePositionForOthers(Vector2 position)
{
var id = playerGameObjectGetter.GetPlayerGameObject().Id;
var directionTransform = playerGameObjectGetter.GetPlayerGameObject().Components.GetComponent <IDirectionTransform>().AssertNotNull();
var direction = directionTransform.Direction.GetDirectionsFromDirection();
var parameters = new SceneObjectPositionChangedEventParameters(id, position.X, position.Y, direction);
interestAreaNotifier.NotifySubscribers((byte)GameEvents.PositionChanged, parameters, MessageSendOptions.DefaultUnreliable((byte)GameDataChannels.Position));
}
public async Task <TResponseParams> SendOperation <TRequestParams, TResponseParams>(IYield yield, byte operationCode, TRequestParams parameters, MessageSendOptions messageSendOptions)
where TRequestParams : struct, IParameters
where TResponseParams : struct, IParameters
{
if (!IsConnected())
{
return(default(TResponseParams));
}
var code = (TOperationCode)Enum.ToObject(typeof(TOperationCode), operationCode);
var requestId = operationRequestSender.Send(code, parameters, messageSendOptions);
var responseParameters = await subscriptionProvider.ProvideSubscription <TResponseParams>(yield, requestId);
return(responseParameters);
}
public GameServersProviderResponseParameters?Handle(MessageData <EmptyParameters> messageData, ref MessageSendOptions sendOptions)
{
var gameServersInformation = new List <GameServerInformationParameters>();
foreach (var gameServerInformation in gameServersInformationProvider.Provide())
{
var name = gameServerInformation.Name;
var ip = gameServerInformation.IP;
var port = gameServerInformation.Port;
var connections = gameServerInformation.Connections;
var maxConnections = gameServerInformation.MaxConnections;
gameServersInformation.Add(new GameServerInformationParameters(name, ip, port, connections, maxConnections));
}
return(new GameServersProviderResponseParameters(gameServersInformation.ToArray()));
}
public EmptyParameters?Handle(MessageData <UpdateGameServerConnectionsInfoRequestParameters> messageData, ref MessageSendOptions sendOptions)
{
var connections = messageData.Parameters.Connections;
updateGameServerConnectionsInfo.Update(peerId, connections);
return(null);
}
public async Task <ValidateCharacterResponseParameters> ValidateCharacter(IYield yield, ValidateCharacterRequestParameters parameters)
{
var responseParameters = await ServerPeerHandler.SendOperation <ValidateCharacterRequestParameters, ValidateCharacterResponseParameters>
(yield, (byte)CharacterOperations.ValidateCharacter, parameters, MessageSendOptions.DefaultReliable());
if (responseParameters.Status == CharacterValidationStatus.Ok)
{
ServiceContainer.GameService.SetPeerLogic <GameScenePeerLogic, GameOperations, GameEvents>();
}
return(responseParameters);
}
public EmptyParameters?Handle(MessageData <ChangeCharacterMapParameters> messageData, ref MessageSendOptions sendOptions)
{
var userId = messageData.Parameters.UserId;
var map = messageData.Parameters.Map;
characterMapUpdater.Update(userId, (byte)map);
return(null);
}
private void AttackPlayer(int peerId, ISceneObject sceneObject, CollisionInfo collisionInfo)
{
isAttacking = true;
var positionTransform = sceneObject.Components.GetComponent <IPositionTransform>().AssertNotNull();
var orientation = (positionTransform.Position - collisionInfo.Position).Normalize();
direction = orientation.X < 0 ? -MOVE_DIRECTION : MOVE_DIRECTION;
RaisePlayerAttacked();
void RaisePlayerAttacked()
{
var parameters = new PlayerAttackedEventParameters(collisionInfo.Position.X, collisionInfo.Position.Y);
InterestAreaNotifier.NotifySubscriberOnly(peerId, (byte)GameEvents.PlayerAttacked, parameters, MessageSendOptions.DefaultUnreliable());
}
}
private void OnPositionChanged(Vector2 position)
{
var body = GetBody().AssertNotNull();
body.SetXForm(position.FromVector2(), body.GetAngle());
if (Vector2.Distance(position, lastPosition) > 0.1f)
{
UpdatePositionForAll();
lastPosition = position;
}
void UpdatePositionForAll()
{
var direction = directionTransform.Direction.GetDirectionsFromDirection();
var parameters = new SceneObjectPositionChangedEventParameters(Id, position.X, position.Y, direction);
InterestAreaNotifier.NotifySubscribers((byte)GameEvents.PositionChanged, parameters, MessageSendOptions.DefaultUnreliable((byte)GameDataChannels.Position));
}
}
public async Task <GetCharactersResponseParameters> GetCharacters(IYield yield)
{
return(await ServerPeerHandler.SendOperation <EmptyParameters, GetCharactersResponseParameters>
(yield, (byte)CharacterOperations.GetCharacters, new EmptyParameters(), MessageSendOptions.DefaultReliable()));
}
public EmptyParameters?Handle(MessageData <RegisterToUserProfileServiceRequestParameters> messageData, ref MessageSendOptions sendOptions)
{
var serverId = messageData.Parameters.ServerId;
onRegistered?.Invoke(serverId);
return(null);
}
public async Task <RemoveCharacterResponseParameters> RemoveCharacter(IYield yield, RemoveCharacterRequestParameters parameters)
{
return(await ServerPeerHandler.SendOperation <RemoveCharacterRequestParameters, RemoveCharacterResponseParameters>
(yield, (byte)CharacterOperations.RemoveCharacter, parameters, MessageSendOptions.DefaultReliable()));
}
