예제 #1
0
        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);
        }
예제 #2
0
        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 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();
        }
        protected void GiveBackWater(AbstractGameAsset a, Player p, int waterToReturn)
        {
            m_log.InfoFormat(
                "[WATER WARS]: Deallocating {0} water from {1} owned by {2}",
                waterToReturn, a.Name, a.Field.BuyPoint.DevelopmentRightsOwner);

            BuyPoint assetBp = a.Field.BuyPoint;

            // If the asset owner has no water rights anywhere then the water is simply lost.
            if (assetBp.DevelopmentRightsOwner.WaterRightsOwned.Count == 0)
            {
                return;
            }

            // If the asset sits in a parcel for which the owner also owns water rights, then just return the water
            // there
            if (assetBp.DevelopmentRightsOwner == assetBp.WaterRightsOwner)
            {
                assetBp.WaterAvailable += waterToReturn;
                a.WaterAllocated       -= waterToReturn;
            }
            else
            {
                lock (p.WaterRightsOwned)
                {
                    int waterForEach = (int)Math.Ceiling(waterToReturn / (double)p.WaterRightsOwned.Count);
                    a.WaterAllocated -= waterToReturn;

                    foreach (BuyPoint bp in p.WaterRightsOwned.Values)
                    {
                        int water = Math.Min(waterForEach, waterToReturn);
                        bp.WaterAvailable += water;
                        waterToReturn     -= water;

                        if (waterToReturn <= 0)
                        {
                            break;
                        }
                    }
                }
            }

            a.TriggerChanged();
        }
예제 #5
0
        public override void SellGameAssetToEconomy(AbstractGameAsset ga)
        {
            if (!ga.CanBeSoldToEconomy)
            {
                throw new WaterWarsGameLogicException(
                          "{0} tried to sell asset {1} on {2} in {3} to the economy but it is not of the appropriate type",
                          ga.OwnerName, ga.Name, ga.Field.BuyPoint.Name, ga.Field.BuyPoint.Location.RegionName);
            }

            if (!ga.IsBuilt)
            {
                throw new WaterWarsGameLogicException(
                          "{0} tried to sell asset {1} on {2} in {3} to the economy but it is only partially built",
                          ga.OwnerName, ga.Name, ga.Field.BuyPoint.Name, ga.Field.BuyPoint.Location.RegionName);
            }

            Player   owner = ga.Field.Owner;
            BuyPoint bp    = ga.Field.BuyPoint;

            if (ga.WaterUsage > owner.WaterEntitlement)
            {
                throw new WaterWarsGameLogicException(
                          "Game asset {0} on parcel {1} in {2} cannot be sold to the market since this requires water rights of {3} whereas {4} has only {5} available",
                          ga.Name, bp.Name, bp.Location.RegionName, owner.Name, owner.WaterEntitlement);
            }

            m_log.InfoFormat(
                "[WATER WARS]: {0} selling {1} on {2} in {3} to economy", owner.Name, ga.Name, bp.Name, bp.Location.RegionName);

            int revenue = ga.MarketPrice;

            owner.Money += revenue;
            owner.BuildRevenueThisTurn += revenue;
            owner.WaterEntitlement     -= ga.WaterUsage;
            ga.IsSoldToEconomy          = true;
            ga.Field.Owner              = m_controller.Game.Economy;

            ga.TriggerChanged();
            bp.TriggerChanged();
            owner.TriggerChanged();

            m_controller.EventManager.TriggerGameAssetSoldToEconomy(ga, owner, revenue);
        }
예제 #6
0
        public override AbstractGameAsset ContinueBuildingGameAsset(AbstractGameAsset ga)
        {
            BuyPoint bp = ga.Field.BuyPoint;

            if (ga.IsBuilt)
            {
                throw new WaterWarsGameLogicException(
                          "{0} tried to continue building game asset {1} on {2} in {3} but this is already fully built",
                          bp.DevelopmentRightsOwner.Name, ga.Name, bp.Name, bp.Location.RegionName);
            }

            Player p = bp.DevelopmentRightsOwner;

            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 build the next phase of {2} in {3} at {4} costing {5}",
                          p, p.Money, ga.Name, bp.Name, bp.Location.RegionName, price);
            }

            p.Money -= price;
            p.BuildCostsThisTurn += price;
            ga.StepsBuilt++;
            ga.StepBuiltThisTurn = true;

            m_controller.EventManager.TriggerGameAssetBuildContinued(ga);
            if (ga.IsBuilt)
            {
                m_controller.EventManager.TriggerGameAssetBuildCompleted(ga);
            }

            ga.TriggerChanged();

            p.TriggerChanged();
            bp.TriggerChanged();

            UpdateHudStatus(p);

            return(ga);
        }
예제 #7
0
        public override void UseWater(AbstractGameAsset a, Player p, int amount)
        {
            BuyPoint bp = a.Field.BuyPoint;

            if (bp.DevelopmentRightsOwner != p)
            {
                throw new WaterWarsGameLogicException(
                          "{0} tried to allocate water on asset {1} but development rights are owned by {2}",
                          p, a, bp.DevelopmentRightsOwner);
            }

            if (!a.CanBeAllocatedWater)
            {
                throw new WaterWarsGameLogicException(
                          "{0} tried to allocate water on asset {1} but this asset type does not allow water allocation",
                          p.Name, a.Name);
            }

            if (!a.IsBuilt)
            {
                throw new WaterWarsGameLogicException(
                          "{0} tried to allocate water on asset {1} but it is only partially built",
                          p.Name, a.Name);
            }

            m_log.InfoFormat(
                "[WATER WARS]: {0} using {1} on {2} at {3} in {4}",
                p.Name, WaterWarsUtils.GetWaterUnitsText(amount), a.Name, bp.Name, bp.Location.RegionName);

            m_controller.WaterAllocator.ChangeAllocation(a, p, amount);
            m_controller.EventManager.TriggerWaterUsed(a, p, amount);
            a.TriggerChanged();
            bp.TriggerChanged();
            p.TriggerChanged();

            UpdateHudStatus(p);
        }