public override void UndoUseWater(AbstractGameAsset a)
{
if (!a.CanBeAllocatedWater)
{
throw new WaterWarsGameLogicException(
string.Format(
"Attempt made to undo allocate water on asset {0} but this asset type does not allow water allocation",
a.Name));
}
if (!a.IsBuilt)
{
throw new WaterWarsGameLogicException(
"{0} tried to undo allocate water on asset {1} but it is only partially built",
a.OwnerName, a.Name);
}
Player p = a.Field.BuyPoint.DevelopmentRightsOwner;
BuyPoint bp = a.Field.BuyPoint;
m_log.InfoFormat(
"[WATER WARS]: {0} undoing use of {1} on {2} at {3} in {4}",
p.Name, WaterWarsUtils.GetWaterUnitsText(a.WaterAllocated), a.Name, bp.Name, bp.Location.RegionName);
m_controller.WaterAllocator.ChangeAllocation(a, p, 0);
m_controller.EventManager.TriggerWaterUsed(a, p, 0);
a.TriggerChanged();
bp.TriggerChanged();
p.TriggerChanged();
UpdateHudStatus(p);
}
public void TriggerGameAssetBuildCompleted(AbstractGameAsset ga)
{
if (OnGameAssetBuildCompleted != null)
{
OnGameAssetBuildCompleted(ga);
}
}
/// <summary>
/// Create a game asset view
/// </summary>
/// <param name="asset"></param>
/// <returns>A view that doesn't have a link to the model. The caller needs to link this subsequently</returns>
public GameAssetView CreateGameAssetView(AbstractGameAsset asset)
{
GameAssetView v = null;
FieldView fv = m_fieldViews[asset.Field.Uuid];
Vector3 pos = fv.RootPart.AbsolutePosition;
if (asset.Type == AbstractGameAssetType.Factory)
{
v = new FactoryView(m_controller, m_scene, asset, m_itemStoreView);
}
else if (asset.Type == AbstractGameAssetType.Houses)
{
v = new HousesView(m_controller, m_scene, asset, m_itemStoreView);
}
else if (asset.Type == AbstractGameAssetType.Crops)
{
v = new CropsView(m_controller, m_scene, asset, m_itemStoreView);
}
else
{
throw new Exception(string.Format("Unrecognized asset type {0} at position {1}", asset.Type, pos));
}
fv.Close();
m_fieldViews.Remove(asset.Field.Uuid);
v.Initialize(pos);
return(v);
}
public void TriggerGameAssetRemoved(AbstractGameAsset ga)
{
if (OnGameAssetRemoved != null)
{
OnGameAssetRemoved(ga);
}
}
public void TriggerGameAssetSoldToEconomy(AbstractGameAsset ga, Player p, int price)
{
if (OnGameAssetSoldToEconomy != null)
{
OnGameAssetSoldToEconomy(ga, p, price);
}
}
public void TriggerGameAssetUpgraded(AbstractGameAsset ga, int oldLevel)
{
if (OnGameAssetUpgraded != null)
{
OnGameAssetUpgraded(ga, oldLevel);
}
}
protected void RecordGameAsset(AbstractGameAsset ga)
{
m_xtw.WriteStartElement(AssetElement);
RecordAttributes(ga);
m_xtw.WriteElementString("Level", ga.Level.ToString());
m_xtw.WriteElementString("MinLevel", ga.MinLevel.ToString());
m_xtw.WriteElementString("MaxLevel", ga.MaxLevel.ToString());
m_xtw.WriteElementString(PriceElement, ga.ConstructionCost.ToString());
m_xtw.WriteElementString("PricePerBuildStep", ga.ConstructionCostPerBuildStep.ToString());
m_xtw.WriteElementString("StepsBuilt", ga.StepsBuilt.ToString());
m_xtw.WriteElementString("StepsRequired", ga.StepsToBuild.ToString());
m_xtw.WriteElementString("StepBuiltThisTurn", ga.StepBuiltThisTurn.ToString());
m_xtw.WriteElementString("IsMultiStepBuild", ga.IsMultiStepBuild.ToString());
m_xtw.WriteElementString("IsBuilt", ga.IsBuilt.ToString());
m_xtw.WriteElementString("IsDependentOnWaterToExist", ga.IsDependentOnWaterToExist.ToString());
m_xtw.WriteElementString("IsSoldToEconomy", ga.IsSoldToEconomy.ToString());
m_xtw.WriteElementString("MarketPrice", ga.MarketPrice.ToString());
m_xtw.WriteElementString("NormalOperatingRevenue", ga.NormalRevenue.ToString());
m_xtw.WriteElementString("OperatingRevenue", ga.ProjectedRevenue.ToString());
m_xtw.WriteElementString("NominalMaximumProfitThisTurn", ga.NominalMaximumProfitThisTurn.ToString());
m_xtw.WriteElementString("Profit", ga.Profit.ToString());
m_xtw.WriteElementString("WaterUsage", ga.WaterUsage.ToString());
m_xtw.WriteElementString("WaterAllocated", ga.WaterAllocated.ToString());
m_xtw.WriteElementString("MaintenanceCost", ga.MaintenanceCost.ToString());
m_xtw.WriteElementString("AccruedMaintenanceCost", ga.AccruedMaintenanceCost.ToString());
m_xtw.WriteElementString("TimeToLive", ga.TimeToLive.ToString());
m_xtw.WriteElementString("CanBeAllocatedWater", ga.CanBeAllocatedWater.ToString());
m_xtw.WriteElementString("CanBePartiallyAllocatedWater", ga.CanPartiallyAllocateWater.ToString());
m_xtw.WriteElementString("CanBeSoldToEconomy", ga.CanBeSoldToEconomy.ToString());
m_xtw.WriteElementString("CanUpgradeInPrinciple", ga.CanUpgradeInPrinciple.ToString());
m_xtw.WriteElementString("CanUpgrade", ga.CanUpgrade.ToString());
m_xtw.WriteEndElement();
}
public void TestWaterDependentCropBehaviour()
{
TestHelpers.InMethod();
AddBuyPoints();
AddPlayers(Farmer.Singleton);
StartGame();
m_controller.State.BuyLandRights(bp1, p1);
m_controller.State.BuyLandRights(bp2, p1);
AbstractGameAsset c1
= m_controller.State.BuildGameAsset(bp1.Fields.Values.ToList()[0], Crops.Template, (int)CropType.Grapes);
EndTurns();
m_controller.State.UseWater(c1, p1, c1.WaterUsage);
EndTurns();
Assert.That(bp1.Cropss.Count, Is.EqualTo(1));
// Switch from build to water and back again
EndTurns(2);
// Without watering, the crops should have died
Assert.That(bp1.Cropss.Count, Is.EqualTo(0));
}
public void TriggerWaterUsed(AbstractGameAsset ga, Player user, int amount)
{
if (OnWaterUsed != null)
{
OnWaterUsed(ga, user, amount);
}
}
public void TestSalesRevenue()
{
TestHelpers.InMethod();
//log4net.Config.XmlConfigurator.Configure();
AddBuyPoints();
AddPlayers(Farmer.Singleton);
StartGame();
m_controller.State.BuyLandRights(bp1, p1);
m_controller.State.BuyLandRights(bp2, p1);
AbstractGameAsset c1 = m_controller.State.BuildGameAsset(bp1.Fields.Values.ToList()[0], Crops.Template, 1);
EndTurns(1);
m_controller.State.UseWater(c1, p1, c1.WaterUsage);
EndTurns(1);
Assert.That(p1.History[1].BuildRevenueThisTurn, Is.EqualTo(0));
Assert.That(p1.History[1].WaterRevenueThisTurn, Is.EqualTo(0));
Assert.That(p1.History[1].BuildCostsThisTurn, Is.EqualTo(c1.ConstructionCost));
Assert.That(p1.History[1].WaterCostsThisTurn, Is.EqualTo(0));
Assert.That(p1.History[1].CostOfLiving, Is.EqualTo(p1.CostOfLiving));
Assert.That(p1.History[1].ProjectedRevenueFromProducts, Is.EqualTo(c1.ProjectedRevenue));
Assert.That(p1.History[1].Profit, Is.EqualTo(c1.ProjectedRevenue - c1.ConstructionCost - p1.CostOfLiving));
}
/// <summary>
/// Use available water on a particular asset on a particular parcel
/// </summary>
/// <param name="rawBuyPointId"></param>
/// <param name="rawAssetId"></param>
/// <param name="rawPlayerId">Temporarily, this can be UUID.Zero if no player id was supplied in the request</param>
/// <param name="amount">
/// Amount of water to use. If this is zero and there already is some water allocated then this signals undo
/// </param>
public void UseWater(string rawBuyPointId, string rawAssetId, string rawPlayerId, int amount)
{
UUID buyPointId = WaterWarsUtils.ParseRawId(rawBuyPointId);
UUID assetId = WaterWarsUtils.ParseRawId(rawAssetId);
UUID playerId = WaterWarsUtils.ParseRawId(rawPlayerId);
BuyPoint bp = GetBuyPoint(buyPointId);
AbstractGameAsset a = GetAsset(bp, assetId);
if (0 == amount)
{
m_controller.State.UndoUseWater(a);
}
else
{
Player p = null;
if (playerId != UUID.Zero)
{
p = GetPlayer(playerId);
}
else
{
p = bp.DevelopmentRightsOwner;
}
m_controller.State.UseWater(a, p, amount);
}
}
public void ChangeAllocation(AbstractGameAsset a, Player p, int allocation)
{
int adjustment = allocation - a.WaterAllocated;
if (adjustment > p.Water)
{
throw new WaterWarsGameLogicException(
string.Format(
"Player {0} only has {1} water, not enough to satisfy allocation adjustment of {2}",
p.Name, p.Water, adjustment));
}
if (adjustment == 0)
{
return;
}
else if (adjustment > 0)
{
TakeWater(a, p, adjustment);
}
else
{
GiveBackWater(a, p, -adjustment);
}
}
public override AbstractGameAsset BuildGameAsset(Field f, AbstractGameAsset templateAsset, int level)
{
BuyPoint bp = f.BuyPoint;
Player p = bp.DevelopmentRightsOwner;
if (!p.Role.AllowedAssets.Contains(templateAsset))
{
throw new WaterWarsGameLogicException(
"[WATER WARS]: Player {0} tried to buy a {1} on {2} but this is not one of their allowed assets",
p.Name, templateAsset.Type, bp.Name);
}
AbstractGameAsset ga
= m_controller.ModelFactory.CreateGameAsset(f, templateAsset, Vector3.Zero, level);
int price = ga.ConstructionCostPerBuildStep;
if (p.Money < price)
{
// TODO: Signal this to the player in-world in some way
throw new WaterWarsGameLogicException(
"[WATER WARS]: Player {0} has {1}, not enough to starting building a {2} costing {3}",
p, p.Money, templateAsset.Type, price);
}
m_log.InfoFormat(
"[WATER WARS]: Player {0} building a {1} on {2} in {3} for {4} (approx {5} each turn)",
p.Name, ga.Type, bp.Name, bp.Location.RegionName, ga.ConstructionCost, price);
p.Money -= price;
p.BuildCostsThisTurn += price;
ga.StepsBuilt++;
ga.StepBuiltThisTurn = true;
// We have to remove the field from the buy point - it is now attached to the game asset if we want it back
// later on. This is pretty nasty - fields and game assets should probably occupy specific slots on the
// BuyPoint now.
// NO! The buy point has to be kept here since this is actually the only way that the game asset can
// retrieve the field.
// f.BuyPoint = null;
bp.AddGameAsset(ga);
m_controller.EventManager.TriggerGameAssetBuildStarted(ga);
if (ga.IsBuilt)
{
m_controller.EventManager.TriggerGameAssetBuildCompleted(ga);
}
p.TriggerChanged();
bp.TriggerChanged();
// Don't trigger this change since we are deleting the field view
//f.TriggerChanged();
UpdateHudStatus(p);
return(ga);
}
public CropsView(WaterWarsController controller, Scene scene, AbstractGameAsset asset, AbstractView itemStoreView)
: base(controller, scene, asset, itemStoreView)
{
m_veSceneObjectNames = new string[4, 1];
m_veSceneObjectNames[1, 0] = string.Format("{0}_Alfalfa", IN_WORLD_NAME);
m_veSceneObjectNames[2, 0] = string.Format("{0}_Chillis", IN_WORLD_NAME);
m_veSceneObjectNames[3, 0] = string.Format("{0}_Grapes", IN_WORLD_NAME);
}
public WaterAllocationDecorator(
WaterWarsController controller, Scene scene, AbstractGameAsset asset, AbstractView itemStoreView, Vector3 positionToDisplay)
: base(controller, scene, itemStoreView, IN_WORLD_NAME, positionToDisplay)
{
GameAsset = asset;
Update();
GameAsset.OnChange += GameAssetChanged;
}
protected void OnGameAssetBuildStarted(AbstractGameAsset ga)
{
if (ga != m_gav.GameAsset)
{
return;
}
LabelBehaviour.Text = GetGameAssetStatusMessage();
}
protected void OnGameAssetUpgraded(AbstractGameAsset ga, int oldLevel)
{
if (ga != m_gav.GameAsset)
{
return;
}
LabelBehaviour.Text = GetGameAssetStatusMessage();
}
/// <summary>
/// Remove a particular game asset on a parcel
/// </summary>
/// <param name="buyPointId"></param>
/// <param name="rawGameAssetId">
public Field RemoveGameAsset(string rawBuyPointId, string rawGameAssetId)
{
UUID buyPointId = WaterWarsUtils.ParseRawId(rawBuyPointId);
UUID gameAssetId = WaterWarsUtils.ParseRawId(rawGameAssetId);
BuyPoint bp = GetBuyPoint(buyPointId);
AbstractGameAsset ga = GetAsset(bp, gameAssetId);
return(m_controller.State.RemoveGameAsset(ga));
}
/// <summary>
/// Upgrade a game asset.
/// </summary>
/// This is called by code which only has the ids available.
/// <param name="rawBuyPointId"></param>
/// <param name="rawPlayerId"></param>
/// <param name="level"></param>
public void UpgradeGameAsset(string rawBuyPointId, string rawAssetId, int level)
{
UUID buyPointId = WaterWarsUtils.ParseRawId(rawBuyPointId);
BuyPoint bp = GetBuyPoint(buyPointId);
UUID assetId = WaterWarsUtils.ParseRawId(rawAssetId);
AbstractGameAsset asset = GetAsset(bp, assetId);
m_controller.State.UpgradeGameAsset(bp.DevelopmentRightsOwner, asset, level);
}
/// <summary>
/// Buy a game asset.
/// </summary>
/// <param name="rawBuyPointId"></param>
/// <param name="rawAssetId"></param>
public AbstractGameAsset ContinueBuildingGameAsset(string rawBuyPointId, string rawAssetId)
{
UUID buyPointId = WaterWarsUtils.ParseRawId(rawBuyPointId);
BuyPoint bp = GetBuyPoint(buyPointId);
UUID assetId = WaterWarsUtils.ParseRawId(rawAssetId);
AbstractGameAsset asset = GetAsset(bp, assetId);
return(m_controller.State.ContinueBuildingGameAsset(asset));
}
/// <summary>
/// Sell a game asset to the economy
/// </summary>
/// <param name="rawBuyPointId"></param>
/// <param name="rawGameAssetId"></param>
public void SellGameAssetToEconomy(string rawBuyPointId, string rawGameAssetId)
{
UUID buyPointId = WaterWarsUtils.ParseRawId(rawBuyPointId);
UUID gameAssetId = WaterWarsUtils.ParseRawId(rawGameAssetId);
BuyPoint bp = GetBuyPoint(buyPointId);
AbstractGameAsset ga = GetAsset(bp, gameAssetId);
m_controller.State.SellGameAssetToEconomy(ga);
}
public override void UpgradeGameAsset(Player p, AbstractGameAsset ga, int newLevel)
{
BuyPoint bp = ga.Field.BuyPoint;
if (!ga.IsBuilt)
{
throw new WaterWarsGameLogicException(
"{0} tried to upgrade {1} at {2} in {3} but the asset is only partially built",
p.Name, ga.Name, bp.Name, bp.Location.RegionName);
}
if (newLevel <= ga.Level)
{
throw new WaterWarsGameLogicException(
"{0} tried to upgrade {1} to level {2} but asset is already at level {3}",
p, ga, newLevel, ga.Level);
}
if (newLevel > ga.MaxLevel)
{
throw new WaterWarsGameLogicException(
"{0} tried to upgrade {1} to level {2} but max level of asset is {3}",
p, ga, newLevel, ga.MaxLevel);
}
int price = ga.ConstructionCosts[newLevel] - ga.ConstructionCosts[ga.Level];
if (p.Money < price)
{
throw new WaterWarsGameLogicException(
"{0} has {1}, not enough to upgrade {2} to level {3} which costs {4}",
p, p.Money, ga, newLevel, price);
}
m_log.InfoFormat(
"[WATER WARS]: {0} upgrading {1} on {2} in {3} to level {4}",
p.Name, ga.Name, bp.Name, bp.Location.RegionName, newLevel);
// Perform the transaction
p.Money -= price;
int oldLevel = ga.Level;
ga.Level = newLevel;
ga.Name = string.Format("{0} ({1})", ga.InitialNames[ga.Level], ga.Field.Name);
ga.RevenueThisTurn = m_controller.EconomicDistributor.Allocate(ga.Game.EconomicActivity, ga);
m_controller.EventManager.TriggerGameAssetUpgraded(ga, oldLevel);
bp.TriggerChanged();
p.TriggerChanged();
ga.TriggerChanged();
UpdateHudStatus(p);
}
protected void CreateGameAssetView(AbstractGameAsset asset)
{
lock (m_buyPointViews)
{
GameAssetView gav = GetBuyPointView(asset.BuyPointUuid).CreateGameAssetView(asset);
asset.Position = gav.RootPart.AbsolutePosition;
lock (m_gameAssetViews)
m_gameAssetViews.Add(gav.Uuid, gav);
}
}
public HousesView(WaterWarsController controller, Scene scene, AbstractGameAsset asset, AbstractView itemStoreView)
: base(controller, scene, asset, itemStoreView)
{
m_veSceneObjectNames = new string[4, 2];
m_veSceneObjectNames[1, 0] = string.Format("{0}_Level-1-under-construction", IN_WORLD_NAME);
m_veSceneObjectNames[2, 0] = string.Format("{0}_Level-2-under-construction", IN_WORLD_NAME);
m_veSceneObjectNames[3, 0] = string.Format("{0}_Level-3-under-construction", IN_WORLD_NAME);
m_veSceneObjectNames[1, 1] = string.Format("{0}_Level-1", IN_WORLD_NAME);
m_veSceneObjectNames[2, 1] = string.Format("{0}_Level-2", IN_WORLD_NAME);
m_veSceneObjectNames[3, 1] = string.Format("{0}_Level-3", IN_WORLD_NAME);
}
protected void TakeWater(AbstractGameAsset a, Player p, int waterRequired)
{
m_log.InfoFormat(
"[WATER WARS]: Allocating {0} water to {1} owned by {2}",
waterRequired, a.Name, a.Field.BuyPoint.DevelopmentRightsOwner);
int totalWaterTaken = 0;
if (a.Field.BuyPoint.WaterRightsOwner == p)
{
int waterTaken = Math.Min(a.Field.BuyPoint.WaterAvailable, waterRequired);
a.Field.BuyPoint.WaterAvailable -= waterTaken;
waterRequired -= waterTaken;
totalWaterTaken += waterTaken;
}
// We need to pull in water from other places.
if (waterRequired > 0)
{
lock (p.WaterRightsOwned)
{
Dictionary <UUID, BuyPoint> otherRights = new Dictionary <UUID, BuyPoint>(p.WaterRightsOwned);
otherRights.Remove(a.Field.BuyPoint.Uuid);
while (waterRequired > 0)
{
BuyPoint waterMaxBp = BuyPoint.None;
foreach (BuyPoint bp in otherRights.Values)
{
if (bp.WaterAvailable > waterMaxBp.WaterAvailable)
{
waterMaxBp = bp;
}
}
m_log.InfoFormat(
"[WATER WARS]: ParcelOrientedAllocator determined buy point {0} has max water of {1}",
waterMaxBp.Name, waterMaxBp.WaterAvailable);
int waterTaken = Math.Min(waterMaxBp.WaterAvailable, waterRequired);
waterMaxBp.WaterAvailable -= waterTaken;
waterRequired -= waterTaken;
totalWaterTaken += waterTaken;
}
}
}
a.WaterAllocated += totalWaterTaken;
//p.Water -= a.WaterUsage;
a.TriggerChanged();
}
/// <summary>
/// Load a set of values for a given configurable parameter of a game asset (e.g. costs)
/// </summary>
/// <param name="config"></param>
/// <param name="keyNames"></param>
/// <param name="keyPostFix"></param>
/// <param name="template"></param>
/// <returns></returns>
protected int[] LoadValues(
IConfig config, List <string> keyNames, string keyPostFix, AbstractGameAsset template)
{
int[] values = new int[keyNames.Count];
for (int i = template.MinLevel; i <= template.MaxLevel; i++)
{
string keyName
= string.Format(ConfigurationParser.GAME_ASSET_KEY_FORMAT, keyNames[i].ToLower(), keyPostFix);
values[i] = config.GetInt(keyName);
}
return(values);
}
protected void OnGameAssetSoldToEconomy(AbstractGameAsset ga, Player owner, int price)
{
if (ga != m_gav.GameAsset)
{
return;
}
Color4 soldColour = new Color4(32, 44, 66, 255);
Part.ParentGroup.OwnerID = m_controller.Game.Economy.Uuid;
ChangeTextureColor(soldColour);
Part.ParentGroup.ScheduleGroupForFullUpdate();
}
protected void OnGameAssetUpgraded(AbstractGameAsset ga, int oldLevel)
{
if (ga != GameAsset)
{
return;
}
int lastPhaseIndex = m_veSceneObjectNames.GetLength(1) - 1;
ReplaceSceneObjectFromInventoryItem(
m_veSceneObjectNames[GameAsset.Level, lastPhaseIndex], GameAsset, GameAsset.OwnerUuid);
m_button.ResetButtonPrims(m_rootPart);
}
protected void OnGameAssetBuildCompleted(AbstractGameAsset ga)
{
if (ga != m_gav.GameAsset)
{
return;
}
Color4 neutralColour = new Color4(255, 255, 255, 255);
ChangeTextureColor(neutralColour);
Part.ParentGroup.ScheduleGroupForFullUpdate();
LabelBehaviour.Text = GetGameAssetStatusMessage();
}
// private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
public void ChangeAllocation(AbstractGameAsset a, Player p, int allocation)
{
int adjustment = allocation - a.WaterAllocated;
if (adjustment > p.Water)
{
throw new WaterWarsGameLogicException(
string.Format(
"Player {0} only has {1} water, not enough to satisfy allocation adjustment of {2}",
p.Name, p.Water, adjustment));
}
a.WaterAllocated += adjustment;
p.Water -= adjustment;
}
