public List <PlayerResponse> GetPlayers()
{
_log.LogInformation($"Get all players");
return(_gameContext.Players
.Select(x => PlayerResponse.FromPlayer(x))
.ToList());
}
private void OnStatusChanged(PlayerResponse playerResponse)
{
if (visualizeFeedback == false)
{
return;
}
if (_changedFeedback == null)
{
return;
}
lock (_changedFeedback)
{
foreach (var status in playerResponse.Status)
{
var pos = EnumParser.ToPositionType(status.Key);
var val = status.Value;
byte[] result = new byte[val.Length];
for (int i = 0; i < val.Length; i++)
{
result[i] = (byte)val[i];
}
var feedback = new HapticFeedback(pos, result);
_changedFeedback.Add(feedback);
}
}
}
public void SetResponse(string hashPlayer, PlayerResponse response)
{
if (playersRoundInfo.ContainsKey(hashPlayer))
{
playersRoundInfo[hashPlayer].playerResponse = response;
}
}
public void Receive(PlayerResponse response)
{
try
{
lock (activeKeys)
{
activeKeys.Clear();
activeKeys.AddRange(response.ActiveKeys);
}
lock (registered)
{
registered.Clear();
registered.AddRange(response.RegisteredKeys);
}
lock (status)
{
status = response.Status;
}
}
catch (Exception e)
{
BhapticsLogger.LogInfo("Receive: {0}", e.Message);
}
}
public List <PlayerResponse> GetPlayers(string gameId)
{
return(_gameContext.Players
.Where(p => p.GameId == gameId)
.Select(p => PlayerResponse.FromPlayer(p))
.ToList());
}
/// <summary>
/// This event is fired when the 'SelectButton' is clicked.
/// </summary>
private void SelectButton_Click(object sender, EventArgs e)
{
// the user did not cancel
this.UserCancelled = false;
// If the ParentChipSelectorForm object exists
if (this.HasParentChipSelectorForm)
{
// if the PlayerResponseControl exists
if ((this.HasPlayerResponseControl) && (this.PlayerResponseControl.HasSendResponseCallBack) && (this.HasHouseRules))
{
// get the amountBet
double amountBet = this.AmountBet;
// Create a place bet response request
PlayerResponse playerResponse = new PlayerResponse(ResponseTypeEnum.PlaceBet, amountBet);
// Send the response
this.PlayerResponseControl.SendResponseCallBack(playerResponse);
// The response has been sent
this.PlayerResponseControl.ResponseSent = true;
}
// Close the parent form
this.ParentChipSelectorForm.Close();
}
}
public Player(PlayerResponse response)
{
SteamId = response.steamid;
PersonaName = response.personaname;
ProfileUrl = response.profileurl;
Avatar = response.avatar;
AvatarMedium = response.avatarmedium;
AvatarFull = response.avatarfull;
PersonaState = response.personastate;
CommunityVisibilityState = response.communityvisibilitystate;
ProfileState = response.profilestate;
LastLogoff = response.lastlogoff;
CommentPermission = response.commentpermission;
RealName = response.realname;
PrimaryClanId = response.primaryclanid;
TimeCreated = response.timecreated;
GameId = response.gameid;
GameServerIp = response.gameserverip;
GameExtraInfo = response.gameextrainfo;
CityId = response.cityid;
LocCountryCode = response.loccountrycode;
LocStateCode = response.locstatecode;
LocCityId = response.loccityid;
}
public void Receive(PlayerResponse response)
{
try
{
if (StatusReceived != null)
{
StatusReceived(response);
}
lock (_activeKeys)
{
_activeKeys.Clear();
_activeKeys.AddRange(response.ActiveKeys);
}
lock (_activePosition)
{
_activePosition.Clear();
_activePosition.AddRange(response.ConnectedPositions);
}
}
catch (Exception e)
{
Debug.Log(e);
}
}
public Exchange(ConversationOpener opener, PlayerResponse response1, PlayerResponse response2, PlayerResponse response3)
{
Opener = opener;
PlayerResponse1 = response1;
PlayerResponse2 = response2;
PlayerResponse3 = response3;
}
public Player ToPlayer(PlayerResponse playerResponse)
{
return(new Player
{
User = ToUser(ToPlayer(playerResponse))
});
}
public override ThreeState CheckIfCorrectResponse(PlayerResponse response)
{
var allowedResponses = responseFromPlayer.Split(new char[] { '|' }).Select(s => s.Trim().ToLower());
bool isResponseOk = allowedResponses.Any(s => s == response.responseStr.ToLower().Trim());
return(isResponseOk.ToThreeState());
}
public PlayerViewModel(PlayerResponse player)
{
Id = player.Id;
PlayerName = player.PlayerName;
FirstName = player.FirstName;
LastName = player.LastName;
Colour = player.Colour;
}
public override ThreeState CheckIfCorrectResponse(PlayerResponse response) {
if (response.pathInOrder) {
return response.playerPath.ArePointsInCorrectOrder().ToThreeState();
}
else {
return response.playerPath.WereAllPointsTraversed().ToThreeState();
}
}
public Player(PlayerResponse response)
{
PlayerKey = response.PlayerKey;
PlayerId = response.PlayerId;
FullName = response.Name.Full;
TeamAbbr = response.TeamAbbr;
Position = response.Position;
}
public void GetPlayer(int[] ids, PlayerResponse playerResponse)
{
PlayerResponse res = new PlayerResponse(playerResponse);
string[] keys = { "ids" };
string[] vals = { string.Join("|", ids) };
Debug.Log(BuildURL("findbyid", keys, vals));
SendAPIRequest(BuildURL("findbyid", keys, vals), (req) => HandlePlayerResponse(req, res));
}
public override void Respond(PlayerResponse response)
{
OnResponseGiven?.Invoke(this, new PlayerResponseEventArgs(response));
if (response == PlayerResponse.Missed)
{
OnTurnStarted?.Invoke(this, new EventArgs());
}
}
public static Player MapPlayer(PlayerResponse playerData)
{
return(new Player
{
MatchHistoryUri = playerData.MatchHistoryUri,
ProfileIcon = playerData.ProfileIcon,
SummonerId = playerData.SummonerId,
SummonerName = playerData.SummonerName
});
}
public override ThreeState CheckIfCorrectResponse(PlayerResponse response)
{
if (response.pathInOrder)
{
return(response.playerPath.ArePointsInCorrectOrder().ToThreeState());
}
else
{
return(response.playerPath.WereAllPointsTraversed().ToThreeState());
}
}
public async Task <IActionResult> OnGet(int id)
{
Player = await _apiClient.GetPlayerAsync(id);
if (Player == null)
{
return(NotFound());
}
return(Page());
}
public ViewResult ManagePlayers(PlayerResponse playerResponse)
{
if (ModelState.IsValid)
{
PlayerRepository.AddResponse(playerResponse);
return(View("ClubDetails", PlayerRepository.PlayerResponses.Where(r => r.Deregister == false).OrderBy(r => r.ClubID)));
}
else
{
return(View());
}
}
/// <summary>
/// Handle a response from a communcation channel (to be expanded)
/// </summary>
/// <param name="response"></param>
private void HandleResponse(PlayerResponse response)
{
if (!openingDone)
{
openingDone = true;
maze.OpenDoorsInCell(playerCurrentCoords);
}
//if there was no interchange, no response was expected, so do nothing
if (currentInterchange == null)
{
return;
}
//otherwise, check response, change state, and respond as needed
else
{
//reopen doors if they were closed
maze.OpenDoorsInCell(playerCurrentCoords);
ThreeState wasResponseCorrect = currentInterchange.CheckIfCorrectResponse(response);
Debug.Log(wasResponseCorrect.ToBool());
Debug.Log(response.responseStr);
string responseText = currentInterchange.GetResponseToPlayerText(wasResponseCorrect.ToBool());
SendMessageToPlayer(responseText, oneWayCommChannel);
//ending condition for veryhostile
if (aiAlignmentState == AIAlignmentState.VeryHostile)
{
if (wasResponseCorrect == ThreeState.True)
{
AscendPlayer();
gameOver = true;
}
else
{
ReduceMazeToOneRoom();
}
}
//otherwise do state transition if need be
else if (wasResponseCorrect != ThreeState.Neutral &&
!aiAlignmentState.ToString().StartsWith("Very"))
{
StateTransition(wasResponseCorrect.ToBool());
}
//reset current interchange to get caught by above conditional.
currentInterchange = null;
}
}
public void Added(
PlayerResponse response,
HubConnectionInfo connectionInfo,
IHandler composer)
{
var player = response.Player;
_logger.LogInformation($"Player {player.Id} created ({player.Name})");
if (player.Name == "Pele")
{
composer.DisconnectHub(connectionInfo.Url);
}
}
public async Task <Response> GetUserByEmail(
string urlBase,
string servicePrefix,
string controller,
string tokenType,
string accessToken,
EmailRequest request)
{
try
{
string requestString = JsonConvert.SerializeObject(request);
StringContent content = new StringContent(requestString, Encoding.UTF8, "application/json");
HttpClient client = new HttpClient
{
BaseAddress = new Uri(urlBase)
};
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(tokenType, accessToken);
string url = $"{servicePrefix}{controller}";
HttpResponseMessage response = await client.PostAsync(url, content);
string result = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
return(new Response
{
IsSuccess = false,
Message = result,
});
}
PlayerResponse playerResponse = JsonConvert.DeserializeObject <PlayerResponse>(result);
return(new Response
{
IsSuccess = true,
Result = playerResponse
});
}
catch (Exception ex)
{
return(new Response
{
IsSuccess = false,
Message = ex.Message
});
}
}
public async Task <(PlayersRepositoryStatus Status, PlayerResponse Player)> GetSingle(int id)
{
var player = await _dbContext.Players.FindAsync(id);
if (player == null)
{
return(PlayersRepositoryStatus.NotFound, null);
}
var playerResponse = new PlayerResponse
{
Name = player.Name,
Id = player.PlayerId
};
return(PlayersRepositoryStatus.Found, playerResponse);
}
// Get: api/Player
public IHttpActionResult Get()
{
List <Player> playerList = new List <Player>();
List <PlayerResponse> responseList = new List <PlayerResponse>();
using (Refresh_The_PageEntities entities = new Refresh_The_PageEntities())
{
playerList = entities.Players.ToList();
}
foreach (Player player in playerList)
{
responseList.Add(PlayerResponse.DataToResponse(player));
}
string json = JsonConvert.SerializeObject(responseList);
return(new OkResult(json, Request));
}
// Get: api/Player/1
public IHttpActionResult Get(string id)
{
Player player;
using (Refresh_The_PageEntities entities = new Refresh_The_PageEntities())
{
player = entities.Players.FirstOrDefault(e => e.Id == id);
}
if (player == null)
{
return(NotFound());
}
PlayerResponse response = PlayerResponse.DataToResponse(player);
string json = JsonConvert.SerializeObject(response);
return(new OkResult(json, Request));
}
private List <RecordResponse> TransformRecordData(IEnumerable <RecordWithZonedData> recordBase)
{
var output = recordBase.Select(x =>
{
var cachedRecord = x.Record as CachedTempusRecordBase;
return(new RecordResponse
{
PlayerInfo = new PlayerResponse
{
Id = x.Record.PlayerInfo.Id,
Steamid = x.Record.PlayerInfo.Steamid,
Name = x.Record.PlayerInfo.Name,
RealName = null
},
CachedTime = cachedRecord?.CachedTime,
MapInfo = x.Record.MapInfo,
RecordInfo = x.Record.RecordInfo,
ZoneInfo = x.Record.ZoneInfo
});
}).ToList();
foreach (var record in output)
{
var realName = _tempusCacheService.GetRealName(record.PlayerInfo.Id);
if (realName == null)
{
continue;
}
var realNamePlayer = new PlayerResponse
{
Id = record.PlayerInfo.Id,
Name = record.PlayerInfo.Name,
Steamid = record.PlayerInfo.Steamid,
RealName = realName
};
record.PlayerInfo = realNamePlayer;
}
return(output);
}
/// <summary>
/// Gets all active players on a server
/// </summary>
/// <returns>PlayerResponse containing all players </returns>
/// <exception cref="SourceQueryException"></exception>
public PlayerResponse GetPlayers(int maxRetries = 10)
{
try
{
var byteReader = RequestDataFromServer(Constants.A2S_PLAYER_CHALLENGE_REQUEST, out byte header, maxRetries, true);
if (!header.Equals(Constants.A2S_PLAYER_RESPONSE))
{
throw new ArgumentException("Response was no player response.");
}
PlayerResponse playerResponse = new PlayerResponse()
{
Header = header, Players = new List <Player>()
};
int playercount = byteReader.GetByte();
for (int i = 1; i <= playercount; i++)
{
playerResponse.Players.Add(new Player()
{
Index = byteReader.GetByte(),
Name = byteReader.GetString(),
Score = byteReader.GetLong(),
Duration = TimeSpan.FromSeconds(byteReader.GetFloat())
});
}
//IF more bytes == THE SHIP
if (byteReader.Remaining > 0)
{
playerResponse.IsTheShip = true;
for (int i = 0; i < playercount; i++)
{
playerResponse.Players[i].Deaths = byteReader.GetLong();
playerResponse.Players[i].Money = byteReader.GetLong();
}
}
return(playerResponse);
}
catch (Exception ex)
{
throw new SourceQueryException("Could not gather Players", ex);
}
}
private async void UpdatePredictionAsync()
{
bool isValid = await ValidateDataAsync();
if (!isValid)
{
return;
}
string url = App.Current.Resources["UrlAPI"].ToString();
if (!_apiService.CheckConnection())
{
await App.Current.MainPage.DisplayAlert(
"Error",
"Verifique su conexión a Internet",
"Aceptar");
return;
}
PlayerResponse player = JsonConvert.DeserializeObject <PlayerResponse>(Settings.Player);
TokenResponse token = JsonConvert.DeserializeObject <TokenResponse>(Settings.Token);
PredictionRequest request = new PredictionRequest
{
GoalsLocal = GoalsLocal.Value,
GoalsVisitor = GoalsVisitor.Value,
MatchId = Match.Id,
UserId = new Guid(player.UserId),
};
Response response = await _apiService.MakePredictionAsync(url, "api", "/Predictions", request, "bearer", token.Token);
if (!response.IsSuccess)
{
await App.Current.MainPage.DisplayAlert(
"Error",
response.Message,
"Aceptar");
}
}
public GameStatusResponse GetStatusResponse(string gameId, string playerId)
{
var status = GetStatus(gameId);
if (status == null)
{
return(null);
}
var gameStatus = GameStatusResponse.FromStatus(status);
gameStatus.IsCurrentChoice = status.ChoosingPlayerId == playerId;
gameStatus.RemainingQuestions = RemainingQuestions(gameId);
// Return previous choice
if (!gameStatus.IsCurrentChoice)
{
gameStatus.ChoiceA = _playData.GetPreviousChoiceA();
gameStatus.ChoiceB = _playData.GetPreviousChoiceB();
}
else if (gameStatus.ChoiceA == null || gameStatus.ChoiceB == null)
{
// TODO: Something with EF not populating the object, can look at it later
var choiceA = _gameContext.Answers.Find(status.ChoiceAId);
var choiceB = _gameContext.Answers.Find(status.ChoiceBId);
gameStatus.ChoiceA = AnswerResponse.FromAnswer(choiceA);
gameStatus.ChoiceB = AnswerResponse.FromAnswer(choiceB);
}
if (gameStatus.ChoosingPlayer == null)
{
var player = _gameContext.Players.Find(status.ChoosingPlayerId);
if (player != null)
{
gameStatus.ChoosingPlayer = PlayerResponse.FromPlayer(player);
gameStatus.ChoosingPlayer.IsChoosing = true;
}
}
return(gameStatus);
}
public void Init()
{
_responseStub = new Response
{
Code = 1,
Msg = "Fake message"
};
var player = new PlayerResponse
{
PublicId = "publicId",
AccessToken = "Token",
Name = "PlayerName",
Items = { "item1", "item2" },
Health = 2.10
};
var npc = new NPC
{
Name = "NPC_NAME",
PublicId = "NPC_publicID",
Health = 10.3
};
var bigResponse = new BigMessageResponse
{
Player = player,
Npcs = { { "npc_key", npc } },
Chests = { "chest1", "chest2" }
};
_bigMessageStub = new BigMessage
{
Code = "22",
Response = bigResponse
};
_respondeMessageEncodeJson = Encoding.UTF8.GetBytes("{\"code\": 1,\"msg\":\"Fake message\"}");
_bigMessageEncodedJson = Encoding.UTF8.GetBytes("{\"code\":\"22\",\"response\":{\"player\":{\"publicId\":\"publicId\",\"accessToken\":\"Token\",\"name\":\"PlayerName\",\"items\":[\"item1\",\"item2\"],\"health\":2.1},\"npcs\":{\"npc_key\":{\"name\":\"NPC_NAME\",\"health\":10.3,\"publicId\":\"NPC_publicID\"}},\"chests\":[\"chest1\",\"chest2\"]}}");
_bigMessageEncodedProtobuf = new byte[] { 0x0A, 0x02, 0x32, 0x32, 0x12, 0x74, 0x0A, 0x34, 0x0A, 0x08, 0x70, 0x75, 0x62, 0x6C, 0x69, 0x63, 0x49, 0x64, 0x12, 0x05, 0x54, 0x6F, 0x6B, 0x65, 0x6E, 0x1A, 0x0A, 0x50, 0x6C, 0x61, 0x79, 0x65, 0x72, 0x4E, 0x61, 0x6D, 0x65, 0x22, 0x05, 0x69, 0x74, 0x65, 0x6D, 0x31, 0x22, 0x05, 0x69, 0x74, 0x65, 0x6D, 0x32, 0x29, 0xCD, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0x00, 0x40, 0x12, 0x2C, 0x0A, 0x07, 0x6E, 0x70, 0x63, 0x5F, 0x6B, 0x65, 0x79, 0x12, 0x21, 0x0A, 0x08, 0x4E, 0x50, 0x43, 0x5F, 0x4E, 0x41, 0x4D, 0x45, 0x11, 0x9A, 0x99, 0x99, 0x99, 0x99, 0x99, 0x24, 0x40, 0x1A, 0x0C, 0x4E, 0x50, 0x43, 0x5F, 0x70, 0x75, 0x62, 0x6C, 0x69, 0x63, 0x49, 0x44, 0x1A, 0x06, 0x63, 0x68, 0x65, 0x73, 0x74, 0x31, 0x1A, 0x06, 0x63, 0x68, 0x65, 0x73, 0x74, 0x32 };
_responseEncoded = new ProtobufSerializer(ProtobufSerializer.SerializationFormat.Protobuf).Encode(_responseStub);
}
public abstract ThreeState CheckIfCorrectResponse(PlayerResponse response);
private void Update() {
//if in communcation, check for response, call handler on response if there
if (aiCommState == AICommunicationState.InCommunication) {
if (currentCommChannel != null && currentCommChannel.IsResponseReceived()) {
playerResponse = currentCommChannel.GetResponse();
//end communcation and reset state
currentCommChannel.EndCommuncation();
currentCommChannel = null;
aiCommState = AICommunicationState.NotInCommuncation;
//handle whatever the response was
HandleResponse(playerResponse);
}
}
else if (!openingDone) {
Debug.LogError("about to close doors in cell opening");
maze.CloseDoorsInCell(playerCurrentCoords);
SendMessageToPlayer(GameLinesTextGetter.OpeningMonologue(), oneWayCommChannel);
}
else if (playerCurrentCoords != player.MazeCellCoords &&
DistanceBetweenPlayerAndRoom(player.MazeCellCoords) < 0.4) {
//neutral ending. ends on reaching the ladder
if (player.MazeCellCoords == maze.exitCoords && !aiAlignmentState.ToString().StartsWith("Very")) {
FlyoverMonologueEnding();
}
//very friendly ending. end condition on the last room
else if (aiAlignmentState == AIAlignmentState.VeryFriendly
&& player.MazeCellCoords.z == (maze.size.z - 1)) {
maze.TurnAllLightsRed();
Debug.LogError("about to close doors in cell friendlyending");
maze.CloseDoorsInCell(player.MazeCellCoords);
gameOver = true;
}
//the standard case. do a reaction or request
else {
//for the single hallway ending. close doors behind you.
if (aiAlignmentState == AIAlignmentState.VeryFriendly) {
Debug.LogError("about to close doors in cell friendlyending close behind");
maze.CloseDoorsInCell(playerCurrentCoords);
}
playerCurrentCoords = player.MazeCellCoords;
if (!firstInterchangeDone) {
Neutral_Request_AskPlayerToTouchCorners();
firstInterchangeDone = true;
}
else {
if (reactToPlayer) {
ExecuteRandomAction(perStateReactionList[aiAlignmentState]);
//react to player next time only if VeryHostile, VeryFriendly and there are reactions left
reactToPlayer = (aiAlignmentState.ToString().StartsWith("Very")) &&
perStateReactionList[aiAlignmentState].Count > 0;
}
else {
if (!roomsRequestedIn.ContainsKey(playerCurrentCoords)) {
ExecuteRandomAction(perStateRequestActionList[aiAlignmentState]);
roomsRequestedIn[playerCurrentCoords] = true;
}
//on occasion, prompt a reaction from the AI on the next room
reactToPlayer = (UnityEngine.Random.Range(0, 1f) < 0.75f);
}
}
}
}
}
public override ThreeState CheckIfCorrectResponse(PlayerResponse response) {
return (!response.playerMoved).ToThreeState();
}
public override ThreeState CheckIfCorrectResponse(PlayerResponse response) {
return ThreeState.Neutral;
}
public AiPlayerInterchange(AIAlignmentState state) {
aiState = state;
expectedResponse = new PlayerResponse();
}
public override ThreeState CheckIfCorrectResponse(PlayerResponse response) {
var allowedResponses = responseFromPlayer.Split(new char[] { '|' }).Select(s => s.Trim().ToLower());
bool isResponseOk = allowedResponses.Any(s => s == response.responseStr.ToLower().Trim());
return isResponseOk.ToThreeState();
}
public TouchCornersInterchange(AIAlignmentState state, PlayerResponse response) : base(state, response) { }
public PathInterchange(AIAlignmentState state, PlayerResponse expected, bool firstInterchange)
: base(state, expected, firstInterchange) { }
public PathInterchange(AIAlignmentState state, PlayerResponse expected) : base(state, expected) { }
/// <summary>
/// Handle a response from a communcation channel (to be expanded)
/// </summary>
/// <param name="response"></param>
private void HandleResponse(PlayerResponse response) {
if (!openingDone) {
openingDone = true;
maze.OpenDoorsInCell(playerCurrentCoords);
}
//if there was no interchange, no response was expected, so do nothing
if (currentInterchange == null) {
return;
}
//otherwise, check response, change state, and respond as needed
else {
//reopen doors if they were closed
maze.OpenDoorsInCell(playerCurrentCoords);
ThreeState wasResponseCorrect = currentInterchange.CheckIfCorrectResponse(response);
Debug.Log(wasResponseCorrect.ToBool());
Debug.Log(response.responseStr);
string responseText = currentInterchange.GetResponseToPlayerText(wasResponseCorrect.ToBool());
SendMessageToPlayer(responseText, oneWayCommChannel);
//ending condition for veryhostile
if (aiAlignmentState == AIAlignmentState.VeryHostile) {
if (wasResponseCorrect == ThreeState.True) {
AscendPlayer();
gameOver = true;
}
else {
ReduceMazeToOneRoom();
}
}
//otherwise do state transition if need be
else if (wasResponseCorrect != ThreeState.Neutral &&
!aiAlignmentState.ToString().StartsWith("Very")) {
StateTransition(wasResponseCorrect.ToBool());
}
//reset current interchange to get caught by above conditional.
currentInterchange = null;
}
}
public AiPlayerInterchange(AIAlignmentState state, PlayerResponse expected, bool firstInterchange) {
aiState = state;
expectedResponse = expected;
isFirst = firstInterchange;
}
public AiPlayerInterchange(AIAlignmentState state, PlayerResponse expected) {
aiState = state;
expectedResponse = expected;
}
