public void KnowAllAboutNominalAndColor_ClueAboutNominalOnly_ReturnsFalse()
{
IGameProvider gameProvider = GameProviderFabric.Create(Color.Red, Color.Yellow);
var redTwoCardInHand = CreateCardInHand(gameProvider, new Card(Color.Red, Rank.Two));
var cardsToClue = new[] { redTwoCardInHand };
Guess guess = new Guess(gameProvider, redTwoCardInHand);
guess.Visit(new ClueAboutRank(Rank.Two));
bool result = guess.KnowAboutNominalAndColor();
Assert.IsFalse(result);
}
public void KnowAboutNominalOrColor_NotAnyColorsExceptRed_ReturnsTrue()
{
IGameProvider gameProvider = GameProviderFabric.Create(Color.Red, Color.Yellow);
var redTwoCardInHand = CreateCardInHand(gameProvider, new Card(Color.Red, Rank.Two));
var cardsToClue = new[] { redTwoCardInHand };
Guess guess = new Guess(gameProvider, redTwoCardInHand);
guess.Visit(new ClueAboutNotColor(Color.Yellow));
bool result = guess.KnowAboutRankOrColor();
Assert.IsTrue(result);
}
public GameSelectionMV(IAppSettings settings, IGameProvider gameProvider)
: base(settings)
{
StartGameCommand = new RelayCommand(() =>
{
var game = _currentGame.GameDescription.CreateGame(_gameOptions, _currentSelector.Selector, _selectorOptions);
MessengerInstance.Send(new StartGameNotification(game));
});
_gameProvider = gameProvider;
_games = _gameProvider.Games
.Select(g => new GameDescriptionMV(g))
.ToList();
CurrentGame = _games.FirstOrDefault();
}
private void RegisterNewGame(IGameProvider gameProvider)
{
var hubContext = GetHubContext();
gameProvider.DidMove.Subscribe(moveRes =>
{
var client = hubContext.Clients.Client(moveRes.Item1.NextMoveUserId);
if (client != null)
{
client.didMove(Mapper.Map <MoveResultModel>(moveRes.Item1));
}
});
gameProvider.GameFinishes.Subscribe(gameRes =>
{
foreach (var user in gameRes.Users)
{
userGroupsCollector.RemoveUser(user.UserId);
}
});
gameProvider.DidMove
.SubscribeOn(Scheduler.Default)
.Subscribe(moveRes =>
{
userVocabularyStorage.SaveMoveResultToDatabase(moveRes.Item1);
});
gameProvider.TimerTick.Subscribe(tick =>
{
var hubGroup = hubContext.Clients.Group(gameProvider.AssociatedGroupId);
if (hubGroup != null)
{
hubGroup.timerTick(tick);
}
});
gameProvider.MissedMove
.Subscribe(moveRes =>
{
var hubGroup = hubContext.Clients.Group(gameProvider.AssociatedGroupId);
if (hubGroup != null)
{
hubGroup.missedMove(Mapper.Map <MoveResultModel>(moveRes));
}
});
}
public void GetUniqueCards_DiscardBlueTwoCard_ContainsBlueTwoCard()
{
IGameProvider gameProvider = GameProviderFabric.Create(Color.Blue);
FireworkPile fireworkPile = new FireworkPile(gameProvider);
DiscardPile discardPile = new DiscardPile(gameProvider);
Card blueTwoCard = new Card(Color.Blue, Rank.Two);
discardPile.AddCard(blueTwoCard);
var pileAnalyzer = new PilesAnalyzer(gameProvider);
IReadOnlyList <Card> actual = pileAnalyzer.GetUniqueCards(fireworkPile, discardPile);
Assert.IsTrue(actual.Contains(new Card(Color.Blue, Rank.Two)));
}
public void GetUniqueCards_DiscardAllYellowOneCards_DoesNotContainYellowCards()
{
IGameProvider provider = GameProviderFabric.Create(Color.Yellow);
var fireworkPile = new FireworkPile(provider);
var discardPile = new DiscardPile(provider);
discardPile.AddCard(new Card(Color.Yellow, Rank.One));
discardPile.AddCard(new Card(Color.Yellow, Rank.One));
discardPile.AddCard(new Card(Color.Yellow, Rank.One));
GameProvider gameProvider = new GameProvider();
var pileAnalyzer = new PilesAnalyzer(gameProvider);
IReadOnlyList <Card> actual = pileAnalyzer.GetUniqueCards(fireworkPile, discardPile);
Assert.IsFalse(actual.Any(card => card.Color == Color.Yellow));
}
public static IGameProvider GetGameProvider()
{
if (_provider != null)
return _provider;
Lock.EnterReadLock();
try
{
if (_provider == null)
{
_provider = new GameProvider(CacheProviderFactory.GetCacheProvider(), GameDataProviderFactory.GetGameDataProvider(), MovesDataProviderFactory.GetMovesDataProvider());
}
}
finally
{
Lock.ExitReadLock();
}
return _provider;
}
public void GetUniqueCards_PlayRedOneAndDiscardRedOne_DoesNotContainRedOne()
{
IGameProvider provider = GameProviderFabric.Create(Color.Red);
var fireworkPile = new FireworkPile(provider);
fireworkPile.AddCard(new Card(Color.Red, Rank.One));
var discardedPile = new DiscardPile(provider);
discardedPile.AddCard(new Card(Color.Red, Rank.One));
var pileAnalyzer = new PilesAnalyzer(provider);
IReadOnlyList <Card> actual = pileAnalyzer.GetUniqueCards(fireworkPile, discardedPile);
Assert.IsFalse(actual.Contains(new Card(Color.Red, Rank.One)));
}
public Task GameSettingInfo([FromForm] int?id)
{
GameSetting setting = id == null ? new GameSetting():
(GameSettingAgent.Instance().GetGameSettingInfo(id.Value) ?? new GameSetting());
IGameProvider iProvider = GameFactory.GetFactory(setting.Type.ToString(), setting.SettingString);
return(this.GetResult(new
{
setting.ID,
setting.Name,
setting.Code,
setting.Type,
setting.Status,
setting.MaintainTime,
setting.Remark,
Setting = setting.ID == 0 ? new JsonString("[]") : new JsonString(iProvider.ToSetting())
}));
}
public Task GameInfo([FromForm] int?id)
{
GameProvider provider = id == null ? new GameProvider()
{
Name = "", SettingString = "",
}
: (ProviderAgent.Instance().GetGameProviderInfo(id.Value) ?? new GameProvider()
{
Name = "", SettingString = "",
});
IGameProvider iProvider = GameFactory.GetFactory(provider.Type, provider.SettingString);
return(this.GetResult(new
{
provider.ID,
provider.Name,
provider.Type,
Setting = provider.ID == 0 ? new JsonString("[]"): new JsonString(iProvider.ToSetting())
}));
}
public void GetProbability_ExcludeAllCardsExceptYellowTwo_ReturnsOneForYellowTwo()
{
IGameProvider gameProvider = GameProviderFabric.Create(new List <Color> {
Color.Red, Color.Yellow
});
Guess guess = new Guess(gameProvider,
CreateCardInHand(gameProvider, new Card(Color.Yellow, Rank.Two)));
List <Card> cardsToExclude = new List <Card>
{
new Card(Color.Red, Rank.One),
new Card(Color.Red, Rank.One),
new Card(Color.Red, Rank.One),
new Card(Color.Red, Rank.Two),
new Card(Color.Red, Rank.Two),
new Card(Color.Red, Rank.Three),
new Card(Color.Red, Rank.Three),
new Card(Color.Red, Rank.Four),
new Card(Color.Red, Rank.Four),
new Card(Color.Red, Rank.Five),
new Card(Color.Yellow, Rank.One),
new Card(Color.Yellow, Rank.One),
new Card(Color.Yellow, Rank.One),
// miss yellow two.
new Card(Color.Yellow, Rank.Three),
new Card(Color.Yellow, Rank.Three),
new Card(Color.Yellow, Rank.Four),
new Card(Color.Yellow, Rank.Four),
new Card(Color.Yellow, Rank.Five),
};
List <Card> cardsToSearch = new List <Card> {
new Card(Color.Yellow, Rank.Two)
};
Probability result = guess.GetProbability(cardsToSearch, cardsToExclude);
Assert.AreEqual(1.0, result.Value);
}
/// <summary>
///
/// </summary>
/// <param name="provider"></param>
/// <param name="playersCount"></param>
/// <exception cref="TooLessPlayersException"></exception>
/// <exception cref="TooManyPlayersException"></exception>
public Game(IGameProvider provider, int playersCount)
{
if (playersCount < MinPlayerCount)
{
throw new TooLessPlayersException();
}
if (MaxPlayerCount < playersCount)
{
throw new TooManyPlayersException();
}
GameProvider = provider;
_players = new List <Player>();
for (int i = 0; i < playersCount; i++)
{
Player player = new Player(this, i.ToString());
player.ClueGiven += OnClueGiven;
_players.Add(player);
}
Board = Board.Create(provider);
}
public Knowledge(IGameProvider provider)
{
_provider = provider;
}
public GetGameController(IGameProvider provider)
{
_provider = provider;
}
public ScreenGameRenderer(IScreenManager manager, IGameProvider games) : base(manager)
{
_games = games;
}
public FireworkPile(IGameProvider provider)
: base(provider)
{
}
public AppStateContainer(IGameProvider gameProvider, ICelestialSystemSerializer csSerializer)
{
this.gameProvider = gameProvider;
this.csSerializer = csSerializer;
}
public DiscardPile(IGameProvider provider) : base(provider)
{
}
public TheGame(IGameProvider _gameProvider)
{
m_gameProvider = _gameProvider;
MessageManager.NewMessage += MessageManagerNewMessage;
MessageManager.NewWorldMessage += MessageManagerNewWorldMessage;
}
protected Session(string name, IGameProvider gameProvider)
{
Name = name;
CreateNew();
_gameProvider = gameProvider;
}
protected Pile(IGameProvider provider)
{
Provider = provider ?? throw new ArgumentNullException(nameof(provider));
Matrix = provider.CreateEmptyMatrix();
Converter = new CardsToMatrixConverter(provider);
}
public TheGame(IGameProvider _gameProvider)
{
m_gameProvider = _gameProvider;
MessageManager.NewMessage += MessageManagerNewMessage;
MessageManager.NewWorldMessage += MessageManagerNewWorldMessage;
}
public NavalBase(IGameProvider listener, ILocalizationService localization)
{
Localization = localization;
MasterData = new MasterDataRoot(listener, localization);
Quests = new QuestManager(listener, localization);
_allEquipment = new IdTable<EquipmentId, Equipment, IRawEquipment, NavalBase>(this);
_buildingDocks = new IdTable<BuildingDockId, BuildingDock, IRawBuildingDock, NavalBase>(this);
_repairingDocks = new IdTable<RepairingDockId, RepairingDock, IRawRepairingDock, NavalBase>(this);
_useItems = new IdTable<UseItemId, UseItemCount, IRawUseItemCount, NavalBase>(this);
_allShips = new IdTable<ShipId, Ship, IRawShip, NavalBase>(this);
_fleets = new IdTable<FleetId, Fleet, IRawFleet, NavalBase>(this);
_maps = new IdTable<MapId, Map, IRawMap, NavalBase>(this);
_airForce = new IdTable<(MapAreaId MapArea, AirForceGroupId GroupId), AirForceGroup, IRawAirForceGroup, NavalBase>(this);
listener.AllEquipmentUpdated += (t, msg) => _allEquipment.BatchUpdate(msg, t);
listener.BuildingDockUpdated += (t, msg) => _buildingDocks.BatchUpdate(msg, t);
listener.UseItemUpdated += (t, msg) => _useItems.BatchUpdate(msg, t);
listener.AdmiralUpdated += (t, msg) =>
{
if (Admiral?.Id != msg.Id)
{
var @new = new Admiral(msg, this, t);
AdmiralChanging?.Invoke(t, Admiral, @new);
Admiral = @new;
NotifyPropertyChanged(nameof(Admiral));
}
else
Admiral.Update(msg, t);
};
listener.MaterialsUpdated += (t, msg) =>
{
var materials = Materials;
msg.Apply(ref materials);
if (Materials != materials)
{
Materials = materials;
MaterialsUpdating?.Invoke(t, Materials, materials, msg.Reason);
}
};
listener.HomeportReturned += (t, msg) => _allShips.BatchUpdate(msg.Ships, t);
listener.CompositionChanged += (t, msg) =>
{
var fleet = Fleets[msg.FleetId];
if (msg.ShipId is ShipId shipId)
{
var ship = AllShips[shipId];
fleet.ChangeComposition(msg.Index, ship, Fleets.FirstOrDefault(x => x.Ships.Contains(ship)));
}
else
fleet.ChangeComposition(msg.Index, null, null);
};
listener.FleetsUpdated += (t, msg) => _fleets.BatchUpdate(msg, t);
listener.FleetPresetSelected += (t, msg) => Fleets[msg.Id].Update(msg, t);
listener.ShipEquipmentUdated += (t, msg) => AllShips[msg.ShipId].UpdateEquipments(msg.EquipmentIds);
listener.ShipExtraSlotOpened += (t, msg) => AllShips[msg].ExtraSlot = new Slot();
listener.PartialFleetsUpdated += (t, msg) => _fleets.BatchUpdate(msg, t, removal: false);
listener.PartialShipsUpdated += (t, msg) => _allShips.BatchUpdate(msg, t, removal: false);
listener.RepairingDockUpdated += (t, msg) => _repairingDocks.BatchUpdate(msg, t);
listener.ShipSupplied += (t, msg) =>
{
foreach (var raw in msg)
AllShips[raw.ShipId]?.Supply(raw);
};
listener.RepairStarted += (t, msg) =>
{
if (msg.InstantRepair)
AllShips[msg.ShipId]?.SetRepaired();
};
listener.InstantRepaired += (t, msg) =>
{
var dock = RepairingDocks[msg];
dock.State = RepairingDockState.Empty;
dock.RepairingShip = null;
};
listener.InstantBuilt += (t, msg) => BuildingDocks[msg].State = BuildingDockState.BuildCompleted;
listener.ShipBuildCompleted += (t, msg) =>
{
_allEquipment.BatchUpdate(msg.Equipments, t, removal: false);
_allShips.Add(msg.Ship, t);
};
listener.EquipmentCreated += (t, msg) =>
{
if (msg.IsSuccess)
_allEquipment.Add(msg.Equipment, t);
};
listener.ShipDismantled += (t, msg)
=> ShipDismantling?.Invoke(t, RemoveShips(msg.ShipIds, msg.DismantleEquipments, t), msg.DismantleEquipments);
listener.EquipmentDismantled += (t, msg) => EquipmentDismantling?.Invoke(t, RemoveEquipments(msg, t));
listener.EquipmentImproved += (t, msg) =>
{
var consumed = RemoveEquipments(msg.ConsumedEquipmentIds, t);
var original = AllEquipment[msg.EquipmentId];
EquipmentImproving?.Invoke(t, original, msg.UpdatedTo, consumed, msg.IsSuccess);
if (msg.IsSuccess)
original.Update(msg.UpdatedTo, t);
};
listener.ShipPoweruped += (t, msg) =>
{
var consumed = RemoveShips(msg.ConsumedShipIds, true, t);
var original = AllShips[msg.ShipId];
ShipPoweruping?.Invoke(t, original, msg.UpdatedTo, consumed);
original.Update(msg.UpdatedTo, t);
};
listener.MapsUpdated += (t, msg) => _maps.BatchUpdate(msg, t);
listener.AirForceUpdated += (t, msg) => _airForce.BatchUpdate(msg, t);
listener.AirForcePlaneSet += (t, msg) =>
{
var group = AirForce[(msg.MapAreaId, msg.GroupId)];
group.Distance = msg.NewDistance;
group.squadrons.BatchUpdate(msg.UpdatedSquadrons, t, removal: false);
};
internal InternalConsoleSession(string name, IGameProvider gameProvider) : base(name, gameProvider)
{
}
public GameMediatorService(IGameProvider gameProvider)
{
_gameProvider = gameProvider;
playerStreamlist = new Dictionary <int, PlayerStream>();
}
public MovesProvider(ICacheProvider cacheProvider , IGameProvider gameProvider , IMovesDataProvider movesDataProvider )
{
_cacheProvider = cacheProvider;
_gameProvider = gameProvider;
_movesDataProvider = movesDataProvider;
}
public Matrix(IGameProvider provider)
{
_gameProvider = provider ?? throw new ArgumentNullException(nameof(provider));
_matrix = new int[provider.Ranks.Count, provider.Colors.Count];
}
public PilesAnalyzer(IGameProvider provider)
{
_provider = provider;
_converter = new CardsToMatrixConverter(provider);
}
public void Init(IGameProvider gameProvider)
{
this.gameProvider = gameProvider;
}
public Logger(IDataService dataService, IGameProvider provider, NavalBase navalBase)
{
this.dataService = dataService;
this.navalBase = navalBase;
provider.EquipmentCreated += (t, m) =>
{
using (var context = CreateContext())
{
context.EquipmentCreationTable.Add(new EquipmentCreationEntity
{
TimeStamp = t,
Consumption = m.Consumption,
EquipmentCreated = m.SelectedEquipentInfoId,
IsSuccess = m.IsSuccess,
AdmiralLevel = this.navalBase.Admiral.Leveling.Level,
Secretary = this.navalBase.Secretary.Info.Id,
SecretaryLevel = this.navalBase.Secretary.Leveling.Level
});
context.SaveChanges();
}
};
provider.ShipCreated += (t, m) =>
{
shipCreation = new ShipCreationEntity
{
TimeStamp = t,
Consumption = m.Consumption,
IsLSC = m.IsLSC,
AdmiralLevel = this.navalBase.Admiral.Leveling.Level,
Secretary = this.navalBase.Secretary.Info.Id,
SecretaryLevel = this.navalBase.Secretary.Leveling.Level
};
lastBuildingDock = m.BuildingDockId;
};
provider.BuildingDockUpdated += (t, m) =>
{
if (shipCreation != null)
{
using (var context = CreateContext())
{
shipCreation.ShipBuilt = m.Single(x => x.Id == lastBuildingDock).BuiltShipId.Value;
shipCreation.EmptyDockCount = navalBase.BuildingDocks.Count(x => x.State == BuildingDockState.Empty);
context.ShipCreationTable.Add(shipCreation);
shipCreation = null;
lastBuildingDock = default;
context.SaveChanges();
}
}
};
provider.ExpeditionCompleted += (t, m) =>
{
using (var context = CreateContext())
{
context.ExpeditionCompletionTable.Add(new ExpeditionCompletionEntity
{
TimeStamp = t,
ExpeditionId = this.navalBase.Fleets[m.FleetId].Expedition.Id,
ExpeditionName = m.ExpeditionName,
Result = m.Result,
MaterialsAcquired = m.MaterialsAcquired,
RewardItem1 = m.RewardItem1,
RewardItem2 = m.RewardItem2
});
context.SaveChanges();
}
};
#if DEBUG
using (var context = CreateContext())
context.Database.Migrate();
#endif
provider.AdmiralUpdated += (t, m) =>
{
if (PlayerLoaded)
{
using (var context = CreateContext())
context.Database.Migrate();
}
};
}
public CardsToMatrixConverter(IGameProvider provider)
{
_provider = provider ?? throw new ArgumentNullException(nameof(provider));
}
