public async Task FindParticipantAsync_EquivalentToParticipant(Game game, ChallengeState state)
{
//Arrange
var challengeFaker = TestData.FakerFactory.CreateChallengeFaker(48956632, game, state);
var challenge = challengeFaker.FakeChallenge();
using var factory = new InMemoryDbContextFactory <ChallengesDbContext>();
await using (var context = factory.CreateContext())
{
var challengeRepository = new ChallengeRepository(context);
challengeRepository.Create(challenge);
await challengeRepository.CommitAsync();
}
await using (var context = factory.CreateContext())
{
var participantQuery = new ParticipantQuery(context);
foreach (var participant in challenge.Participants)
{
//Act
var participantAsync = await participantQuery.FindParticipantAsync(ParticipantId.FromGuid(participant.Id));
//Assert
participantAsync.Should().BeEquivalentTo(participant);
}
}
}
public async Task FindChallengeAsync_ShouldBeChallenge(Game game, ChallengeState state)
{
//Arrange
var challengeFaker = TestData.FakerFactory.CreateChallengeFaker(84568994, game, state);
var challenge = challengeFaker.FakeChallenge();
using var factory = new InMemoryDbContextFactory <ChallengesDbContext>();
await using (var context = factory.CreateContext())
{
var challengeRepository = new ChallengeRepository(context);
challengeRepository.Create(challenge);
await challengeRepository.CommitAsync();
}
await using (var context = factory.CreateContext())
{
var challengeQuery = new ChallengeQuery(context);
//Act
var challengeAsync = await challengeQuery.FindChallengeAsync(challenge.Id);
//Assert
challengeAsync.Should().Be(challenge);
}
}
public async Task FindMatchAsync_ShouldBeEquivalentToMatch(Game game, ChallengeState state)
{
//Arrange
var challengeFaker = TestData.FakerFactory.CreateChallengeFaker(83459632, game, state);
var challenge = challengeFaker.FakeChallenge();
using var factory = new InMemoryDbContextFactory <ChallengesDbContext>();
await using (var context = factory.CreateContext())
{
var challengeRepository = new ChallengeRepository(context);
challengeRepository.Create(challenge);
await challengeRepository.CommitAsync();
}
await using (var context = factory.CreateContext())
{
var matchQuery = new MatchQuery(context);
foreach (var match in challenge.Participants.SelectMany(participant => participant.Matches).ToList())
{
//Act
var matchAsync = await matchQuery.FindMatchAsync(MatchId.FromGuid(match.Id));
//Arrange
matchAsync.Should().BeEquivalentTo(match);
}
}
}
public void enterGame()
{
challengeObject.SetActive(true);
startGameDistance = ChallengeManager.sharedManager.challengeStartPosition + ChallengeManager.sharedManager.distance;
challengeObject.transform.position = new Vector3(0, 0, startGameDistance);
challengeState = ChallengeState.inGame;
}
public MenuScreen()
{
isActive = false;
isHidden = true;
canLauchChallenge = false;
menuSound = SoundEffectLibrary.Get("cursor").CreateInstance();
m_sprite = new Sprite(Program.TheGame, TextureLibrary.GetSpriteSheet("menu_start_bg"), m_transform);
m_sprite.Transform.Position = outPos;
arrow = new Sprite(Program.TheGame, TextureLibrary.GetSpriteSheet("arrow"), new Transform(m_transform, true));
moveTo = new MoveToStaticAction(Program.TheGame, m_transform, inPos, 1);
moveTo.StartPosition = new Vector2(80, 200);
moveTo.Interpolator = new PSmoothstepInterpolation();
moveTo.Timer.Interval = 0.5f;
moveOut = new MoveToStaticAction(Program.TheGame, m_transform, outPos, 1);
moveOut.StartPosition = inPos;
moveOut.Interpolator = new PSmoothstepInterpolation();
moveOut.Timer.Interval = 0.5f;
choice = MenuState.START;
challengeChoice = ChallengeState.CHALL_1;
}
public async Task FetchChallengesAsync_ShouldHaveCount(Game game, ChallengeState state)
{
//Arrange
var challengeFaker = TestData.FakerFactory.CreateChallengeFaker(84936374, game);
var fakeChallenges = challengeFaker.FakeChallenges(4);
using var factory = new InMemoryDbContextFactory <ChallengesDbContext>();
await using (var context = factory.CreateContext())
{
var challengeRepository = new ChallengeRepository(context);
challengeRepository.Create(fakeChallenges);
await challengeRepository.CommitAsync();
}
await using (var context = factory.CreateContext())
{
var challengeQuery = new ChallengeQuery(context);
//Act
var challenges = await challengeQuery.FetchChallengesAsync(game, state);
//Assert
challenges.Should().HaveCount(fakeChallenges.Count(challenge => challenge.Game == game && challenge.Timeline == state));
}
}
public MenuScreen()
{
isActive = false;
isHidden = true;
canLauchChallenge = false;
menuSound = SoundEffectLibrary.Get("cursor").CreateInstance();
m_sprite = new Sprite(Program.TheGame, TextureLibrary.GetSpriteSheet("menu_start_bg"), m_transform);
m_sprite.Transform.Position = outPos;
arrow = new Sprite(Program.TheGame, TextureLibrary.GetSpriteSheet("arrow"), new Transform(m_transform, true));
moveTo = new MoveToStaticAction(Program.TheGame, m_transform, inPos, 1);
moveTo.StartPosition = new Vector2(80, 200);
moveTo.Interpolator = new PSmoothstepInterpolation();
moveTo.Timer.Interval = 0.5f;
moveOut = new MoveToStaticAction(Program.TheGame, m_transform, outPos, 1);
moveOut.StartPosition = inPos;
moveOut.Interpolator = new PSmoothstepInterpolation();
moveOut.Timer.Interval = 0.5f;
choice = MenuState.START;
challengeChoice = ChallengeState.CHALL_1;
}
public void UpdateData(ChallengeState state, bool complete_one, bool complete_two, bool complete_three)
{
mState = state;
mCompleteOne = complete_one;
mCompleteTwo = complete_two;
mCompleteThree = complete_three;
Refresh();
}
//初始化关卡限制
private void InitLevelLimit()
{
m_levelInfoList = Resources.Load <UserData>("UserDatum/UserData").levelInfoList;
m_challengeState = ChallengeState.prepare;
m_curInfo = m_levelInfoList.FindLevelInfo(Director.Instance.CurrentSceneName);
m_timeLimit = m_curInfo.PassTimeLimit;
m_turnLimit = m_curInfo.PassTurnLimit;
}
/// <summary>Processes the given challenge token.</summary>
/// <remarks>
/// Processes the given challenge token. Some authentication schemes
/// may involve multiple challenge-response exchanges. Such schemes must be able
/// to maintain the state information when dealing with sequential challenges
/// </remarks>
/// <param name="header">the challenge header</param>
/// <exception cref="Apache.Http.Auth.MalformedChallengeException">
/// is thrown if the authentication challenge
/// is malformed
/// </exception>
public virtual void ProcessChallenge(Header header)
{
Args.NotNull(header, "Header");
string authheader = header.GetName();
if (Sharpen.Runtime.EqualsIgnoreCase(authheader, AUTH.WwwAuth))
{
this.challengeState = ChallengeState.Target;
}
else
{
if (Sharpen.Runtime.EqualsIgnoreCase(authheader, AUTH.ProxyAuth))
{
this.challengeState = ChallengeState.Proxy;
}
else
{
throw new MalformedChallengeException("Unexpected header name: " + authheader);
}
}
CharArrayBuffer buffer;
int pos;
if (header is FormattedHeader)
{
buffer = ((FormattedHeader)header).GetBuffer();
pos = ((FormattedHeader)header).GetValuePos();
}
else
{
string s = header.GetValue();
if (s == null)
{
throw new MalformedChallengeException("Header value is null");
}
buffer = new CharArrayBuffer(s.Length);
buffer.Append(s);
pos = 0;
}
while (pos < buffer.Length() && HTTP.IsWhitespace(buffer.CharAt(pos)))
{
pos++;
}
int beginIndex = pos;
while (pos < buffer.Length() && !HTTP.IsWhitespace(buffer.CharAt(pos)))
{
pos++;
}
int endIndex = pos;
string s_1 = buffer.Substring(beginIndex, endIndex);
if (!Sharpen.Runtime.EqualsIgnoreCase(s_1, GetSchemeName()))
{
throw new MalformedChallengeException("Invalid scheme identifier: " + s_1);
}
ParseChallenge(buffer, pos, buffer.Length());
}
public ShipManager(ChallengeState state, string playerName)
{
_state = state;
_playerName = playerName;
if (!_state.Players.ContainsKey(_playerName))
{
throw new Exception("This has gone really wrong!");
}
}
public void StartChallenge()
{
Canvas.gameObject.SetActive(true);
Results.gameObject.SetActive(false);
ChallengeState = ChallengeState.Prepare;
Initialize("Pro tour tournament");
StartCoroutine(Challenge());
}
public Challenge(CycGame cg, Game1 g, int m)
{
cycGame = cg;
game = g;
state = ChallengeState.NotYet;
Measure = m;
beats = new List<ChallengeBeat>();
enemiesIgnored = 0;
enemiesKilled = 0;
enemyCount = 0;
}
public IOperationResult Cancel()
{
if (this.State != ChallengeState.Accepted)
{
this.State = ChallengeState.Cancelled;
// TODO: Debe checar de manera thread-safe que no haya sido aceptado el reto aún
messaging.Publish(Challenger.Room, Tuple.Create(this, ChallengeState.Cancelled));
return new OperationResult(ResultValue.Success, "");
}
return new OperationResult(ResultValue.Fail, "El reto ha sido aceptado.");
}
private static void ManageChallenge(Socket listener)
{
Console.WriteLine("Setting up a new Challenge...");
var config = ChallengeConfiguration.GetChallengeConfiguration(_configPath);
var state = ChallengeState.GetStateFromConfiguration(config);
var name = state.GetPlayerNames();
for (var i = 0; i < state.Players.Count; i++)
{
listener.Listen(100);
var connection = listener.Accept();
var task = ManageConnection(connection, state, name[i]);
}
state.Flags.AddOrUpdate("Ready", true, (x, y) => true);
Console.WriteLine("Begin the challenge!");
}
//暂停开关
public void PauseSwitch()
{
//当暂停时，进入暂停状态
if (m_challengeState == ChallengeState.underway)
{
m_challengeState = ChallengeState.paused;
return;
}
//当恢复时，进入开始状态
if (m_challengeState == ChallengeState.paused)
{
m_challengeState = ChallengeState.start;
return;
}
}
private static Task ManageConnection(Socket connection, ChallengeState state, string playerName)
{
return(Task.Run(() =>
{
Console.WriteLine($"{playerName} connected!");
var manager = new ChallengeManager(state, playerName);
while (true)
{
if (state.Flags["Ready"])
{
var begin = Encoding.UTF8.GetBytes("Begin");
connection.Send(begin);
break;
}
Thread.Sleep(100);
}
while (true)
{
try
{
byte[] data = new byte[1000000];
var dataSize = connection.Receive(data);
if (!connection.Connected)
{
break;
}
if (dataSize == 0)
{
continue;
}
byte[] command = new byte[dataSize];
Array.Copy(data, command, dataSize);
var response = manager.ProcessCommand(command);
connection.Send(response);
}
catch (Exception e)
{
connection.Close();
Console.WriteLine(e.Message);
Console.WriteLine("Connection died!");
break;
}
}
}));
}
//初始化参数
private void Awake()
{
if (Instance == null)
{
Instance = this;
}
else
{
Destroy(this);
}
m_timeCount = 0;
m_turnCount = 0;
m_countDown = 5;
m_challengeState = ChallengeState.start;
InitLevelLimit(); //初始化关卡限制
}
public void PlayGame()
{
var state = new ChallengeState();
var stateManager = new StateManager(_connection, state);
var explorationManager = new ExplorationManager(state, _connection);
_connection.PollForStart().Wait();
stateManager.PollState();
explorationManager.Explore().Wait();
stateManager.Finish();
foreach (var system in state.SolarSystems.Select(s => s.Value))
{
Console.WriteLine(system.Name);
}
_connection.Close();
}
//修改闯关状态
public void SetChallengeState(ChallengeState state)
{
m_challengeState = state;
//switch(state)
//{
// case 0:
// m_challengeState = ChallengeState.start;
// break;
// case 1:
// m_challengeState = ChallengeState.underway;
// break;
// case 2:
// m_challengeState = ChallengeState.paused;
// break;
// case 3:
// m_challengeState = ChallengeState.failed;
// break;
// case 4:
// m_challengeState = ChallengeState.succeed;
// break;
//}
}
public DateTime RegisteredAt(ChallengeState state, DateTime?startedAt)
{
return(state != ChallengeState.Inscription ? Faker.Date.Recent(1, startedAt) : Faker.Date.Soon(1, DateTime.UtcNow.Date));
}
public int Process(float expectedGrade, float actualGrade, bool changeState)
{
int difficultyThisTurn = 0;
if (state == ChallengeState.NotYet && game.CurrentMeasure >= Measure)
{
if (expectedGrade > actualGrade)
{
if (changeState)
{
state = ChallengeState.Skipped;
}
}
else
{
state = ChallengeState.Active;
}
}
if (state == ChallengeState.Active)
{
bool anyUnsent = false;
foreach (ChallengeBeat beat in beats)
{
if (beat.Unsent && (beat.Beat + (Measure * 4)) <= game.CurrentBeat)
{
beat.Unsent = false;
foreach (EnemyMaker em in beat.Enemies)
{
CycEnemy enemy = (CycEnemy)em(this);
difficultyThisTurn += enemy.Difficulty;
}
}
else
{
anyUnsent = true;
}
}
if (!anyUnsent && changeState)
{
state = ChallengeState.Deployed;
}
}
return difficultyThisTurn;
}
public ChallengeState State(ChallengeState?state = null)
{
return(state ?? Faker.PickRandom(ChallengeState.GetEnumerations()));
}
public Challenge(IEnumerable <IEvent> events)
{
State = new ChallengeState(events);
state = State as ChallengeState;
}
public async Task FindChallengeParticipantsAsync_ShouldBeEquivalentToParticipantList(Game game, ChallengeState state)
{
//Arrange
var challengeFaker = TestData.FakerFactory.CreateChallengeFaker(68545632, game, state);
var challenge = challengeFaker.FakeChallenge();
using var factory = new InMemoryDbContextFactory <ChallengesDbContext>();
await using (var context = factory.CreateContext())
{
var challengeRepository = new ChallengeRepository(context);
challengeRepository.Create(challenge);
await challengeRepository.CommitAsync();
}
await using (var context = factory.CreateContext())
{
var participantQuery = new ParticipantQuery(context);
//Act
var participants = await participantQuery.FetchChallengeParticipantsAsync(challenge.Id);
//Assert
participants.Should().BeEquivalentTo(challenge.Participants.ToList());
}
}
void enterStandby()
{
challengeObject.transform.position = new Vector3(0, 0, -5);
challengeObject.SetActive(false);
challengeState = ChallengeState.standby;
}
public ExplorationManager(ChallengeState state, ConnectionManager connection)
{
_state = state;
_manager = new ShipManager(connection);
}
public void Register_WhenStateNotInscription_ShouldThrowInvalidOperationException(ChallengeState state)
{
// Arrange
var challengeFaker = TestData.FakerFactory.CreateChallengeFaker(78536956, Game.LeagueOfLegends, state);
var challenge = challengeFaker.FakeChallenge();
// Act
var action = new Action(
() => challenge.Register(
new Participant(
new ParticipantId(),
new UserId(),
PlayerId.Parse(Guid.NewGuid().ToString()),
new UtcNowDateTimeProvider())));
// Assert
action.Should().Throw <InvalidOperationException>();
}
public void setChallengeState(ChallengeState _state)
{
_currentState = _state;
}
public override void Update()
{
if (isActive)
{
// Positionning arrow
//
if (choice == MenuState.START)
{
arrow.Transform.Position = new Vector2(-25, -7);
}
if (choice == MenuState.CHALLENGES)
{
arrow.Transform.Position = new Vector2(-45, 7);
}
// Actions with enter or space
//
if ((Game1.kbs.IsKeyDown(Keys.Enter) && Game1.old_kbs.IsKeyUp(Keys.Enter)) ||
(Game1.kbs.IsKeyDown(Keys.Space) && Game1.old_kbs.IsKeyUp(Keys.Space)))
{
ExecuteStartAction();
menuSound.Play();
}
// Up and down input between start & challenges
//
if (choice != MenuState.CHALLENGE_CHOICE)
{
if (Game1.kbs.IsKeyDown(Keys.Up) && Game1.old_kbs.IsKeyUp(Keys.Up))
{
choice = MenuState.START;
menuSound.Play();
}
if (Game1.kbs.IsKeyDown(Keys.Down) && Game1.old_kbs.IsKeyUp(Keys.Down))
{
choice = MenuState.CHALLENGES;
menuSound.Play();
}
}
// Left and right input between challenges
//
if (choice == MenuState.CHALLENGE_CHOICE)
{
if (Game1.kbs.IsKeyDown(Keys.LeftAlt) && Game1.old_kbs.IsKeyUp(Keys.LeftAlt))
{
choice = MenuState.START;
challengeChoice = ChallengeState.CHALL_1;
m_sprite.SpriteSheet = TextureLibrary.GetSpriteSheet("menu_start_bg");
canLauchChallenge = false;
menuSound.Play();
}
if (Game1.kbs.IsKeyDown(Keys.Right) && Game1.old_kbs.IsKeyUp(Keys.Right))
{
if (challengeChoice < ChallengeState.CHALL_5)
{
challengeChoice++;
arrow.Transform.PosX += deltaArrowBetweenChallenges;
menuSound.Play();
}
}
if (Game1.kbs.IsKeyDown(Keys.Left) && Game1.old_kbs.IsKeyUp(Keys.Left))
{
if (challengeChoice > ChallengeState.CHALL_1)
{
challengeChoice--;
arrow.Transform.PosX -= deltaArrowBetweenChallenges;
menuSound.Play();
}
}
}
}
actionManager.Update();
}
public void Reject()
{
if (this.State == ChallengeState.Sent)
{
this.State = ChallengeState.Rejected;
// TODO: Debe checar de manera thread-safe que no haya sido aceptado el reto aún
messaging.Publish(Challenger.Room, Tuple.Create(this, ChallengeState.Rejected));
}
}
public DigestScheme(ChallengeState challengeState) : base(challengeState)
{
}
IEnumerator Challenge()
{
while (ChallengeState == ChallengeState.Prepare)
{
currentTime = startTime + prepareTime - Time.realtimeSinceStartup;
TimeText.text = (prepareTime - currentTime).ToString("n2");
if (!started)
{
startTime = Time.realtimeSinceStartup;
StateText.text = ChallengeState.ToString();
started = true;
}
else if (Time.realtimeSinceStartup >= startTime + prepareTime)
{
ChallengeState = ChallengeState.Challenge;
started = false;
}
yield return(null);
}
while (ChallengeState == ChallengeState.Challenge)
{
currentTime = challengeTime - (startTime + challengeTime - Time.realtimeSinceStartup);
TimeText.text = currentTime.ToString("n2");
if (!started)
{
startTime = Time.realtimeSinceStartup;
StateText.text = ChallengeState.ToString();
started = true;
}
else if (Time.realtimeSinceStartup >= startTime + challengeTime)
{
ChallengeState = ChallengeState.Reward;
started = false;
}
foreach (var unit in ReactionUnits)
{
var controller = unit.GetComponent <ReactionUnitController>();
if (currentTime >= controller.StartTime && currentTime < (controller.StartTime + controller.Duration))
{
unit.gameObject.SetActive(true);
}
else
{
if (unit.gameObject.activeSelf)
{
unit.gameObject.SetActive(false);
}
}
}
yield return(null);
}
while (ChallengeState == ChallengeState.Reward)
{
if (!started)
{
var prizeCards = new List <GameObject>();
foreach (var reaction in Reactions)
{
if (reaction != null)
{
var card = DeckController.GetRandomCard();
prizeCards.Add(card);
PlayerController.ReceiveCard(card);
}
}
if (prizeCards.Count > 0)
{
GameController.OpenBoosterController.Initialize(prizeCards);
GameController.OpenBoosterController.InnerGameObject.SetActive(true);
CloseChallenge();
}
else
{
GameController.StoryController.SetStoryText("Bad luck this time. Maybe, you will win in the next challenge!");
CloseChallenge();
}
started = true;
}
yield return(new WaitForSeconds(2));
}
yield return(null);
}
public override void Update()
{
if (isActive)
{
// Positionning arrow
//
if (choice == MenuState.START)
arrow.Transform.Position = new Vector2(-25, -7);
if (choice == MenuState.CHALLENGES)
arrow.Transform.Position = new Vector2(-45, 7);
// Actions with enter or space
//
if ((Game1.kbs.IsKeyDown(Keys.Enter) && Game1.old_kbs.IsKeyUp(Keys.Enter))
|| (Game1.kbs.IsKeyDown(Keys.Space) && Game1.old_kbs.IsKeyUp(Keys.Space)))
{
ExecuteStartAction();
menuSound.Play();
}
// Up and down input between start & challenges
//
if (choice != MenuState.CHALLENGE_CHOICE)
{
if (Game1.kbs.IsKeyDown(Keys.Up) && Game1.old_kbs.IsKeyUp(Keys.Up))
{
choice = MenuState.START;
menuSound.Play();
}
if (Game1.kbs.IsKeyDown(Keys.Down) && Game1.old_kbs.IsKeyUp(Keys.Down))
{
choice = MenuState.CHALLENGES;
menuSound.Play();
}
}
// Left and right input between challenges
//
if (choice == MenuState.CHALLENGE_CHOICE)
{
if (Game1.kbs.IsKeyDown(Keys.LeftAlt) && Game1.old_kbs.IsKeyUp(Keys.LeftAlt))
{
choice = MenuState.START;
challengeChoice = ChallengeState.CHALL_1;
m_sprite.SpriteSheet = TextureLibrary.GetSpriteSheet("menu_start_bg");
canLauchChallenge = false;
menuSound.Play();
}
if (Game1.kbs.IsKeyDown(Keys.Right) && Game1.old_kbs.IsKeyUp(Keys.Right))
{
if (challengeChoice < ChallengeState.CHALL_5)
{
challengeChoice++;
arrow.Transform.PosX += deltaArrowBetweenChallenges;
menuSound.Play();
}
}
if (Game1.kbs.IsKeyDown(Keys.Left) && Game1.old_kbs.IsKeyUp(Keys.Left))
{
if (challengeChoice > ChallengeState.CHALL_1)
{
challengeChoice--;
arrow.Transform.PosX -= deltaArrowBetweenChallenges;
menuSound.Play();
}
}
}
}
actionManager.Update();
}
public RFC2617Scheme(ChallengeState challengeState) : base(challengeState)
{
// AuthSchemeBase, params
this.@params = new Dictionary <string, string>();
this.credentialsCharset = Consts.Ascii;
}
public IChallenge FakeChallenge(ChallengeModel model)
{
var challengeFaker = new ChallengeFaker();
challengeFaker.CustomInstantiator(
faker =>
{
faker.User().Reset();
var name = new ChallengeName(model.Name);
var game = Game.FromValue(model.Game);
var entries = new Entries(model.Entries);
var bestOf = new BestOf(model.BestOf);
var duration = new ChallengeDuration(TimeSpan.FromTicks(model.Timeline.Duration));
var state = ChallengeState.FromValue(model.State);
var utcNowDate = DateTime.UtcNow.Date;
var createdAt = faker.Date.Recent(1, utcNowDate);
var startedAt = faker.Date.Between(createdAt, utcNowDate);
var endedAt = startedAt + duration;
var synchronizationBuffer = endedAt + TimeSpan.FromHours(2);
var closedAt = faker.Date.Soon(1, synchronizationBuffer);
var synchronizedAt = faker.Date.Between(synchronizationBuffer, closedAt);
var timeline = new ChallengeTimeline(new DateTimeProvider(startedAt), duration);
var scoring = new Scoring
{
[new StatName("StatName1")] = new StatWeighting(0.00015F),
[new StatName("StatName2")] = new StatWeighting(1),
[new StatName("StatName3")] = new StatWeighting(0.77F),
[new StatName("StatName4")] = new StatWeighting(100),
[new StatName("StatName5")] = new StatWeighting(-3)
};
var challenge = new Challenge(
model.Id.ConvertTo <ChallengeId>(),
name,
game,
bestOf,
entries,
timeline,
scoring);
var participantFaker = new ParticipantFaker(game, createdAt, startedAt);
participantFaker.UseSeed(faker.Random.Int());
var participants = participantFaker.Generate(this.ParticipantCount(state, challenge.Entries));
participants.ForEach(participant => challenge.Register(participant));
if (state != ChallengeState.Inscription)
{
challenge.Start(new DateTimeProvider(startedAt));
participants.ForEach(
participant =>
{
var matchFaker = new MatchFaker(challenge.Scoring, synchronizedAt);
matchFaker.UseSeed(faker.Random.Int());
var matches = matchFaker.Generate(this.MatchCount(state, challenge.BestOf));
participant.Snapshot(matches, new DateTimeProvider(synchronizedAt));
});
challenge.Synchronize(new DateTimeProvider(synchronizedAt));
if (state == ChallengeState.Ended || state == ChallengeState.Closed)
{
challenge.Start(new DateTimeProvider(startedAt - duration));
}
if (state == ChallengeState.Closed)
{
challenge.Close(new DateTimeProvider(closedAt));
}
}
return(challenge);
});
return(challengeFaker.Generate());
}
