public FocusBarUpgradeResponse(bool hasUpgraded, FocusBarModel focusBarModel, FocusCardModel oldTech, FocusCardModel newTech)
{
HasUpgraded = hasUpgraded;
UpgradedFocusBar = focusBarModel;
OldTechnology = oldTech;
NewTechnology = newTech;
}
private FocusCardModel GetFocusCardToUpgrade(FocusBarModel activeFocusBar)
{
var lowestTechLevel = activeFocusBar.ActiveFocusSlots.Min(x => x.Value.Level);
var lowestTechFocusCards = activeFocusBar.ActiveFocusSlots.Where(x => x.Value.Level == lowestTechLevel).ToList();
var focusCardToUpgrade = lowestTechFocusCards.ElementAt(_randomService.Next(lowestTechFocusCards.Count - 1));
return(focusCardToUpgrade.Value);
}
public FocusBarUpgradeResponse ResolveFreeTechnologyUpdate(FocusBarModel activeFocusBar)
{
// DBr: this wrapper method feels forced : rational was to prevent a new dependency going into the consumer
// as the consumer would already have a dependency on this guy (which already has a dependency on our focusbar guy)
// smells a little bit tho - perhaps we strip this method out and let the consumer have an additonal dependency
if (!activeFocusBar.ActiveFocusSlots.All(x => x.Value.Level == FocusLevel.Lvl4))
{
return(_focusBarTechnologyUpgradeResolver.RegenerateFocusBarLowestTechnologyLevelUpgrade(activeFocusBar));
}
return(new FocusBarUpgradeResponse(false, activeFocusBar, null, null));
}
public FocusBarModel ResetFocusBarForNextMove(FocusBarModel activeFocusBar)
{
// shift all cards up by 1 with slot resolved this turn being reset to first slot
var tmpSlot2 = activeFocusBar.FocusSlot1;
var newFocusBar = new Dictionary <int, FocusCardModel>();
newFocusBar.Add(0, activeFocusBar.FocusSlot5);
newFocusBar.Add(4, activeFocusBar.FocusSlot4);
newFocusBar.Add(3, activeFocusBar.FocusSlot3);
newFocusBar.Add(2, activeFocusBar.FocusSlot2);
newFocusBar.Add(1, tmpSlot2);
return(new FocusBarModel(new ReadOnlyDictionary <int, FocusCardModel>(newFocusBar)));
}
public FocusType ResolveSmallestTokenPile(FocusBarModel activeFocusBar, Dictionary <FocusType, int> tradeTokenPiles)
{
var smallestPileValue = 0;
var smallestPileType = FocusType.Culture;
foreach (var x in activeFocusBar.ActiveFocusSlots)
{
var tokenpile = tradeTokenPiles[x.Value.Type];
if (tokenpile <= smallestPileValue)
{
smallestPileType = x.Value.Type;
}
}
return(smallestPileType);
}
public FocusBarModel ResetFocusBarForSubMove(FocusBarModel activeFocusBar, FocusType focusType)
{
var slotIndexToReset = activeFocusBar.ActiveFocusSlots.First(x => x.Value.Type == focusType).Key;
if (slotIndexToReset == 0)
{
return(activeFocusBar);
}
var newFocusBar = new Dictionary <int, FocusCardModel>();
if (slotIndexToReset == 1)
{
var tmpSlot2 = activeFocusBar.FocusSlot1;
newFocusBar.Add(0, activeFocusBar.ActiveFocusSlots[slotIndexToReset]);
newFocusBar.Add(1, tmpSlot2);
newFocusBar.Add(2, activeFocusBar.ActiveFocusSlots[2]);
newFocusBar.Add(3, activeFocusBar.ActiveFocusSlots[3]);
newFocusBar.Add(4, activeFocusBar.ActiveFocusSlots[4]);
}
else
{
var tmpSlot2 = activeFocusBar.FocusSlot1;
newFocusBar.Add(0, activeFocusBar.ActiveFocusSlots[slotIndexToReset]);
var slotPointer = 0;
for (int i = slotIndexToReset - 1; i > 1; i--)
{
newFocusBar.Add(i, activeFocusBar.ActiveFocusSlots[i - 1]);
slotPointer++;
}
newFocusBar.Add(1, tmpSlot2);
for (int i = slotIndexToReset; i < 5; i++)
{
newFocusBar.Add(i, activeFocusBar.ActiveFocusSlots[i]);
slotPointer++;
}
// TODO: we need to add the unaffected cards after slot index
}
return(new FocusBarModel(new ReadOnlyDictionary <int, FocusCardModel>(newFocusBar)));
}
private FocusBarUpgradeResponse CreateUpgradedFocusBar(FocusBarModel activeFocusBar, FocusCardModel focusCardToUpgrade, FocusCardModel upgradeFocusCard)
{
Dictionary <int, FocusCardModel> newFocusBarCards = new Dictionary <int, FocusCardModel>();
foreach (var fs in activeFocusBar.ActiveFocusSlots)
{
if (fs.Value.Name == focusCardToUpgrade.Name)
{
newFocusBarCards.Add(fs.Key, upgradeFocusCard);
}
else
{
newFocusBarCards.Add(fs.Key, fs.Value);
}
}
var upgradedFocusBar = new FocusBarModel(new ReadOnlyDictionary <int, FocusCardModel>(newFocusBarCards));
return(new FocusBarUpgradeResponse(true, upgradedFocusBar, focusCardToUpgrade, upgradeFocusCard));
}
public TechnologyUpgradeResponse ResolveTechnologyLevelUpdates(int currentTechLevel, int techLevelIncrement, FocusBarModel activeFocusBar)
{
var encounteredBreakthroughs = new List <BreakthroughModel>();
var breakThroughResponse = _technologyBreakthroughResolver.ResolveTechnologyBreakthrough(currentTechLevel, techLevelIncrement);
if (breakThroughResponse != null) // TODO: do we have better than null check here to define if no breakthrough??
{
foreach (var breakthroughLevel in breakThroughResponse)
{
if (!activeFocusBar.ActiveFocusSlots.All(x => x.Value.Level == FocusLevel.Lvl4))
{
var techUpgradeResponse = _focusBarTechnologyUpgradeResolver.RegenerateFocusBarLowestTechnologyLevelUpgrade(activeFocusBar, breakthroughLevel);
activeFocusBar = techUpgradeResponse.UpgradedFocusBar;
encounteredBreakthroughs.Add(new BreakthroughModel(techUpgradeResponse.OldTechnology, techUpgradeResponse.NewTechnology));
}
}
}
var newTechLevelPoints = currentTechLevel + techLevelIncrement;
return(new TechnologyUpgradeResponse(newTechLevelPoints, activeFocusBar, encounteredBreakthroughs));
}
public TechnologyUpgradeResponse(int newTechnologyLevel, FocusBarModel focusBarModel, IReadOnlyCollection <BreakthroughModel> encounteredBreakthroughs)
{
NewTechnologyLevelPoints = newTechnologyLevel;
UpgradedFocusBar = focusBarModel;
EncounteredBreakthroughs = encounteredBreakthroughs;
}
public FocusBarUpgradeResponse RegenerateFocusBarSpecificTechnologyLevelUpgrade(FocusBarModel activeFocusBar, FocusType focusType)
{
var focusCardToUpgrade = activeFocusBar.ActiveFocusSlots.First(x => x.Value.Type == focusType).Value;
var upgradeFocusCard = GetUpgradeFocusCard(focusCardToUpgrade, focusCardToUpgrade.Level + 1);
return(CreateUpgradedFocusBar(activeFocusBar, focusCardToUpgrade, upgradeFocusCard));
}
public FocusBarUpgradeResponse RegenerateFocusBarLowestTechnologyLevelUpgrade(FocusBarModel activeFocusBar)
{
var focusCardToUpgrade = GetFocusCardToUpgrade(activeFocusBar);
var targetLevel = DetermineNextTechnologyLevelForFocusCard(focusCardToUpgrade);
var upgradeFocusCard = GetUpgradeFocusCard(focusCardToUpgrade, targetLevel);
return(CreateUpgradedFocusBar(activeFocusBar, focusCardToUpgrade, upgradeFocusCard));
}
public FocusBarUpgradeResponse RegenerateFocusBarLowestTechnologyLevelUpgrade(FocusBarModel activeFocusBar, FocusLevel levelBarrierHit)
{
var focusCardToUpgrade = GetFocusCardToUpgrade(activeFocusBar);
var upgradeFocusCard = GetUpgradeFocusCard(focusCardToUpgrade, levelBarrierHit);
return(CreateUpgradedFocusBar(activeFocusBar, focusCardToUpgrade, upgradeFocusCard));
}
