private void AddChallengeEntry(string name)
{
// Create ChallengeEntry
ChallengeEntry ChallengeEntry = new ChallengeEntry {
name = name
};
// Load saved Challenges
string jsonString = PlayerPrefs.GetString("challengesTable2");
Challenges Challenges = JsonUtility.FromJson <Challenges>(jsonString);
if (Challenges == null)
{
// There's no stored table, initialize
Challenges = new Challenges()
{
ChallengeEntryList = new List <ChallengeEntry>()
};
}
// Add new entry to Challenges
Challenges.ChallengeEntryList.Add(ChallengeEntry);
// Save updated Challenges
string json = JsonUtility.ToJson(Challenges);
PlayerPrefs.SetString("challengesTable2", json);
PlayerPrefs.Save();
}
public async Task<ChallengeEntry> AddToDb(ChallengeEntry challengeEntry)
{
await _dbContext.ChallengeEntries.AddAsync(challengeEntry);
await _dbContext.SaveChangesAsync();
return challengeEntry;
}
public async Task ShouldReturnFalseIfEntryIsInvalid(string challengeElement1, string challengeElement2,
string balance)
{
_mockAccountRepository.Setup(x => x.Get(It.IsAny <string>(), AccountFieldsSelection.ChallengePayeSchemes))
.Returns(Task.FromResult(new Account()));
_mockChallengeRepository.Setup(x => x.CheckData(It.IsAny <Account>(), It.IsAny <ChallengePermissionQuery>()))
.Returns(Task.FromResult(true));
//Arrange
var challengeEntry = new ChallengeEntry
{
Id = "qwerty",
Balance = balance,
Url = string.Empty,
FirstCharacterPosition = "1",
SecondCharacterPosition = "2",
Challenge1 = challengeElement1,
Challenge2 = challengeElement2
};
var message = new ChallengePermissionQuery(challengeEntry);
//Act
var result = await _sut.Handle(message);
//Assert
result.IsValid.Should().Be(false);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
switch (version)
{
case 0:
this.m_Challenger = reader.ReadMobile();
this.m_Organizers.Add(this.m_Challenger);
this.m_GameLocked = reader.ReadBool();
this.m_GameInProgress = reader.ReadBool();
this.m_TotalPurse = reader.ReadInt();
this.m_EntryFee = reader.ReadInt();
this.m_ArenaSize = reader.ReadInt();
this.m_TargetScore = reader.ReadInt();
this.m_DeathBall = (DeathBall)reader.ReadItem();
int count = reader.ReadInt();
for (int i = 0; i < count; i++)
{
ChallengeEntry entry = new ChallengeEntry();
entry.Participant = reader.ReadMobile();
string sname = reader.ReadString();
// look up the enum by name
ChallengeStatus status = ChallengeStatus.None;
try
{
status = (ChallengeStatus)Enum.Parse(typeof(ChallengeStatus), sname);
}
catch
{
}
entry.Status = status;
entry.Accepted = reader.ReadBool();
entry.PageBeingViewed = reader.ReadInt();
entry.Score = reader.ReadInt();
entry.Winner = reader.ReadBool();
entry.Team = reader.ReadInt();
this.Participants.Add(entry);
}
break;
}
if (this.GameCompleted)
{
Timer.DelayCall(this.PostGameDecayTime, new TimerCallback(Delete));
}
// start the challenge timer
this.StartChallengeTimer();
this.SetNameHue();
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
switch (version)
{
case 0:
m_Challenger = reader.ReadMobile();
m_Organizers.Add(m_Challenger);
m_GameLocked = reader.ReadBool();
m_GameInProgress = reader.ReadBool();
m_TotalPurse = reader.ReadInt();
m_EntryFee = reader.ReadInt();
m_ArenaSize = reader.ReadInt();
m_TargetScore = reader.ReadInt();
m_MatchLength = reader.ReadTimeSpan();
TimeSpan elapsed = reader.ReadTimeSpan();
if (elapsed > TimeSpan.Zero)
{
m_MatchStart = DateTime.UtcNow - elapsed;
}
int count = reader.ReadInt();
for (int i = 0; i < count; i++)
{
ChallengeEntry entry = new ChallengeEntry();
entry.Participant = reader.ReadMobile();
string sname = reader.ReadString();
// look up the enum by name
ChallengeStatus status = ChallengeStatus.None;
try{
status = (ChallengeStatus)Enum.Parse(typeof(ChallengeStatus), sname);
} catch {}
entry.Status = status;
entry.Accepted = reader.ReadBool();
entry.PageBeingViewed = reader.ReadInt();
entry.Score = reader.ReadInt();
entry.Winner = reader.ReadBool();
Participants.Add(entry);
}
break;
}
if (GameCompleted)
{
Timer.DelayCall(PostGameDecayTime, new TimerCallback(Delete));
}
// start the challenge timer
StartChallengeTimer();
}
public ChallengePermissionQuery(ChallengeEntry challengeEntry)
{
Id = challengeEntry.Id;
Url = challengeEntry.Url;
ChallengeElement1 = challengeEntry.Challenge1;
ChallengeElement2 = challengeEntry.Challenge2;
Balance = challengeEntry.Balance;
FirstCharacterPosition = challengeEntry.FirstCharacterPosition;
SecondCharacterPosition = challengeEntry.SecondCharacterPosition;
}
public ChallengeActor()
{
Receive <ChallengeIssuedMessage>(message =>
{
using var serviceScope = Context.CreateScope();
var challengePersistence = ServiceScopeHelper.GetService <ChallengePersistence>(serviceScope);
var eventStream = Context.System.EventStream;
var newChallenge = new ChallengeEntry
{
CommunityName = message.SendChallengeModel.CommunityName,
FromPlayer = message.SendChallengeModel.FromPlayer,
ToPlayer = message.SendChallengeModel.ToPlayer,
Status = ChallengeStatus.Challenging,
Date = message.TimeStamp
};
challengePersistence.AddToDb(newChallenge).ContinueWith(saveChallengeTask =>
eventStream.Publish(new ChallengeEntrySavedMessage(ChallengeEntry: saveChallengeTask.Result)));
});
Receive <FirebaseInitialChallengeNotificationSentMessage>(message =>
UpdateStatusForChallengeEntry(
message.ChallengeEntry.Id, ChallengeStatus.Challenged, message.ChallengeNotification.Date));
Receive <ChallengeAcceptedMessage>(message =>
UpdateStatusForChallengeEntry(message.ChallengeEntryId, ChallengeStatus.Accepting, message.TimeStamp));
Receive <ChallengeDeclinedMessage>(message =>
UpdateStatusForChallengeEntry(message.ChallengeEntryId, ChallengeStatus.Declining, message.TimeStamp));
Receive <FirebaseChallengeResponseNotificationSentMessage>(message =>
{
var newStatus = message.ChallengeNotification.Type == NotificationType.Accepted
? ChallengeStatus.Accepted
: ChallengeStatus.Declined;
UpdateStatusForChallengeEntry(message.ChallengeEntry.Id, newStatus, message.ChallengeNotification.Date);
});
Receive <GetChallengesMessage>(_ =>
{
var serviceScope = Context.CreateScope();
var challengePersistence = ServiceScopeHelper.GetService <ChallengePersistence>(serviceScope);
challengePersistence
.GetAllFromDb()
.ContinueWith(getChallengesTask =>
{
serviceScope.Dispose();
return(new GetChallengesResponse(ChallengeEntries: getChallengesTask.Result));
})
.PipeTo(Sender);
});
}
public static ChallengeModel ToChallengeModel(this ChallengeEntry challengeEntry)
{
return(new()
{
Id = challengeEntry.Id,
CommunityName = challengeEntry.CommunityName,
FromPlayer = challengeEntry.FromPlayer,
ToPlayer = challengeEntry.ToPlayer,
Status = challengeEntry.Status,
Date = challengeEntry.Date
});
}
public void SubtractScore(ChallengeEntry entry)
{
if (entry == null)
{
return;
}
entry.Score--;
// refresh the gumps
DeathmatchGump.RefreshAllGumps(this, false);
}
public void AddScore(ChallengeEntry entry)
{
if (entry == null)
{
return;
}
entry.Score++;
// refresh the gumps
TeamDeathmatchGump.RefreshAllGumps(this, false);
}
private ChallengePermissionQuery Map(ChallengeEntry challengeEntry)
{
return(new ChallengePermissionQuery
{
Id = challengeEntry.Id,
Url = challengeEntry.Url,
ChallengeElement1 = challengeEntry.Challenge1,
ChallengeElement2 = challengeEntry.Challenge2,
Balance = challengeEntry.Balance,
FirstCharacterPosition = challengeEntry.FirstCharacterPosition,
SecondCharacterPosition = challengeEntry.SecondCharacterPosition
});
}
private void SendResponseViaFirebaseAndPublishEvent(
ChallengeEntry challengeEntry, NotificationType notificationType)
{
using var serviceScope = Context.CreateScope();
var firebaseMessagingService = ServiceScopeHelper.GetService <FirebaseMessagingService>(serviceScope);
var eventStream = Context.System.EventStream;
firebaseMessagingService.SendMessageWithResponseToChallenge(challengeEntry, notificationType)
.ContinueWith(sendToFirebaseTask =>
eventStream.Publish(
new FirebaseChallengeResponseNotificationSentMessage
(
ChallengeEntry: challengeEntry,
ChallengeNotification: sendToFirebaseTask.Result
)));
}
public void RespawnWithPenalty(ChallengeEntry entry)
{
if (entry == null)
{
return;
}
SubtractScore(entry);
// move the participant to the gauntlet
if (entry.Participant != null)
{
entry.Participant.MoveToWorld(this.Location, this.Map);
entry.Participant.PlaySound(0x214);
entry.Participant.FixedEffect(0x376A, 10, 16);
GameBroadcast(100401, entry.Participant.Name); // "{0} was penalized."
}
}
public async Task ItShouldReturnChallengeValidationJsonResultWhenTheChallengeEntryIsValid()
{
var challengeEntry = new ChallengeEntry
{
Id = "123",
Balance = "£1000",
Challenge1 = "1",
Challenge2 = "A",
FirstCharacterPosition = 1,
SecondCharacterPosition = 4,
Url = "https://tempuri.org/challenge/me/to/a/deul/any/time"
};
var query = new ChallengePermissionQuery
{
Id = "123",
Balance = "£1000",
ChallengeElement1 = "1",
ChallengeElement2 = "B",
FirstCharacterPosition = 1,
SecondCharacterPosition = 4,
Url = "https://tempuri.org/challenge/me/to/a/deul/any/time"
};
var response = new ChallengePermissionResponse
{
Id = challengeEntry.Id,
Url = challengeEntry.Url,
IsValid = true
};
MockChallengeHandler.Setup(x => x.Handle(It.IsAny <ChallengePermissionQuery>()))
.ReturnsAsync(response);
var actual = await Unit.Index(challengeEntry.Id, challengeEntry);
Assert.IsNotNull(actual);
Assert.IsInstanceOf <JsonResult>(actual);
var result = ((JsonResult)actual).Data as ChallengeValidationResult;
Assert.IsNotNull(result);
Assert.IsTrue(result.IsValidResponse);
}
private void CreateChallengeEntryTransform(ChallengeEntry ChallengeEntry, Transform container, List <Transform> transformList)
{
float templateHeight = 93f;
Transform entryTransform = Instantiate(entryTemplate, container);
RectTransform entryRectTransform = entryTransform.GetComponent <RectTransform>();
entryRectTransform.anchoredPosition = new Vector2(0, -templateHeight * transformList.Count);
entryTransform.gameObject.SetActive(true);
entryTransform.Find("TextChallengeButton").GetComponent <Text>().text = ChallengeEntry.name;
// Set background visible odds and evens, easier to read
// Highlight First
transformList.Add(entryTransform);
}
public async Task ItShouldReturnAViewModelWhenTheChallengeEntryIsInvalid()
{
var challengeEntry = new ChallengeEntry
{
Id = "123",
Balance = "£1000",
Challenge1 = "1",
Challenge2 = "A",
FirstCharacterPosition = 0,
SecondCharacterPosition = 1,
Url = "https://tempuri.org/challenge/me/to/a/deul/any/time"
};
var query = new ChallengePermissionQuery
{
Id = "123",
Balance = "£1000",
ChallengeElement1 = "1",
ChallengeElement2 = "A",
FirstCharacterPosition = 1,
SecondCharacterPosition = 2,
Url = "https://tempuri.org/challenge/me/to/a/deul/any/time"
};
var response = new ChallengePermissionResponse
{
Id = challengeEntry.Id,
Url = challengeEntry.Url,
IsValid = false
};
MockChallengeHandler.Setup(x => x.Handle(It.IsAny <ChallengePermissionQuery>()))
.ReturnsAsync(response);
var actual = await Unit.Index(challengeEntry.Id, challengeEntry);
Assert.IsNotNull(actual);
Assert.IsInstanceOf <ViewResult>(actual);
Assert.IsInstanceOf <ChallengeViewModel>(((ViewResult)actual).Model);
Assert.AreEqual(true, ((ChallengeViewModel)((ViewResult)actual).Model).HasError);
}
public async Task <ChallengeNotification> SendMessageWithResponseToChallenge(
ChallengeEntry challenge, NotificationType response)
{
var responseString = response.ToString().ToLower();
var playerThatChallenged = challenge.FromPlayer;
var respondingPlayer = challenge.ToPlayer;
var encodedTopic = $"{challenge.CommunityName}_{playerThatChallenged}".Base64UrlEncode();
var notificationMessage =
$"{challenge.CommunityName}: {respondingPlayer} has {responseString} your challenge!";
var message = new Message
{
Data = new Dictionary <string, string>
{
{ "challengeId", challenge.Id.ToString() },
{ "title", $"Challenge {responseString}" },
{ "message", notificationMessage },
{ "communityName", challenge.CommunityName },
{ "responseType", response.ToString() },
{ "fromPlayer", respondingPlayer },
{ "toPlayer", playerThatChallenged }
},
Topic = encodedTopic
};
var firebaseResponse = await FirebaseMessaging.DefaultInstance.SendAsync(message);
return(new ChallengeNotification
{
Topic = encodedTopic,
Message = notificationMessage,
FromPlayer = respondingPlayer,
Date = DateTime.UtcNow,
Type = response,
FirebaseResponse = firebaseResponse
});
}
public async Task <ActionResult> Index(string id, ChallengeEntry challengeEntry)
{
var response = await _handler.Handle(Map(challengeEntry));
if (response.IsValid)
{
return(Json(new ChallengeValidationResult
{
IsValidResponse = true
}));
}
var model = new ChallengeViewModel
{
Characters = response.Characters,
Id = challengeEntry.Id,
Url = challengeEntry.Url,
HasError = true
};
return(View(model));
}
public async Task <ChallengeNotification> SendMessageWithInitialChallenge(ChallengeEntry challenge)
{
var encodedTopic = $"{challenge.CommunityName}_{challenge.ToPlayer}".Base64UrlEncode();
var notificationMessage = $"{challenge.CommunityName}: {challenge.FromPlayer} has challenged you to a game!";
var notificationTitle = "New Challenge!";
var message = new Message
{
Notification = new Notification
{
Title = notificationTitle,
Body = notificationMessage
},
Data = new Dictionary <string, string>
{
{ "challengeId", challenge.Id.ToString() },
{ "title", notificationTitle },
{ "message", notificationMessage },
{ "communityName", challenge.CommunityName },
{ "fromPlayer", challenge.FromPlayer },
{ "toPlayer", challenge.ToPlayer },
},
Topic = encodedTopic
};
var firebaseResponse = await FirebaseMessaging.DefaultInstance.SendAsync(message);
return(new ChallengeNotification
{
Topic = encodedTopic,
Message = notificationMessage,
FromPlayer = challenge.FromPlayer,
Date = DateTime.UtcNow,
Type = NotificationType.Challenged,
FirebaseResponse = firebaseResponse
});
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt();
switch(version)
{
case 0:
m_Challenger = reader.ReadMobile();
m_Organizers.Add(m_Challenger);
m_GameLocked = reader.ReadBool();
m_GameInProgress = reader.ReadBool();
m_TotalPurse = reader.ReadInt();
m_EntryFee = reader.ReadInt();
m_ArenaSize = reader.ReadInt();
m_TargetScore = reader.ReadInt();
m_DeathBall = (DeathBall)reader.ReadItem();
int count = reader.ReadInt();
for(int i = 0;i<count;i++)
{
ChallengeEntry entry = new ChallengeEntry();
entry.Participant = reader.ReadMobile();
string sname = reader.ReadString();
// look up the enum by name
ChallengeStatus status = ChallengeStatus.None;
try{
status = (ChallengeStatus)Enum.Parse(typeof(ChallengeStatus), sname);
} catch{}
entry.Status = status;
entry.Accepted = reader.ReadBool();
entry.PageBeingViewed = reader.ReadInt();
entry.Score = reader.ReadInt();
entry.Winner = reader.ReadBool();
entry.Team = reader.ReadInt();
Participants.Add(entry);
}
break;
}
if(GameCompleted)
Timer.DelayCall( PostGameDecayTime, new TimerCallback( Delete ) );
// start the challenge timer
StartChallengeTimer();
SetNameHue();
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
switch(version)
{
case 0:
this.m_Challenger = reader.ReadMobile();
this.m_Organizers.Add(this.m_Challenger);
this.m_GameLocked = reader.ReadBool();
this.m_GameInProgress = reader.ReadBool();
this.m_TotalPurse = reader.ReadInt();
this.m_EntryFee = reader.ReadInt();
this.m_ArenaSize = reader.ReadInt();
this.m_TargetScore = reader.ReadInt();
this.m_MatchLength = reader.ReadTimeSpan();
TimeSpan elapsed = reader.ReadTimeSpan();
if (elapsed > TimeSpan.Zero)
{
this.m_MatchStart = DateTime.Now - elapsed;
}
int count = reader.ReadInt();
for (int i = 0; i < count; i++)
{
ChallengeEntry entry = new ChallengeEntry();
entry.Participant = reader.ReadMobile();
string sname = reader.ReadString();
// look up the enum by name
ChallengeStatus status = ChallengeStatus.None;
try
{
status = (ChallengeStatus)Enum.Parse(typeof(ChallengeStatus), sname);
}
catch
{
}
entry.Status = status;
entry.Accepted = reader.ReadBool();
entry.PageBeingViewed = reader.ReadInt();
entry.Score = reader.ReadInt();
entry.Winner = reader.ReadBool();
this.Participants.Add(entry);
}
break;
}
if (this.GameCompleted)
Timer.DelayCall(this.PostGameDecayTime, new TimerCallback(Delete));
// start the challenge timer
this.StartChallengeTimer();
}
public void RespawnWithPenalty(ChallengeEntry entry)
{
if (entry == null)
return;
this.SubtractScore(entry);
// move the participant to the gauntlet
if (entry.Participant != null)
{
entry.Participant.MoveToWorld(this.Location, this.Map);
entry.Participant.PlaySound(0x214);
entry.Participant.FixedEffect(0x376A, 10, 16);
this.GameBroadcast(100401, entry.Participant.Name); // "{0} was penalized."
}
}
public void AddScore(ChallengeEntry entry)
{
if (entry == null)
return;
entry.Score++;
// refresh the gumps
TeamDeathmatchGump.RefreshAllGumps(this, false);
}
public void SubtractScore(ChallengeEntry entry)
{
if(entry == null) return;
entry.Score--;
// refresh the gumps
CTFGump.RefreshAllGumps(this, false);
}