/// <inheritdoc/>
public async Task <string> PublishAsync(MatchMessage message, Region region, CancellationToken cancellationToken = default)
{
// Validate inputs
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (region == null)
{
throw new ArgumentNullException(nameof(region));
}
RequestValidationResult validationResult = message.Validate();
validationResult.Combine(region.Validate());
if (validationResult.Passed)
{
// Push to upstream data repository
return(await this._messageRepo.InsertAsync(message, region, cancellationToken));
}
else
{
throw new RequestValidationFailedException(validationResult);
}
}
/// <inheritdoc/>
public async Task <string> PublishAsync(SelfReportRequest request, long timeAtRequest, CancellationToken cancellationToken = default)
{
// Validate inputs
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
RequestValidationResult validationResult = request.Validate();
validationResult.Combine(Validator.ValidateTimestamp(timeAtRequest));
if (validationResult.Passed)
{
// Build MatchMessage from submitted content
MatchMessage message = new MatchMessage();
BluetoothMatch matches = new BluetoothMatch();
matches.Seeds.AddRange(request.Seeds);
// Store in data repository
message.BluetoothMatches.Add(matches);
return(await this._messageRepo.InsertAsync(message, request.Region, cancellationToken));
}
else
{
throw new RequestValidationFailedException(validationResult);
}
}
public void Update(float deltaTime, byte playerIndex)
{
MessageQueue.Clear();
var direction = m_input.GetDirection();
if (direction != PlayerDirection.None)
{
// MessageQueue.AddMessage(PlayerMove.Create(deltaTime, m_team, playerIndex, direction));
}
if (m_prevActionState != m_input.GetAction())
{
if (m_input.GetAction())
{
m_actionStartTime = Time.time;
}
else
{
var actionMsg = new Action();
actionMsg.m_duration = Time.time - m_actionStartTime;
var msg = new MatchMessage();
msg.m_messageType = MessageType.PlayerAction;
msg.m_message = actionMsg;
MessageQueue.AddMessage(msg);
}
m_prevActionState = m_input.GetAction();
}
}
/// <inheritdoc/>
public async Task <string> InsertAsync(MatchMessage message, Region region, CancellationToken cancellationToken = default)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (region == null)
{
throw new ArgumentNullException(nameof(region));
}
region = RegionHelper.AdjustToPrecision(region);
// Get allowed region boundary
RegionBoundary boundary = RegionHelper.GetRegionBoundary(region);
var record = new MatchMessageRecord(message)
{
RegionBoundary = new RegionBoundaryProperty(boundary),
Region = new RegionProperty(region),
PartitionKey = MatchMessageRecord.GetPartitionKey(region)
};
ItemResponse <MatchMessageRecord> response = await this.Container
.CreateItemAsync <MatchMessageRecord>(
record,
new PartitionKey(record.PartitionKey),
cancellationToken : cancellationToken
);
return(response.Resource.Id);
}
/// <inheritdoc/>
public async Task PublishAreaAsync(AreaMatch areaMatch, CancellationToken cancellationToken = default)
{
// Validate inputs
if (areaMatch == null)
{
throw new ArgumentNullException(nameof(areaMatch));
}
RequestValidationResult validationResult = areaMatch.Validate();
if (validationResult.Passed)
{
// Build a MatchMessage containing the submitted areas
MatchMessage message = new MatchMessage();
message.AreaMatches.Add(areaMatch);
// Define a regions for the published message
IEnumerable <Region> messageRegions = RegionHelper.GetRegionsCoverage(areaMatch.Areas, this.RegionPrecision);
// Publish
await this._messageRepo.InsertAsync(message, messageRegions, cancellationToken);
}
else
{
throw new RequestValidationFailedException(validationResult);
}
}
public async Task PublishAsync_SucceedsOnValidMessage()
{
// Arrange
string repoResponse = "00000000-0000-0000-0000-000000000001";
Region region = new Region
{
LatitudePrefix = 10.1234,
LongitudePrefix = -10.1234,
Precision = 4
};
MatchMessage request = new MatchMessage();
AreaMatch areaMatch = new AreaMatch
{
UserMessage = "Test user message"
};
areaMatch.Areas.Add(new Area
{
BeginTime = 0,
EndTime = 1,
Location = new Location
{
Latitude = 10.1234,
Longitude = -10.1234
},
RadiusMeters = 100
});
request.AreaMatches.Add(areaMatch);
BluetoothMatch btMatch = new BluetoothMatch
{
UserMessage = "Test BL message"
};
btMatch.Seeds.Add(new BlueToothSeed
{
Seed = "00000000-0000-0000-0000-000000000000",
SequenceEndTime = 1,
SequenceStartTime = 0
});
request.BluetoothMatches.Add(btMatch);
this._repo
.Setup(r => r.InsertAsync(It.IsAny <MatchMessage>(), It.IsAny <Region>(), CancellationToken.None))
.Returns(Task.FromResult(repoResponse));
// Act
string result = await this._service
.PublishAsync(request, region, CancellationToken.None);
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(repoResponse, result);
}
private void OnMessageReceived(BestHTTP.WebSocket.WebSocket ws, string message)
{
try
{
MatchMessage message2 = JsonConvert.DeserializeObject <MatchMessage>(message);
if (!string.IsNullOrEmpty(message2.userid))
{
if (string.IsNullOrEmpty(this.otheruserid))
{
this.otheruserid = message2.userid;
}
else if (this.otheruserid != message2.userid)
{
return;
}
}
switch (((MatchMessageType)message2.msgtype))
{
case MatchMessageType.eLearnSkill:
GameLogic.Hold.BattleData.Challenge_SendEvent("MatchDefenceTime_other_learn_skill", message2.argint);
return;
case MatchMessageType.eDead:
GameLogic.Hold.BattleData.Challenge_SendEvent("MatchDefenceTime_other_dead", null);
return;
case MatchMessageType.eReborn:
GameLogic.Hold.BattleData.Challenge_SendEvent("MatchDefenceTime_other_reborn", null);
return;
case MatchMessageType.eScoreUpdate:
GameLogic.Hold.BattleData.Challenge_SendEvent("MatchDefenceTime_other_updatescore", message2.argint);
return;
case MatchMessageType.eGameStart:
{
long argint = message2.argint;
GameLogic.Hold.BattleData.Challenge_UpdateMode(0x332d, BattleSource.eMatch);
GameLogic.Hold.BattleData.Challenge_SendEvent("MatchDefenceTime_set_random_seed", argint);
WindowUI.ShowWindow(WindowID.WindowID_Battle);
GameLogic.Hold.BattleData.Challenge_SendEvent("MatchDefenceTime_me_updatename", this.myname);
GameLogic.Hold.BattleData.Challenge_SendEvent("MatchDefenceTime_other_updatename", message2.nickname);
return;
}
case MatchMessageType.eGameEnd:
return;
}
}
catch
{
}
}
public ActionResult writeMessage(int playerid_, int matchid_, string text)
{
if (Session["id"] == null || Session["role"].ToString() != "user")
{
return(RedirectToRoute("login"));
}
if (playerid_ != Int32.Parse(Session["id"].ToString()))
{
return(RedirectToRoute("login"));
}
matchmessage = new MatchMessage();
matchmessage.addMessage(playerid_, matchid_, text);
return(Json("1"));
}
private void Update()
{
GameClient.Update();
if (!MatchSceneLoaded())
{
return;
}
if (m_matchStarted)
{
UpdateInput(Time.deltaTime);
while (true)
{
var msg = GameClient.GetMatchMessage();
if (msg == null)
{
break;
}
m_match.ProcessMessage(msg);
if (msg.m_messageType == MessageType.BallPosition)
{
var ballPosMsg = (BallPosition)msg.m_message;
m_msgSync.DiscardProcessedMssages(ballPosMsg.m_clientMsgNum);
}
if (msg.m_messageType == MessageType.PlayerPosition)
{
var playerPosMsg = (PlayerPosition)msg.m_message;
m_msgSync.DiscardProcessedMssages(playerPosMsg.m_clientMsgNum);
for (int i = 0; i < m_msgSync.Messages.Count; i++)
{
if (playerPosMsg.m_index == m_msgSync.Messages[i].m_playerIndex &&
playerPosMsg.m_team == m_msgSync.Messages[i].m_team)
{
var matchMessage = new MatchMessage();
matchMessage.m_messageType = MessageType.PlayerMove;
matchMessage.m_message = m_msgSync.Messages[i];
m_match.ProcessMessage(matchMessage);
}
}
}
}
}
}
/// <summary>
/// Calculates the size (in bytes) of a <see cref="MatchMessage"/>
/// </summary>
/// <param name="message">Source <see cref="MatchMessage"/></param>
/// <returns><see cref="MatchMessage"/> size, in bytes</returns>
public static long GetSize(MatchMessage message)
{
if (message != null)
{
// Serialize object into a byte array and return its size
MemoryStream stream = new MemoryStream();
Serializer.Serialize(stream, message);
return(stream.ToArray().Length);
}
else
{
throw new ArgumentNullException(nameof(message));
}
}
private void ProcessMessage(NetworkMessage msg)
{
switch (msg.m_type)
{
case NetworkMessageType.JoinAccept:
{
Debug.Log("Join Accept");
Team = ((JoinAccept)msg.m_msg).m_team;
break;
}
case NetworkMessageType.OpponentFound:
Debug.LogFormat("Opponent found: {0}", ((OpponentFound)msg.m_msg).m_playerName);
if (OpponentFound != null)
{
OpponentFound();
}
break;
case NetworkMessageType.StartMatch:
Debug.LogFormat("StartMatch");
if (MatchStarted != null)
{
MatchStarted();
}
break;
case NetworkMessageType.PlayerPosition:
{
var matchMsg = new MatchMessage();
matchMsg.m_messageType = MessageType.PlayerPosition;
matchMsg.m_message = msg.m_msg;
m_msgQueue.AddMessage(matchMsg);
break;
}
case NetworkMessageType.BallPosition:
{
var matchMsg = new MatchMessage();
matchMsg.m_messageType = MessageType.BallPosition;
matchMsg.m_message = msg.m_msg;
m_msgQueue.AddMessage(matchMsg);
break;
}
}
}
// team is ignored when sending from the client to the server.
public static MatchMessage Create(int messageNumber, byte team, byte playerIndex, float duration)
{
var payload = new Action();
payload.m_messageNumber = messageNumber;
payload.m_team = team;
payload.m_playerIndex = playerIndex;
payload.m_duration = duration;
var msg = new MatchMessage();
msg.m_messageType = MessageType.PlayerAction;
msg.m_message = payload;
return(msg);
}
public static MatchMessage Create(int messageNumber, float dt, byte team, byte playerIndex, PlayerDirection direction)
{
var payload = new PlayerMove();
payload.m_messageNumber = messageNumber;
payload.m_dt = dt;
payload.m_team = team;
payload.m_playerIndex = playerIndex;
payload.m_playerDirection = direction;
var msg = new MatchMessage();
msg.m_messageType = MessageType.PlayerMove;
msg.m_message = payload;
return(msg);
}
string GetMatchOrJoinMessage()
{
if (room != null)
{
var msg = new JoinMessage {
user_id = Player.id, room = room, last_id = receivedMessages[receivedMessages.Count - 1].id
};
return(JsonUtility.ToJson(msg));
}
else
{
var msg = new MatchMessage {
user_id = Player.id
};
return(JsonUtility.ToJson(msg));
}
}
/// <summary>
/// This method sends match state message to other players through Nakama server.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="opCode"></param>
/// <param name="message"></param>
public void SendMatchStateMessage <T>(MatchMessageType opCode, T message)
where T : MatchMessage <T>
{
try
{
//Packing MatchMessage object to json
string json = MatchMessage <T> .ToJson(message);
//Sending match state json along with opCode needed for unpacking message to server.
//Then server sends it to other players
_socket.SendMatchStateAsync(MatchId, (long)opCode, json);
}
catch (Exception e)
{
Debug.LogError("Error while sending match state: " + e.Message);
}
}
public void Send(MatchMessageType msgtype, int arg = 0)
{
if ((this.webSocket != null) && this.webSocket.IsOpen)
{
MatchMessage message = new MatchMessage();
this.myname = LocalSave.Instance.GetUserName();
message.userid = LocalSave.Instance.GetServerUserID().ToString();
if (this.myname == string.Empty)
{
this.myname = message.userid;
}
message.nickname = this.myname;
message.msgtype = (short)msgtype;
message.argint = arg;
this.Send(JsonConvert.SerializeObject(message));
}
}
public async Task PostAsync_OkWithMatchedParameters()
{
// Arrange
IEnumerable<string> ids = new string[]
{
"00000000-0000-0000-0000-000000000000",
"00000000-0000-0000-0000-000000000001"
};
MatchMessage result1 = new MatchMessage();
MatchMessage result2 = new MatchMessage();
IEnumerable<MatchMessage> toReturn = new List<MatchMessage>
{
result1,
result2
};
this._repo
.Setup(s => s.GetRangeAsync(ids, CancellationToken.None))
.Returns(Task.FromResult(toReturn));
MessageRequest request = new MessageRequest();
request.RequestedQueries.Add(new MessageInfo
{
MessageId = ids.ElementAt(0),
MessageTimestamp = 0
});
request.RequestedQueries.Add(new MessageInfo
{
MessageId = ids.ElementAt(1),
MessageTimestamp = 0
});
// Act
ActionResult<IEnumerable<MatchMessage>> controllerResponse = await this._controller
.PostAsync(request, CancellationToken.None);
// Assert
Assert.IsNotNull(controllerResponse);
Assert.IsInstanceOfType(controllerResponse.Result, typeof(OkObjectResult));
OkObjectResult castedResult = controllerResponse.Result as OkObjectResult;
Assert.IsInstanceOfType(castedResult.Value, typeof(List<MatchMessage>));
List<MatchMessage> listResult = castedResult.Value as List<MatchMessage>;
Assert.AreEqual(toReturn.Count(), listResult.Count());
}
public static MatchMessage Create(
int clientMsgNumber, byte team, byte index, Vector2 position, PlayerDirection direction)
{
var payload = new Slide()
{
m_clientMsgNum = clientMsgNumber,
m_team = team,
m_index = index,
m_position = position,
m_direction = direction,
};
var msg = new MatchMessage();
msg.m_messageType = MessageType.Slide;
msg.m_message = payload;
return(msg);
}
public ActionResult getMessagesString(int id)
{
matchmessage = new MatchMessage();
string[] text = matchmessage.getMessages(id);
string allMessages = "";
for (int i = 0; i < text.Length; i++)
{
if (i != text.Length - 1)
{
allMessages += text[i] + "\n";
}
else
{
allMessages += text[i];
}
}
return(Json(allMessages));
}
public async Task InsertAsync(MatchMessage message, IEnumerable <Region> regions, CancellationToken cancellationToken = default)
{
// Validate inputs
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
// Prepare records to insert (grouped by partition key)
var recordGroups = regions.Select(
r => new MatchMessageRecord(message)
{
RegionBoundary = new RegionBoundaryProperty(
RegionHelper.GetRegionBoundary(r)),
Region = new RegionProperty(r),
PartitionKey = MatchMessageRecord.GetPartitionKey(r)
}).GroupBy(r => r.PartitionKey);
// Begin batch operation
// All MatchMessageRecords will have same PartitionID in this batch
var batches = recordGroups.Select(g => g.Aggregate(
this.Container.CreateTransactionalBatch(new PartitionKey(g.Key)),
(result, item) => result.CreateItem <MatchMessageRecord>(item)));
// Execute transactions
// TODO: make a single transaction.
var responses = await Task.WhenAll(batches.Select(b => b.ExecuteAsync(cancellationToken)));
var failed = responses.Where(r => !r.IsSuccessStatusCode);
if (failed.Any())
{
throw new Exception(
String.Format(
"{0} out of {1} insertions failed. Cosmos bulk insert failed with HTTP Status Code {2}.",
responses.Count(),
failed.Count(),
failed.First().StatusCode.ToString()
)
);
}
}
public async Task <ActionResult <IEnumerable <MatchMessage> > > PostAsync([FromBody] MessageRequest request, CancellationToken cancellationToken = default)
{
try
{
// Submit request
IEnumerable <MessageContainer> reports = await this._reportService
.GetByIdsAsync(
request.RequestedQueries.Select(r => r.MessageId),
cancellationToken
);
// Map MatchMessage types
List <MatchMessage> messages = new List <MatchMessage>();
foreach (MessageContainer report in reports)
{
MatchMessage result = this._map.Map <MatchMessage>(report);
// Get BLEs
BluetoothMatch match = new BluetoothMatch();
match.Seeds.AddRange(
report.BluetoothSeeds.Select(s => this._map.Map <BlueToothSeed>(s))
);
// Add converted BLE match
result.BluetoothMatches.Add(match);
// Add converted MatchMessage
messages.Add(result);
}
// Return as expected proto type
return(Ok(messages));
}
catch (RequestValidationFailedException ex)
{
// Only return validation results
return(BadRequest(ex.ValidationResult));
}
catch (ArgumentNullException)
{
return(BadRequest());
}
}
public async Task PublishAsync_ArgumentNullOnNullRegion()
{
// Arrange
MatchMessage request = new MatchMessage();
AreaMatch areaMatch = new AreaMatch
{
UserMessage = "Test user message"
};
areaMatch.Areas.Add(new Area
{
BeginTime = 0,
EndTime = 1,
Location = new Location
{
Latitude = 10.1234,
Longitude = -10.1234
},
RadiusMeters = 100
});
request.AreaMatches.Add(areaMatch);
BluetoothMatch btMatch = new BluetoothMatch
{
UserMessage = "Test BL message"
};
btMatch.Seeds.Add(new BlueToothSeed
{
Seed = "00000000-0000-0000-0000-000000000000",
SequenceEndTime = 1,
SequenceStartTime = 0
});
request.BluetoothMatches.Add(btMatch);
// Act
string result = await this._service
.PublishAsync(request, null, CancellationToken.None);
// Assert
// Exception caught by decorator
}
public void ProcessMessage(GameServer gameServer, NetworkMessage netMsg, INetworkAddress address)
{
if (!gameServer.IsClientConnected(address))
{
Debug.LogFormat("Received the message {0} from not connected client {1}", netMsg.m_type, address.ToString());
return;
}
var clientInfo = gameServer.GetClientInfoByAddress(address);
switch (netMsg.m_type)
{
case NetworkMessageType.PlayerMove:
{
var playerMove = netMsg.m_msg as PlayerMove;
playerMove.m_team = clientInfo.Team;
MatchMessage matchMsg = new MatchMessage();
matchMsg.m_message = playerMove;
matchMsg.m_messageType = MessageType.PlayerMove;
gameServer.AddMatchMessage(matchMsg);
// Not sure it it supposed to be here.
clientInfo.LastMsgNum = Mathf.Max(clientInfo.LastMsgNum, playerMove.m_messageNumber);
break;
}
case NetworkMessageType.PlayerAction:
{
var msg = netMsg.m_msg as Action;
msg.m_team = clientInfo.Team;
MatchMessage matchMsg = new MatchMessage();
matchMsg.m_message = msg;
matchMsg.m_messageType = MessageType.PlayerAction;
gameServer.AddMatchMessage(matchMsg);
// Not sure it it supposed to be here.
clientInfo.LastMsgNum = Mathf.Max(clientInfo.LastMsgNum, msg.m_messageNumber);
break;
}
}
}
public void ProcessMessage(Match match, MatchMessage message)
{
switch (message.m_messageType)
{
case MessageType.PlayerMove:
var playerMoveMsg = message.m_message as PlayerMove;
var moveVector = PlayerDirectionVector.GetVector(playerMoveMsg.m_playerDirection) * GameSettings.PlayerSpeed;
match.SetPlayerPosition(
playerMoveMsg.m_team,
0,
match.GetPlayerPosition(playerMoveMsg.m_team, 0) + moveVector * playerMoveMsg.m_dt,
playerMoveMsg.m_playerDirection);
break;
case MessageType.PlayerAction:
var playerActionMsg = message.m_message as Action;
match.PlayerAction(playerActionMsg.m_team, playerActionMsg.m_duration);
break;
case MessageType.Slide:
var slide = message.m_message as Slide;
match.SetPlayerPosition(slide.m_team, slide.m_index, new Vector3(slide.m_position.x, 0.0f, slide.m_position.y), slide.m_direction);
match.Slide(slide.m_team, slide.m_index);
break;
case MessageType.PlayerPosition:
var playerPositionMsg = message.m_message as PlayerPosition;
match.SetPlayerPosition(playerPositionMsg.m_team, playerPositionMsg.m_index, playerPositionMsg.m_position, playerPositionMsg.m_direction);
break;
case MessageType.BallPosition:
var ballPositionMsg = message.m_message as BallPosition;
match.SetBallPosition(ballPositionMsg.m_position, ballPositionMsg.m_velocity);
break;
}
}
public void AddMatchMessage(MatchMessage msg)
{
m_gameMsgQueue.AddMessage(msg);
}
public void SendMessage(MatchMessage message)
{
// m_netCom.SendMessage(message);
}
public void ProcessMessage(MatchMessage message)
{
m_messageInterpreter.ProcessMessage(this, message);
}
public abstract byte[] Serialize(MatchMessage message);
public override void UpdateListeners()
{
NetIncomingMessage msg;
while ((msg = client.ReadMessage()) != null)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.DebugMessage:
case NetIncomingMessageType.VerboseDebugMessage:
Debug.Log(msg.ReadString());
break;
case NetIncomingMessageType.WarningMessage:
Debug.LogWarning(msg.ReadString());
break;
case NetIncomingMessageType.ErrorMessage:
Debug.LogError(msg.ReadString());
break;
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte();
string statusMsg = msg.ReadString();
switch (status)
{
case NetConnectionStatus.Disconnected:
if (Disconnected != null)
{
Disconnected(this, new DisconnectArgs(statusMsg));
}
break;
default:
Debug.Log("Status change received: " + status + " - Message: " + statusMsg);
break;
}
break;
case NetIncomingMessageType.Data:
switch (msg.ReadByte())
{
case MessageType.MatchMessage:
double timestamp = msg.ReadTime(false);
MatchMessage message = Newtonsoft.Json.JsonConvert.DeserializeObject <MatchMessage>(msg.ReadString(), serializerSettings);
//Use reflection to call ReceiveMessage with the proper type parameter
MethodInfo methodToCall = typeof(OnlineMatchMessenger).GetMethod("ReceiveMessage", BindingFlags.NonPublic | BindingFlags.Instance);
MethodInfo genericVersion = methodToCall.MakeGenericMethod(message.GetType());
genericVersion.Invoke(this, new object[] { message, timestamp });
break;
case MessageType.PlayerMovementMessage:
double time = msg.ReadTime(false);
PlayerMovement movement = PlayerMovement.ReadFromMessage(msg);
if (OnPlayerMovement != null)
{
OnPlayerMovement(this, new PlayerMovementArgs(time, movement));
}
break;
}
break;
default:
Debug.Log("Received unhandled message of type " + msg.MessageType);
break;
}
}
}
public void AddMessage(MatchMessage message)
{
m_messages.Enqueue(message);
}
