コード例 #1
0
        public ActionResult CounterProposal(int id)
        {
            var db     = new ZkDataContext();
            var treaty = db.FactionTreaties.Single(x => x.FactionTreatyID == id);
            var acc    = db.Accounts.Single(x => x.AccountID == Global.AccountID);

            if (treaty.CanCancel(acc) && treaty.TreatyState == TreatyState.Proposed)
            {
                if (treaty.AcceptingFactionGuarantee == acc.FactionID)
                {
                    var pom = treaty.AcceptingFactionGuarantee;
                    treaty.AcceptingFactionGuarantee = treaty.ProposingFactionGuarantee;
                    treaty.ProposingFactionGuarantee = pom;
                }

                treaty.FactionByAcceptingFactionID = treaty.AcceptingFactionID == acc.FactionID
                                                         ? treaty.FactionByProposingFactionID
                                                         : treaty.FactionByAcceptingFactionID;
                treaty.AccountByProposingAccountID = acc;
                treaty.FactionByProposingFactionID = acc.Faction;
                treaty.TreatyState = TreatyState.Invalid;


                db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("{0} modified treaty proposal {1} between {2} and {3}", acc, treaty, treaty.FactionByProposingFactionID, treaty.FactionByAcceptingFactionID));
                db.SaveChanges();



                return(View("FactionTreatyDefinition", db.FactionTreaties.Find(treaty.FactionTreatyID)));
            }
            return(Content("Not permitted"));
        }
コード例 #2
0
        public ActionResult JoinFaction(int id)
        {
            if (Global.Account.FactionID != null)
            {
                return(Content("Already in faction"));
            }
            if (Global.Account.Clan != null && Global.Account.Clan.FactionID != id)
            {
                return(Content("Must leave current clan first"));
            }
            var     db  = new ZkDataContext();
            Account acc = db.Accounts.Single(x => x.AccountID == Global.AccountID);

            acc.FactionID = id;

            Faction faction = db.Factions.Single(x => x.FactionID == id);

            if (faction.IsDeleted && !(Global.Account.Clan != null && Global.Account.Clan.FactionID == id))
            {
                throw new ApplicationException("Cannot join deleted faction");
            }
            db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("{0} joins {1}", acc, faction));
            db.SaveChanges();
            Global.Server.PublishAccountUpdate(acc);
            return(RedirectToAction("Index", "Factions"));
        }
コード例 #3
0
        public ActionResult RushActivation(int planetID, int structureTypeID)
        {
            using (var db = new ZkDataContext())
            {
                var planet    = db.Planets.Single(p => p.PlanetID == planetID);
                var acc       = db.Accounts.Single(x => x.AccountID == Global.AccountID);
                var structure = planet.PlanetStructures.Single(x => x.StructureTypeID == structureTypeID);
                if (structure.RushStructure(acc))
                {
                    db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("{0} has rushed activation of {1} on {2} planet {3}.",
                                                                                acc,
                                                                                structure.StructureType,
                                                                                planet.Faction,
                                                                                planet));
                }
                else
                {
                    return(Content("You cannot rush this"));
                }

                db.SaveChanges();

                return(RedirectToAction("Planet", new { id = planetID }));
            }
        }
コード例 #4
0
        public ActionResult SetStructureTarget(int planetID, int structureTypeID, int targetPlanetID)
        {
            var db        = new ZkDataContext();
            var acc       = db.Accounts.Single(x => x.AccountID == Global.AccountID);
            var planet    = db.Planets.Single(x => x.PlanetID == planetID);
            var structure = planet.PlanetStructures.Single(x => x.StructureTypeID == structureTypeID);

            if (!acc.CanSetStructureTarget(structure))
            {
                return(Content("Cannot set target"));
            }
            var target = db.Planets.Single(x => x.PlanetID == targetPlanetID);

            if (target != structure.PlanetByTargetPlanetID)
            {
                structure.ReactivateAfterBuild();
            }


            structure.PlanetByTargetPlanetID = target;
            db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("{0} of {1} aimed {2} located at {3} to {4} planet {5}", acc, acc.Faction, structure.StructureType, planet, target.Faction, target));

            if (structure.IsActive && !structure.StructureType.IsSingleUse)
            {
                return(ActivateTargetedStructure(planetID, structureTypeID));
            }

            db.SaveChanges();
            return(RedirectToAction("Planet", new { id = planet.PlanetID }));
        }
コード例 #5
0
 public ActionResult SubmitRenamePlanet(int planetID, string newName, int teamSize, string map)
 {
     using (var scope = new TransactionScope())
     {
         if (String.IsNullOrWhiteSpace(newName))
         {
             return(Content("Error: the planet must have a name."));
         }
         var    db     = new ZkDataContext();
         var    acc    = db.Accounts.Find(Global.AccountID);
         Planet planet = db.Planets.Single(p => p.PlanetID == planetID);
         if (planet.Name != newName)
         {
             db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("{0} renamed planet {1} to {2}", acc, planet, newName));
         }
         db.SaveChanges();
         planet.Name           = newName;
         planet.TeamSize       = teamSize;
         planet.Resource       = db.Resources.Where(x => x.TypeID == ResourceType.Map && x.InternalName == map).First();
         planet.Galaxy.IsDirty = true;
         db.SaveChanges();
         scope.Complete();
         return(RedirectToAction("Planet", new { id = planet.PlanetID }));
     }
 }
コード例 #6
0
        /// <summary>
        /// Clan leaving logic (including after kick)
        /// </summary>
        public static Clan PerformLeaveClan(int accountID, ZkDataContext db = null)
        {
            if (db == null)
            {
                db = new ZkDataContext();
            }
            var acc  = db.Accounts.Single(x => x.AccountID == accountID);
            var clan = acc.Clan;

            if (clan == null)
            {
                return(null);              // Person not in a clan
            }
            RoleType leader   = db.RoleTypes.FirstOrDefault(x => x.RightKickPeople && x.IsClanOnly);
            bool     isLeader = acc.AccountRolesByAccountID.Any(x => x.RoleType == leader);

            // remove role
            db.AccountRoles.DeleteAllOnSubmit(acc.AccountRolesByAccountID.Where(x => x.RoleType.IsClanOnly).ToList());

            // delete active polls
            db.Polls.DeleteAllOnSubmit(acc.PollsByRoleTargetAccountID.Where(x => x.RoleType.IsClanOnly));

            // remove planets
            acc.Planets.Clear();

            acc.ResetQuotas();

            // delete channel subscription
            //if (!acc.IsZeroKAdmin || acc.IsZeroKAdmin)
            //{
            //    var channelSub = db.LobbyChannelSubscriptions.FirstOrDefault(x => x.Account == acc && x.Channel == acc.Clan.GetClanChannel());
            //    db.LobbyChannelSubscriptions.DeleteOnSubmit(channelSub);
            //}

            acc.Clan = null;
            db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("{0} leaves clan {1}", acc, clan));
            db.SaveChanges();
            if (!clan.Accounts.Any())
            {
                clan.IsDeleted = true;
                db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("{0} is disbanded", clan));
            }
            else if (isLeader)
            {
                var otherClanMember = clan.Accounts.FirstOrDefault(x => x.AccountID != accountID);
                if (otherClanMember != null)
                {
                    db.AccountRoles.InsertOnSubmit(new AccountRole()
                    {
                        AccountID = otherClanMember.AccountID, Clan = clan, RoleType = leader, Inauguration = DateTime.UtcNow
                    });
                }
            }

            db.SaveChanges();
            Global.Server.PublishAccountUpdate(acc);
            return(clan);
        }
コード例 #7
0
        public ActionResult DestroyStructure(int planetID, int structureTypeID)
        {
            using (var db = new ZkDataContext())
            {
                Planet planet = db.Planets.Single(p => p.PlanetID == planetID);
                if (Global.Server.GetPlanetBattles(planet).Any(x => x.IsInGame))
                {
                    return(Content("Battle in progress on the planet, cannot destroy structures"));
                }
                Account       acc           = db.Accounts.Single(x => x.AccountID == Global.AccountID);
                StructureType structureType = db.StructureTypes.SingleOrDefault(s => s.StructureTypeID == structureTypeID);
                Faction       faction       = planet.Faction;
                if (structureType == null)
                {
                    return(Content("Structure type does not exist."));
                }
                if (!structureType.IsBuildable)
                {
                    return(Content("Structure is not buildable."));
                }

                // assumes you can only build level 1 structures! if higher level structures can be built directly, we should check down the upgrade chain too

                if (!planet.PlanetStructures.Any(x => x.StructureTypeID == structureTypeID))
                {
                    return(Content("Structure or its upgrades not present"));
                }

                List <PlanetStructure> list      = planet.PlanetStructures.Where(x => x.StructureTypeID == structureTypeID).ToList();
                PlanetStructure        toDestroy = list[0];
                if (!toDestroy.IsActive)
                {
                    return(Content("Structure is currently disabled"));
                }
                var canDestroy = toDestroy.OwnerAccountID == acc.AccountID || planet.OwnerAccountID == acc.AccountID;
                if (!canDestroy)
                {
                    return(Content("Structure is not under your control."));
                }
                var refund = toDestroy.StructureType.Cost * GlobalConst.SelfDestructRefund;
                if (toDestroy.Account != null)
                {
                    toDestroy.Account.ProduceMetal(refund);
                }
                else
                {
                    faction?.ProduceMetal(refund);
                }
                db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("{0} has demolished a {1} on {2}.", acc, toDestroy.StructureType, planet));
                db.PlanetStructures.DeleteOnSubmit(toDestroy);
                db.SaveChanges();
                PlanetWarsTurnHandler.SetPlanetOwners(new PlanetwarsEventCreator(), db);
            }

            return(RedirectToAction("Planet", new { id = planetID }));
        }
コード例 #8
0
        public ActionResult AppointRole(int accountID, int roletypeID)
        {
            var      db            = new ZkDataContext();
            Account  targetAccount = db.Accounts.Single(x => x.AccountID == accountID);
            Account  myAccount     = db.Accounts.Single(x => x.AccountID == Global.AccountID);
            RoleType role          = db.RoleTypes.Single(x => x.RoleTypeID == roletypeID);

            if (myAccount.CanAppoint(targetAccount, role))
            {
                Account previous = null;
                if (role.IsOnePersonOnly)
                {
                    List <AccountRole> entries =
                        db.AccountRoles.Where(
                            x => x.RoleTypeID == role.RoleTypeID && (role.IsClanOnly ? x.ClanID == myAccount.ClanID : x.FactionID == myAccount.FactionID)).ToList();
                    if (entries.Any())
                    {
                        previous = entries.First().Account;
                        db.AccountRoles.DeleteAllOnSubmit(entries);
                    }
                }
                var entry = new AccountRole
                {
                    AccountID    = accountID,
                    Inauguration = DateTime.UtcNow,
                    Clan         = role.IsClanOnly ? myAccount.Clan : null,
                    Faction      = !role.IsClanOnly ? myAccount.Faction : null,
                    RoleTypeID   = roletypeID,
                };
                db.AccountRoles.InsertOnSubmit(entry);
                if (previous != null)
                {
                    db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("{0} was appointed to the {1} role of {2} by {3} - replacing {4}",
                                                                                targetAccount,
                                                                                role.IsClanOnly ? (object)myAccount.Clan : myAccount.Faction,
                                                                                role,
                                                                                myAccount,
                                                                                previous));
                }
                else
                {
                    db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("{0} was appointed to the {1} role of {2} by {3}",
                                                                                targetAccount,
                                                                                role.IsClanOnly ? (object)myAccount.Clan : myAccount.Faction,
                                                                                role,
                                                                                myAccount));
                }
                Global.Server.GhostPm(targetAccount.Name, string.Format("You were appointed for the function of {0} by {1}", role.Name, myAccount.Name));
                db.SaveChanges();
                return(RedirectToAction("Detail", "Users", new { id = accountID }));
            }
            else
            {
                return(Content("Cannot recall"));
            }
        }
コード例 #9
0
        public ActionResult BuildStructure(int planetID, int structureTypeID)
        {
            using (var db = new ZkDataContext())
            {
                Planet planet = db.Planets.Single(p => p.PlanetID == planetID);
                if (Global.Server.GetPlanetBattles(planet).Any(x => x.IsInGame))
                {
                    return(Content("Battle in progress on the planet, cannot build structures"));
                }
                Account acc = db.Accounts.Single(x => x.AccountID == Global.AccountID);
                if (acc.FactionID != planet.OwnerFactionID)
                {
                    return(Content("Planet is not under your control."));
                }

                StructureType structureType = db.StructureTypes.SingleOrDefault(s => s.StructureTypeID == structureTypeID);
                if (structureType == null)
                {
                    return(Content("Structure type does not exist."));
                }
                if (!structureType.IsBuildable)
                {
                    return(Content("Structure is not buildable."));
                }

                if (acc.GetMetalAvailable() < structureType.Cost)
                {
                    return(Content("Insufficient metal"));
                }
                acc.SpendMetal(structureType.Cost);

                var newBuilding = new PlanetStructure
                {
                    StructureTypeID = structureTypeID,
                    StructureType   = structureType,
                    PlanetID        = planetID,
                    OwnerAccountID  = acc.AccountID,
                };
                newBuilding.ReactivateAfterBuild();

                db.PlanetStructures.InsertOnSubmit(newBuilding);
                db.SaveChanges();

                db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("{0} has built a {1} on {2} planet {3}.",
                                                                            acc,
                                                                            newBuilding.StructureType,
                                                                            planet.Faction,
                                                                            planet));
                PlanetWarsTurnHandler.SetPlanetOwners(new PlanetwarsEventCreator(), db);
            }
            return(RedirectToAction("Planet", new { id = planetID }));
        }
コード例 #10
0
        private ActionResult FirePlanetBuster(int planetID, int structureTypeID, int targetID)
        {
            var             db        = new ZkDataContext();
            PlanetStructure structure = db.PlanetStructures.FirstOrDefault(x => x.PlanetID == planetID && x.StructureTypeID == structureTypeID);
            Planet          source    = db.Planets.FirstOrDefault(x => x.PlanetID == planetID);
            Planet          target    = db.Planets.FirstOrDefault(x => x.PlanetID == targetID);

            Account acc = db.Accounts.Single(x => x.AccountID == Global.AccountID);

            if (acc.Faction == null)
            {
                return(Content("Join some faction first"));
            }
            if (!target.CanFirePlanetBuster(acc.Faction))
            {
                return(Content("You cannot attack here"));
            }

            //Get rid of all strutures
            var structures = target.PlanetStructures.Where(x => x.StructureType.EffectIsVictoryPlanet != true && x.StructureType.OwnerChangeWinsGame != true).ToList();


            //kill all IP
            foreach (var pf in target.PlanetFactions.Where(x => x.Influence > 0))
            {
                pf.Influence = 0;
            }
            var links = db.Links.Where(x => (x.PlanetID1 == target.PlanetID || x.PlanetID2 == target.PlanetID));

            foreach (Link link in links)
            {
                db.Links.DeleteOnSubmit(link);
            }

            db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("A {4} fired from {0} {1} has destroyed {2} {3}!", source.Faction, source, target.Faction, target, structure.StructureType));
            db.SaveChanges();

            db.PlanetStructures.DeleteAllOnSubmit(structures);
            var residue = db.StructureTypes.First(x => x.Name == "Residue"); // todo not nice use constant instead

            target.PlanetStructures.Add(new PlanetStructure()
            {
                StructureType = residue, IsActive = true, ActivatedOnTurn = null
            });
            db.SaveChanges();

            return(null);
        }
コード例 #11
0
        public ActionResult CancelTreaty(int id)
        {
            var db     = new ZkDataContext();
            var treaty = db.FactionTreaties.Single(x => x.FactionTreatyID == id);
            var acc    = db.Accounts.Single(x => x.AccountID == Global.AccountID);

            if (treaty.CanCancel(acc))
            {
                treaty.TreatyState = TreatyState.Invalid;
                db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("Treaty {0} between {1} and {2} cancelled by {3}", treaty, treaty.FactionByProposingFactionID, treaty.FactionByAcceptingFactionID, acc));
                db.SaveChanges();

                return(RedirectToAction("Detail", new { id = Global.FactionID }));
            }
            return(Content("Cannot cancel"));
        }
コード例 #12
0
        public ActionResult SetEnergyPriority(int planetID, int structuretypeID, EnergyPriority priority)
        {
            var db        = new ZkDataContext();
            var acc       = db.Accounts.Single(x => x.AccountID == Global.AccountID);
            var planet    = db.Planets.Single(x => x.PlanetID == planetID);
            var structure = planet.PlanetStructures.Single(x => x.StructureTypeID == structuretypeID);

            if (!acc.CanSetPriority(structure))
            {
                return(Content("Cannot set priority"));
            }
            structure.EnergyPriority = priority;
            db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("{0} changed energy priority of {1} on {2} to {3}", acc, structure.StructureType, planet, priority));
            db.SaveChanges();
            return(RedirectToAction("Planet", new { id = planet.PlanetID }));
        }
コード例 #13
0
        // GET: PlanetwarsAdmin
        public ActionResult Index(PlanetwarsAdminModel model, string set, string purge, string futureset)
        {
            var db = new ZkDataContext();

            if (model != null)
            {
                if (!string.IsNullOrEmpty(set))
                {
                    MiscVar.PlanetWarsMode = model.PlanetWarsMode;
                    db.Events.Add(PlanetwarsEventCreator.CreateEvent("{0} changed PlanetWars status to {1}",
                                                                     db.Accounts.Find(Global.AccountID),
                                                                     model.PlanetWarsMode.Description()));

                    db.SaveChanges();
                }

                if (!string.IsNullOrEmpty(purge))
                {
                    PurgeGalaxy(model.LastSelectedGalaxyID, model.UnassignFactions, model.ResetRoles, model.DeleteClans);
                }

                if (!string.IsNullOrEmpty(futureset))
                {
                    if (model.PlanetWarsNextMode == MiscVar.PlanetWarsMode || model.PlanetWarsNextModeDate == null ||
                        model.PlanetWarsNextModeDate < DateTime.UtcNow || model.PlanetWarsNextMode == null)
                    {
                        model.PlanetWarsNextMode     = null;
                        model.PlanetWarsNextModeDate = null;
                    }

                    MiscVar.PlanetWarsNextMode     = model.PlanetWarsNextMode;
                    MiscVar.PlanetWarsNextModeTime = model.PlanetWarsNextModeDate;
                }
            }

            model = model ?? new PlanetwarsAdminModel();

            model.PlanetWarsMode         = MiscVar.PlanetWarsMode;
            model.PlanetWarsNextMode     = MiscVar.PlanetWarsNextMode;
            model.PlanetWarsNextModeDate = MiscVar.PlanetWarsNextModeTime;

            model.Galaxies             = db.Galaxies.OrderByDescending(x => x.IsDefault).ThenByDescending(x => x.GalaxyID);
            model.LastSelectedGalaxyID = model.Galaxies.FirstOrDefault(x => x.IsDefault)?.GalaxyID ?? 0;


            return(View("PlanetwarsAdminIndex", model));
        }
コード例 #14
0
        public static Faction PerformLeaveFaction(int accountID, bool keepClan = false, ZkDataContext db = null)
        {
            if (db == null)
            {
                db = new ZkDataContext();
            }
            Account acc     = db.Accounts.Single(x => x.AccountID == Global.AccountID);
            Faction faction = acc.Faction;

            if (!keepClan && acc.Clan != null)
            {
                ClansController.PerformLeaveClan(Global.AccountID);
            }
            db.AccountRoles.DeleteAllOnSubmit(acc.AccountRolesByAccountID.Where(x => !keepClan || x.ClanID == null).ToList());
            acc.ResetQuotas();

            foreach (var ps in acc.PlanetStructures)
            {
                ps.OwnerAccountID = null;
            }

            foreach (var planet in acc.Planets)
            {
                planet.OwnerAccountID = null;
            }


            db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("{0} leaves faction {1}", acc, acc.Faction));
            db.SaveChanges();
            PlanetWarsTurnHandler.SetPlanetOwners(new PlanetwarsEventCreator(), db);


            using (var db2 = new ZkDataContext())
            {
                Account acc2 = db2.Accounts.Single(x => x.AccountID == Global.AccountID);
                acc2.FactionID = null;
                db2.SaveChanges();

                Global.Server.PublishAccountUpdate(acc2);
                Global.Server.PublishUserProfileUpdate(acc2);
                PlanetWarsTurnHandler.SetPlanetOwners(new PlanetwarsEventCreator(), db2);
            }
            return(faction);
        }
コード例 #15
0
        public ActionResult ConfiscateStructure(int planetID, int structureTypeID)
        {
            using (var db = new ZkDataContext())
            {
                Planet planet = db.Planets.Single(p => p.PlanetID == planetID);
                //if (Global.Nightwatch.GetPlanetBattles(planet).Any(x => x.IsInGame)) return Content("Battle in progress on the planet, cannot destroy structures");
                Account acc           = db.Accounts.Single(x => x.AccountID == Global.AccountID);
                bool    factionLeader = acc.HasFactionRight(x => x.RightMetalQuota > 0) && (acc.Faction == planet.Faction);
                if ((planet.OwnerAccountID != acc.AccountID) && !factionLeader)
                {
                    return(Content("Planet not yours"));
                }
                StructureType structureType = db.StructureTypes.SingleOrDefault(s => s.StructureTypeID == structureTypeID);
                if (structureType == null)
                {
                    return(Content("Structure type does not exist."));
                }
                //if (!structureType.IsBuildable) return Content("Structure is not buildable.");

                if (!planet.PlanetStructures.Any(x => x.StructureTypeID == structureTypeID))
                {
                    return(Content("Structure or its upgrades not present"));
                }
                List <PlanetStructure> list      = planet.PlanetStructures.Where(x => x.StructureTypeID == structureTypeID).ToList();
                PlanetStructure        structure = list[0];
                Account orgAc = structure.Account;
                double  cost  = (!factionLeader) ? structure.StructureType.Cost : 0;
                if (orgAc != null)
                {
                    structure.Account.SpendMetal(-cost);
                    acc.SpendMetal(cost);
                }
                structure.Account = acc;
                db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("{0} has confiscated {1} structure {2} on {3}.",
                                                                            acc,
                                                                            orgAc,
                                                                            structure.StructureType,
                                                                            planet));
                db.SaveChanges();

                return(RedirectToAction("Planet", new { id = planetID }));
            }
        }
コード例 #16
0
        public ActionResult RecallRole(int accountID, int roletypeID)
        {
            var      db            = new ZkDataContext();
            Account  targetAccount = db.Accounts.Single(x => x.AccountID == accountID);
            Account  myAccount     = db.Accounts.Single(x => x.AccountID == Global.AccountID);
            RoleType role          = db.RoleTypes.Single(x => x.RoleTypeID == roletypeID);

            if (myAccount.CanRecall(targetAccount, role))
            {
                db.AccountRoles.DeleteAllOnSubmit(db.AccountRoles.Where(x => x.AccountID == accountID && x.RoleTypeID == roletypeID));
                db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("{0} was recalled from the {1} role of {2} by {3}",
                                                                            targetAccount,
                                                                            role.IsClanOnly ? (object)myAccount.Clan : myAccount.Faction,
                                                                            role,
                                                                            myAccount));
                Global.Server.GhostPm(targetAccount.Name, string.Format("You were recalled from the function of {0} by {1}", role.Name, myAccount.Name));
                db.SaveChanges();
                return(RedirectToAction("Detail", "Users", new { id = accountID }));
            }
            else
            {
                return(Content("Cannot recall"));
            }
        }
コード例 #17
0
        public ActionResult JoinClan(int id, string password)
        {
            var db   = new ZkDataContext();
            var clan = db.Clans.Single(x => x.ClanID == id);


            if (clan.CanJoin(Global.Account))
            {
                if (!string.IsNullOrEmpty(clan.Password) && clan.Password != password)
                {
                    return(View(clan.ClanID));
                }
                else
                {
                    var acc = db.Accounts.Single(x => x.AccountID == Global.AccountID);
                    acc.ClanID    = clan.ClanID;
                    acc.FactionID = clan.FactionID;
                    db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("{0} joins clan {1}", acc, clan));

                    if (clan.IsDeleted) // recreate clan
                    {
                        AddClanLeader(acc.AccountID, clan.ClanID, db);
                        clan.IsDeleted = false;
                        db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("Clan {0} reformed by {1}", clan, acc));
                    }

                    db.SaveChanges();
                    Global.Server.PublishAccountUpdate(acc);
                    return(RedirectToAction("Detail", new { id = clan.ClanID }));
                }
            }
            else
            {
                return(Content("You cannot join this clan - its full, or has password, or is different faction"));
            }
        }
コード例 #18
0
        public ActionResult AcceptTreaty(int id)
        {
            var db     = new ZkDataContext();
            var treaty = db.FactionTreaties.Single(x => x.FactionTreatyID == id);
            var acc    = db.Accounts.Single(x => x.AccountID == Global.AccountID);

            if (!treaty.CanAccept(acc))
            {
                return(Content("You do not have rights to accept treaties"));
            }

            // note: we don't actually need to make sure trade can be executed before storing guarantee,
            // because if either fails we just don't save the changes to database

            var isOneTimeOnly = treaty.TreatyEffects.All(x => x.TreatyEffectType.IsOneTimeOnly);

            if (treaty.ProcessTrade(true) == null && (isOneTimeOnly || treaty.StoreGuarantee()))
            {
                treaty.AcceptedAccountID = acc.AccountID;
                treaty.TreatyState       = TreatyState.Accepted;
                db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("Treaty {0} between {1} and {2} accepted by {3}", treaty, treaty.FactionByProposingFactionID, treaty.FactionByAcceptingFactionID, acc));

                PlanetWarsTurnHandler.SetPlanetOwners(new PlanetwarsEventCreator(), db);

                db.SaveChanges();

                if (isOneTimeOnly)
                {
                    treaty.TreatyState = TreatyState.Invalid;
                    db.SaveChanges();
                }

                return(RedirectToAction("Detail", new { id = Global.FactionID }));
            }
            return(Content("One or both parties are unable to meet treaty conditions"));
        }
コード例 #19
0
        public ActionResult CreateLink(int planetID, int structureTypeID, int targetID)
        {
            var db = new ZkDataContext();

            PlanetStructure structure = db.PlanetStructures.FirstOrDefault(x => x.PlanetID == planetID && x.StructureTypeID == structureTypeID);
            Planet          source    = db.Planets.FirstOrDefault(x => x.PlanetID == planetID);
            Planet          target    = db.Planets.FirstOrDefault(x => x.PlanetID == targetID);

            // warp jammers protect against link creation
            //var warpDefense = target.PlanetStructures.Where(x => x.StructureType.EffectBlocksJumpgate == true).ToList();
            //if (warpDefense.Count > 0) return Content("Warp jamming prevents link creation");

            if (source.GalaxyID != target.GalaxyID)
            {
                return(Content("Cannot form exo-galaxy link"));
            }

            db.Links.InsertOnSubmit(new Link {
                PlanetID1 = source.PlanetID, PlanetID2 = target.PlanetID, GalaxyID = source.GalaxyID
            });
            db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("A new link was created between {0} planet {1} and {2} planet {3} by the {4}", source.Faction, source, target.Faction, target, structure.StructureType));
            db.SaveChanges();
            return(null);
        }
コード例 #20
0
        /// <summary>
        /// Create or modify a PlanetWars <see cref="FactionTreaty"/>
        /// </summary>
        /// <param name="factionTreatyID">Existing <see cref="FactionTreaty"/> ID, if modifying one</param>
        /// <param name="turns">How long the treaty lasts</param>
        /// <param name="acceptingFactionID"></param>
        /// <param name="effectTypeID"><see cref="TreatyEffect"/> to add or remove, if applicable</param>
        /// <param name="effectValue"></param>
        /// <param name="planetID">Specifies the <see cref="Planet"/> for planet-based effects</param>
        /// <param name="isReverse"></param>
        /// <param name="note">Diplomatic note readable by both parties, to better communicate their intentions</param>
        /// <param name="add">If not null or empty, add the specified <see cref="TreatyEffect"/></param>
        /// <param name="delete">Delete the specified <see cref="TreatyEffect"/>?</param>
        /// <param name="propose">If not null or empty, this is a newly proposed treaty</param>
        /// <returns></returns>
        public ActionResult ModifyTreaty(int factionTreatyID,
                                         int?turns,
                                         int?acceptingFactionID,
                                         int?effectTypeID,
                                         double?effectValue,
                                         int?planetID,
                                         bool?isReverse,
                                         string note,
                                         string add, int?delete, string propose)
        {
            if (!Global.Account.HasFactionRight(x => x.RightDiplomacy))
            {
                return(Content("Not a diplomat!"));
            }

            FactionTreaty treaty;

            // submit, store treaty in db
            var db = new ZkDataContext();

            if (factionTreatyID > 0)
            {
                treaty = db.FactionTreaties.Single(x => x.FactionTreatyID == factionTreatyID);
                if (treaty.TreatyState != TreatyState.Invalid)
                {
                    return(Content("Treaty already in progress!"));
                }
            }
            else
            {
                treaty = new FactionTreaty();
                db.FactionTreaties.InsertOnSubmit(treaty);
                treaty.FactionByAcceptingFactionID = db.Factions.Single(x => x.FactionID == acceptingFactionID);
            }
            treaty.AccountByProposingAccountID = db.Accounts.Find(Global.AccountID);
            treaty.FactionByProposingFactionID = db.Factions.Single(x => x.FactionID == Global.FactionID);
            treaty.TurnsRemaining = turns;
            treaty.TurnsTotal     = turns;
            treaty.TreatyNote     = note;


            if (!string.IsNullOrEmpty(add))
            {
                TreatyEffectType effectType = db.TreatyEffectTypes.Single(x => x.EffectTypeID == effectTypeID);
                var effect = new TreatyEffect
                {
                    FactionByGivingFactionID    = isReverse == true ? treaty.FactionByAcceptingFactionID : treaty.FactionByProposingFactionID,
                    FactionByReceivingFactionID =
                        isReverse == true ? treaty.FactionByProposingFactionID : treaty.FactionByAcceptingFactionID,
                    TreatyEffectType = effectType,
                    FactionTreaty    = treaty
                };
                if (effectType.HasValue)
                {
                    if (effectType.MinValue.HasValue && effectValue < effectType.MinValue.Value)
                    {
                        effectValue = effectType.MinValue;
                    }
                    if (effectType.MaxValue.HasValue && effectValue > effectType.MaxValue.Value)
                    {
                        effectValue = effectType.MaxValue;
                    }
                }
                if (effectType.HasValue)
                {
                    effect.Value = effectValue;
                }
                if (effectType.IsPlanetBased)
                {
                    effect.PlanetID = planetID.Value;
                }
                db.TreatyEffects.InsertOnSubmit(effect);
            }
            if (delete != null)
            {
                db.TreatyEffects.DeleteOnSubmit(db.TreatyEffects.Single(x => x.TreatyEffectID == delete));
            }
            db.SaveChanges();

            if (!string.IsNullOrEmpty(propose))
            {
                treaty.TreatyState = TreatyState.Proposed;

                db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("{0} proposes a new treaty between {1} and {2} - {3}", treaty.AccountByProposingAccountID, treaty.FactionByProposingFactionID, treaty.FactionByAcceptingFactionID, treaty));

                db.SaveChanges();
                return(RedirectToAction("Detail", new { id = treaty.ProposingFactionID }));
            }


            return(View("FactionTreatyDefinition", db.FactionTreaties.Find(treaty.FactionTreatyID)));
        }
コード例 #21
0
        public ActionResult SubmitCreate(Clan clan, HttpPostedFileBase image, HttpPostedFileBase bgimage, bool noFaction = false)
        {
            //using (var scope = new TransactionScope())
            //{
            ZkDataContext db      = new ZkDataContext();
            bool          created = clan.ClanID == 0; // existing clan vs creation
            var           acc     = db.Accounts.Single(x => x.AccountID == Global.AccountID);

            //return Content(noFaction ? "true":"false");
            if (noFaction)
            {
                clan.FactionID = null;
            }

            Faction new_faction = db.Factions.SingleOrDefault(x => x.FactionID == clan.FactionID);

            if ((new_faction != null) && new_faction.IsDeleted)
            {
                return(Content("Cannot create clans in deleted factions"));
            }

            if (string.IsNullOrEmpty(clan.ClanName) || string.IsNullOrEmpty(clan.Shortcut))
            {
                return(Content("Name and shortcut cannot be empty!"));
            }
            if (!ZkData.Clan.IsShortcutValid(clan.Shortcut))
            {
                return(Content("Shortcut must have at least 1 characters and contain only numbers and letters"));
            }

            if (created && (image == null || image.ContentLength == 0))
            {
                return(Content("A clan image is required"));
            }

            Clan orgClan = null;

            if (!created)
            {
                if (!Global.IsModerator && (!Global.Account.HasClanRight(x => x.RightEditTexts) || clan.ClanID != Global.Account.ClanID))
                {
                    return(Content("Unauthorized"));
                }

                // check if our name or shortcut conflicts with existing clans
                var existingClans = db.Clans.Where(x => ((SqlFunctions.PatIndex(clan.Shortcut, x.Shortcut) > 0 || SqlFunctions.PatIndex(clan.ClanName, x.ClanName) > 0) && x.ClanID != clan.ClanID));
                if (existingClans.Count() > 0)
                {
                    if (existingClans.Any(x => !x.IsDeleted))
                    {
                        return(Content("Clan with this shortcut or name already exists"));
                    }
                }

                orgClan = db.Clans.Single(x => x.ClanID == clan.ClanID);
                string orgImageUrl   = Server.MapPath(orgClan.GetImageUrl());
                string orgBGImageUrl = Server.MapPath(orgClan.GetBGImageUrl());
                string orgShortcut   = orgClan.Shortcut;
                string newImageUrl   = Server.MapPath(clan.GetImageUrl());
                string newBGImageUrl = Server.MapPath(clan.GetBGImageUrl());

                if (Global.IsModerator && (!Global.Account.HasClanRight(x => x.RightEditTexts) || clan.ClanID != Global.Account.ClanID))
                {
                    Global.Server.GhostChanSay(GlobalConst.ModeratorChannel, string.Format("{0} edited clan {1} {2}", Global.Account.Name, orgClan.ClanName, Url.Action("Detail", "Clans", new { id = clan.ClanID }, "http")));
                    if (orgClan.ClanName != clan.ClanName)
                    {
                        Global.Server.GhostChanSay(GlobalConst.ModeratorChannel, string.Format("{0} => {1}", orgClan.ClanName, clan.ClanName));
                    }
                }

                orgClan.ClanName    = clan.ClanName;
                orgClan.Shortcut    = clan.Shortcut;
                orgClan.Description = clan.Description;
                orgClan.SecretTopic = clan.SecretTopic;
                orgClan.Password    = clan.Password;
                bool shortcutChanged = orgShortcut != clan.Shortcut;

                if (image != null && image.ContentLength > 0)
                {
                    var im = Image.FromStream(image.InputStream);
                    if (im.Width != 64 || im.Height != 64)
                    {
                        im = im.GetResized(64, 64, InterpolationMode.HighQualityBicubic);
                    }
                    im.Save(newImageUrl);
                }
                else if (shortcutChanged)
                {
                    //if (System.IO.File.Exists(newImageUrl)) System.IO.File.Delete(newImageUrl);
                    //System.IO.File.Move(orgImageUrl, newImageUrl);
                    try {
                        //var im = Image.FromFile(orgImageUrl);
                        //im.Save(newImageUrl);
                        System.IO.File.Copy(orgImageUrl, newImageUrl, true);
                    } catch (System.IO.FileNotFoundException fnfex) // shouldn't happen but hey
                    {
                        return(Content("A clan image is required"));
                    }
                }

                if (bgimage != null && bgimage.ContentLength > 0)
                {
                    var im = Image.FromStream(bgimage.InputStream);
                    im.Save(newBGImageUrl);
                }
                else if (shortcutChanged)
                {
                    //if (System.IO.File.Exists(newBGImageUrl)) System.IO.File.Delete(newBGImageUrl);
                    //System.IO.File.Move(orgBGImageUrl, newBGImageUrl);
                    try
                    {
                        //var im = Image.FromFile(orgBGImageUrl);
                        //im.Save(newBGImageUrl);
                        System.IO.File.Copy(orgBGImageUrl, newBGImageUrl, true);
                    }
                    catch (System.IO.FileNotFoundException fnfex)
                    {
                        // there wasn't an original background image, do nothing
                    }
                }

                if (clan.FactionID != orgClan.FactionID)
                {
                    // set factions of members
                    Faction oldFaction = orgClan.Faction;
                    orgClan.FactionID = clan.FactionID;
                    foreach (Account member in orgClan.Accounts)
                    {
                        if (member.FactionID != clan.FactionID && member.FactionID != null)
                        {
                            FactionsController.PerformLeaveFaction(member.AccountID, true, db);
                        }
                        member.FactionID = clan.FactionID;
                    }
                    db.SaveChanges();
                    if (clan.FactionID != null)
                    {
                        db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("Clan {0} moved to faction {1}", orgClan, orgClan.Faction));
                    }
                    else
                    {
                        db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("Clan {0} left faction {1}", orgClan, oldFaction));
                    }
                }
                db.SaveChanges();
            }
            else
            {
                if (Global.Clan != null)
                {
                    return(Content("You already have a clan"));
                }
                // should just change their faction for them?
                if (Global.FactionID != 0 && Global.FactionID != clan.FactionID)
                {
                    return(Content("Clan must belong to same faction you are in"));
                }

                // check if our name or shortcut conflicts with existing clans
                // if so, allow us to create a new clan over it if it's a deleted clan, else block action
                var existingClans = db.Clans.Where(x => ((SqlFunctions.PatIndex(clan.Shortcut, x.Shortcut) > 0 || SqlFunctions.PatIndex(clan.ClanName, x.ClanName) > 0) && x.ClanID != clan.ClanID));
                if (existingClans.Count() > 0)
                {
                    if (existingClans.Any(x => !x.IsDeleted))
                    {
                        return(Content("Clan with this shortcut or name already exists"));
                    }
                    Clan deadClan  = existingClans.First();
                    Clan inputClan = clan;
                    clan = deadClan;
                    if (noFaction)
                    {
                        clan.FactionID = null;
                    }
                    clan.IsDeleted   = false;
                    clan.ClanName    = inputClan.ClanName;
                    clan.Password    = inputClan.Password;
                    clan.Description = inputClan.Description;
                    clan.SecretTopic = inputClan.SecretTopic;
                }
                else
                {
                    db.Clans.InsertOnSubmit(clan);
                }

                db.SaveChanges();

                acc.ClanID = clan.ClanID;

                // we created a new clan, set self as founder and rights
                AddClanLeader(acc.AccountID, clan.ClanID, db);

                db.SaveChanges();

                if (image != null && image.ContentLength > 0)
                {
                    var im = Image.FromStream(image.InputStream);
                    if (im.Width != 64 || im.Height != 64)
                    {
                        im = im.GetResized(64, 64, InterpolationMode.HighQualityBicubic);
                    }
                    im.Save(Server.MapPath(clan.GetImageUrl()));
                }
                if (bgimage != null && bgimage.ContentLength > 0)
                {
                    var im = Image.FromStream(bgimage.InputStream);
                    im.Save(Server.MapPath(clan.GetBGImageUrl()));
                }

                db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("New clan {0} formed by {1}", clan, acc));
                db.SaveChanges();
            }

            Global.Server.PublishAccountUpdate(acc);
            //scope.Complete();
            Global.Server.ChannelManager.AddClanChannel(clan);;
            Global.Server.SetTopic(clan.GetClanChannel(), clan.SecretTopic, Global.Account.Name);
            //}
            return(RedirectToAction("Detail", new { id = clan.ClanID }));
        }
コード例 #22
0
        private ActionResult ChangePlanetMap(int planetID, int structureTypeID, int targetID, int?newMapID)
        {
            var             db        = new ZkDataContext();
            PlanetStructure structure = db.PlanetStructures.FirstOrDefault(x => x.PlanetID == planetID && x.StructureTypeID == structureTypeID);
            Planet          source    = db.Planets.FirstOrDefault(x => x.PlanetID == planetID);
            Planet          target    = db.Planets.FirstOrDefault(x => x.PlanetID == targetID);
            Galaxy          gal       = db.Galaxies.FirstOrDefault(x => x.GalaxyID == source.GalaxyID);

            if (newMapID == null)
            {
                List <Resource> mapList =
                    db.Resources.Where(
                        x =>
                        x.MapPlanetWarsIcon != null && x.Planets.Where(p => p.GalaxyID == gal.GalaxyID).Count() == 0 && x.MapSupportLevel >= MapSupportLevel.Featured &&
                        x.ResourceID != source.MapResourceID).ToList();
                if (mapList.Count > 0)
                {
                    int r = new Random().Next(mapList.Count);
                    newMapID = mapList[r].ResourceID;
                }
            }
            if (newMapID != null)
            {
                Resource newMap = db.Resources.Single(x => x.ResourceID == newMapID);
                target.Resource = newMap;
                gal.IsDirty     = true;
                string word = "";
                if (target.Faction == source.Faction)
                {
                    if (target.TeamSize < GlobalConst.PlanetWarsMaxTeamsize)
                    {
                        target.TeamSize++;
                    }
                    word = "terraformed";
                }
                else
                {
                    word = "nanodegraded";
                    if (target.TeamSize > 1)
                    {
                        target.TeamSize--;
                    }
                }

                db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("{0} {1} has been {6} by {2} from {3} {4}. New team size is {5} vs {5}",
                                                                            target.Faction,
                                                                            target,
                                                                            structure.StructureType,
                                                                            source.Faction,
                                                                            source,
                                                                            target.TeamSize,
                                                                            word));
            }
            else
            {
                return
                    (Content(string.Format("Terraform attempt on {0} {1} using {2} from {3} {4} has failed - no valid maps",
                                           target.Faction,
                                           target,
                                           structure.StructureType,
                                           source.Faction,
                                           source)));
            }
            db.SaveChanges();
            return(null);
        }
コード例 #23
0
        public ActionResult BombPlanet(int planetID, int count, bool?useWarp)
        {
            var     db  = new ZkDataContext();
            Account acc = db.Accounts.Single(x => x.AccountID == Global.AccountID);

            if (acc.Faction == null)
            {
                return(Content("Join some faction first"));
            }
            Planet planet     = db.Planets.Single(x => x.PlanetID == planetID);
            bool   accessible = (useWarp == true) ? planet.CanBombersWarp(acc.Faction) : planet.CanBombersAttack(acc.Faction);

            if (!accessible)
            {
                return(Content("You cannot attack here"));
            }
            if (Global.Server.GetPlanetBattles(planet).Any(x => x.IsInGame))
            {
                return(Content("Battle in progress on the planet, cannot bomb planet"));
            }

            bool selfbomb = acc.FactionID == planet.OwnerFactionID;

            if (count < 0)
            {
                count = 0;
            }
            double avail = Math.Min(count, acc.GetBombersAvailable());

            if (useWarp == true)
            {
                avail = Math.Min(acc.GetWarpAvailable(), avail);
            }

            var capa = acc.GetBomberCapacity();

            if (avail > capa)
            {
                return(Content("Too many bombers - the fleet limit is " + capa));
            }

            if (avail > 0)
            {
                double defense   = planet.PlanetStructures.Where(x => x.IsActive).Sum(x => x.StructureType.EffectBomberDefense) ?? 0;
                double effective = avail;
                if (!selfbomb)
                {
                    effective = effective - defense;
                }

                if (effective <= 0)
                {
                    return(Content("Enemy defenses completely block your ships"));
                }

                acc.SpendBombers(avail);
                if (useWarp == true)
                {
                    acc.SpendWarps(avail);
                }

                var r = new Random();

                double strucKillChance = !selfbomb ? effective * GlobalConst.BomberKillStructureChance : 0;
                int    strucKillCount  = (int)Math.Floor(strucKillChance + r.NextDouble());

                double ipKillChance = effective * GlobalConst.BomberKillIpChance;
                int    ipKillCount  = (int)Math.Floor(ipKillChance + r.NextDouble());

                List <PlanetStructure> structs = planet.PlanetStructures.Where(x => x.StructureType.IsBomberDestructible).ToList();
                var bombed = new List <StructureType>();
                while (structs.Count > 0 && strucKillCount > 0)
                {
                    strucKillCount--;
                    PlanetStructure s = structs[r.Next(structs.Count)];
                    bombed.Add(s.StructureType);
                    structs.Remove(s);
                    db.PlanetStructures.DeleteOnSubmit(s);
                }

                double ipKillAmmount = ipKillCount * GlobalConst.BomberKillIpAmount;
                if (ipKillAmmount > 0)
                {
                    var influenceDecayMin = planet.PlanetStructures.Where(x => x.IsActive && x.StructureType.EffectPreventInfluenceDecayBelow != null).Select(x => x.StructureType.EffectPreventInfluenceDecayBelow).OrderByDescending(x => x).FirstOrDefault() ?? 0;


                    foreach (PlanetFaction pf in planet.PlanetFactions.Where(x => x.FactionID != acc.FactionID))
                    {
                        pf.Influence -= ipKillAmmount;
                        if (pf.Influence < 0)
                        {
                            pf.Influence = 0;
                        }

                        // prevent bombing below influence decaymin for owner - set by active structures
                        if (pf.FactionID == planet.OwnerFactionID && pf.Influence < influenceDecayMin)
                        {
                            pf.Influence = influenceDecayMin;
                        }
                    }
                }

                var args = new List <object>
                {
                    acc,
                    acc.Faction,
                    !selfbomb ? planet.Faction : null,
                    planet,
                    avail,
                    defense,
                    useWarp == true ? "They attacked by warp. " : "",
                    ipKillAmmount
                };
                args.AddRange(bombed);

                string str;
                if (selfbomb)
                {
                    str = "{0} of {1} bombed own planet {3} using {4} bombers against {5} defenses. {6}Ground armies lost {7} influence";
                }
                else
                {
                    str = "{0} of {1} bombed {2} planet {3} using {4} bombers against {5} defenses. {6}Ground armies lost {7} influence";
                }
                if (bombed.Count > 1)
                {
                    str += " and ";
                    int counter = 8;
                    foreach (var b in bombed)
                    {
                        str += "{" + counter + "}" + ", ";
                        counter++;
                    }
                    str += " were destroyed.";
                }
                else if (bombed.Count == 1)
                {
                    str += " and {8} was destroyed.";
                }
                else
                {
                    str += ".";
                }

                db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent(str, args.ToArray()));
            }

            db.SaveChanges();
            PlanetWarsTurnHandler.SetPlanetOwners(new PlanetwarsEventCreator());
            return(RedirectToAction("Planet", new { id = planetID }));
        }
コード例 #24
0
        public ActionResult SendDropships(int planetID, int count, bool?useWarp)
        {
            var     db  = new ZkDataContext();
            Account acc = db.Accounts.Single(x => x.AccountID == Global.AccountID);

            if (acc.Faction == null)
            {
                return(Content("Join a faction first"));
            }
            Planet planet     = db.Planets.SingleOrDefault(x => x.PlanetID == planetID);
            int    there      = planet.PlanetFactions.Where(x => x.FactionID == acc.FactionID).Sum(x => (int?)x.Dropships) ?? 0;
            bool   accessible = useWarp == true?planet.CanDropshipsWarp(acc.Faction) : planet.CanDropshipsAttack(acc.Faction);

            if (!accessible)
            {
                return(Content(string.Format("That planet cannot be attacked")));
            }
            if (Global.Server.GetPlanetBattles(planet).Any(x => x.IsInGame))
            {
                return(Content("Battle in progress on the planet, cannot send ships"));
            }

            int cnt = Math.Max(count, 0);

            int capa = acc.GetDropshipCapacity();

            if (cnt + there > capa)
            {
                return(Content("Too many dropships on planet - the fleet limit is " + capa));
            }
            cnt = Math.Min(cnt, (int)acc.GetDropshipsAvailable());
            if (useWarp == true)
            {
                cnt = Math.Min(cnt, (int)acc.GetWarpAvailable());
            }
            if (cnt > 0)
            {
                acc.SpendDropships(cnt);
                if (useWarp == true)
                {
                    acc.SpendWarps(cnt);
                    if (cnt < GlobalConst.DropshipsForFullWarpIPGain)
                    {
                        return(Content($"You must send at least {GlobalConst.DropshipsForFullWarpIPGain} dropships when warping"));
                    }
                }

                if (planet.Account != null)
                {
                    Global.Server.GhostPm(planet.Account.Name, string.Format(
                                              "Warning: long range scanners detected fleet of {0} ships inbound to your planet {1} {3}/Planetwars/Planet/{2}",
                                              cnt,
                                              planet.Name,
                                              planet.PlanetID,
                                              GlobalConst.BaseSiteUrl));
                }
                PlanetFaction pac = planet.PlanetFactions.SingleOrDefault(x => x.FactionID == acc.FactionID);
                if (pac == null)
                {
                    pac = new PlanetFaction {
                        FactionID = Global.FactionID, PlanetID = planetID
                    };
                    db.PlanetFactions.InsertOnSubmit(pac);
                }
                pac.Dropships         += cnt;
                pac.DropshipsLastAdded = DateTime.UtcNow;

                if (cnt > 0)
                {
                    db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("{0} sends {1} {2} dropships to {3} {4} {5}",
                                                                                acc,
                                                                                cnt,
                                                                                acc.Faction,
                                                                                planet.Faction,
                                                                                planet,
                                                                                useWarp == true ? "using warp drives" : ""));
                }
                db.SaveChanges();
            }
            return(RedirectToAction("Planet", new { id = planetID }));
        }
コード例 #25
0
        /// <summary>
        /// Automatically close old polls
        /// </summary>
        public static void AutoClosePolls()
        {
            var db = new ZkDataContext();

            foreach (var p in db.Polls.Where(x => x.IsHeadline && x.ExpireBy != null && x.ExpireBy < DateTime.UtcNow && x.RoleTypeID != null).ToList())
            {
                var yes = p.PollVotes.Count(x => x.PollOption.OptionText == "Yes");
                var no  = p.PollVotes.Count(x => x.PollOption.OptionText == "No");
                var acc = p.AccountByRoleTargetAccountID;
                if (yes > no)
                {
                    if (p.RoleIsRemoval)
                    {
                        var toDelete = db.AccountRoles.Where(x => x.AccountID == acc.AccountID && x.RoleTypeID == p.RoleTypeID);
                        db.AccountRoles.DeleteAllOnSubmit(toDelete);
                        db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("{0} was removed from the {1} role of {2} by a vote - {3} for, {4} against", acc, (object)p.Clan ?? p.Faction, p.RoleType, yes, no));

                        db.SaveChanges();

                        Global.Server.GhostPm(acc.Name, string.Format("You were recalled from the function of {0} by a vote", p.RoleType.Name));
                    }
                    else
                    {
                        if (!acc.AccountRolesByAccountID.Any(x => x.RoleTypeID == p.RoleTypeID))
                        {
                            Account previous = null;
                            if (p.RoleType.IsOnePersonOnly)
                            {
                                var entries = db.AccountRoles.Where(x => x.RoleTypeID == p.RoleTypeID && (p.RoleType.IsClanOnly ? x.ClanID == p.RestrictClanID : x.FactionID == p.RestrictFactionID)).ToList();

                                if (entries.Any())
                                {
                                    previous = entries.First().Account;
                                    db.AccountRoles.DeleteAllOnSubmit(entries);
                                    db.SaveChanges();
                                }
                            }

                            var entry = new AccountRole()
                            {
                                Account      = acc,
                                Inauguration = DateTime.UtcNow,
                                Clan         = p.Clan,
                                Faction      = p.Faction,
                                RoleType     = p.RoleType
                            };
                            acc.AccountRolesByAccountID.Add(entry);
                            if (previous == null)
                            {
                                db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("{0} was elected for the {1} role of {2} by a vote - {3} for, {4} against",
                                                                                            acc,
                                                                                            (object)p.Clan ?? p.Faction,
                                                                                            p.RoleType,
                                                                                            yes,
                                                                                            no));
                            }

                            else
                            {
                                db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("{0} was elected for the {1} role of {2} by a vote, replacing {3} - {4} for, {5} against",
                                                                                            acc,
                                                                                            (object)p.Clan ?? p.Faction,
                                                                                            p.RoleType,
                                                                                            previous,
                                                                                            yes,
                                                                                            no));
                            }

                            Global.Server.GhostPm(acc.Name, string.Format("Congratulations!! You were elected into a function of {0} by a vote", p.RoleType.Name));
                        }
                    }
                }

                p.IsHeadline = false;
                db.Polls.DeleteOnSubmit(p);
            }
            db.SaveChanges();
        }
コード例 #26
0
        /// <summary>
        /// Create or modify a PlanetWars <see cref="FactionTreaty"/>
        /// </summary>
        /// <param name="factionTreatyID">Existing <see cref="FactionTreaty"/> ID, if modifying one</param>
        /// <param name="turns">How long the treaty lasts</param>
        /// <param name="acceptingFactionID"></param>
        /// <param name="effectTypeID"><see cref="TreatyEffect"/> to add or remove, if applicable</param>
        /// <param name="effectValue"></param>
        /// <param name="planetID">Specifies the <see cref="Planet"/> for planet-based effects</param>
        /// <param name="isReverse"></param>
        /// <param name="note">Diplomatic note readable by both parties, to better communicate their intentions</param>
        /// <param name="add">If not null or empty, add the specified <see cref="TreatyEffect"/></param>
        /// <param name="delete">Delete the specified <see cref="TreatyEffect"/>?</param>
        /// <param name="propose">If not null or empty, this is a newly proposed treaty</param>
        /// <returns></returns>
        public ActionResult ModifyTreaty(int factionTreatyID,
                                         int?turns,
                                         int?acceptingFactionID,
                                         int?effectTypeID,
                                         double?effectValue,
                                         int?planetID,
                                         bool?isReverse,
                                         TreatyUnableToTradeMode?treatyUnableToTradeMode,
                                         int?proposingFactionGuarantee,
                                         int?acceptingFactionGuarantee,
                                         string note,
                                         string add, int?delete, string propose)
        {
            if (Global.Account == null)
            {
                return(Content("You must be logged in to manage treaties"));
            }
            if (!Global.Account.HasFactionRight(x => x.RightDiplomacy))
            {
                return(Content("Not a diplomat!"));
            }

            FactionTreaty treaty;

            // submit, store treaty in db
            var db = new ZkDataContext();

            if (factionTreatyID > 0)
            {
                treaty = db.FactionTreaties.Single(x => x.FactionTreatyID == factionTreatyID);
                if (treaty.TreatyState != TreatyState.Invalid)
                {
                    return(Content("Treaty already in progress!"));
                }
            }
            else
            {
                if (factionTreatyID == acceptingFactionID)
                {
                    return(Content("Faction cannot enter into treaty with itself"));
                }

                treaty = new FactionTreaty();
                db.FactionTreaties.InsertOnSubmit(treaty);
                treaty.FactionByAcceptingFactionID = db.Factions.Single(x => x.FactionID == acceptingFactionID);
            }
            treaty.AccountByProposingAccountID = db.Accounts.Find(Global.AccountID);
            treaty.FactionByProposingFactionID = db.Factions.Single(x => x.FactionID == Global.FactionID);
            treaty.TurnsRemaining            = turns;
            treaty.TurnsTotal                = turns;
            treaty.TreatyNote                = note;
            treaty.TreatyUnableToTradeMode   = treatyUnableToTradeMode ?? TreatyUnableToTradeMode.Cancel;
            treaty.ProposingFactionGuarantee = Math.Max(proposingFactionGuarantee ?? 0, 0);
            treaty.AcceptingFactionGuarantee = Math.Max(acceptingFactionGuarantee ?? 0, 0);


            if (!string.IsNullOrEmpty(add))
            {
                TreatyEffectType effectType = db.TreatyEffectTypes.Single(x => x.EffectTypeID == effectTypeID);
                var effect = new TreatyEffect
                {
                    FactionByGivingFactionID    = isReverse == true ? treaty.FactionByAcceptingFactionID : treaty.FactionByProposingFactionID,
                    FactionByReceivingFactionID =
                        isReverse == true ? treaty.FactionByProposingFactionID : treaty.FactionByAcceptingFactionID,
                    TreatyEffectType = effectType,
                    FactionTreaty    = treaty
                };
                if (effectType.HasValue)
                {
                    if (effectType.MinValue.HasValue && effectValue < effectType.MinValue.Value)
                    {
                        effectValue = effectType.MinValue;
                    }
                    if (effectType.MaxValue.HasValue && effectValue > effectType.MaxValue.Value)
                    {
                        effectValue = effectType.MaxValue;
                    }
                }
                if (effectType.HasValue)
                {
                    effect.Value = effectValue;
                }
                if (effectType.IsPlanetBased)
                {
                    effect.PlanetID = planetID.Value;
                    effect.Planet   = db.Planets.Find(planetID.Value);
                    if (effect.Planet.PlanetStructures.Any(x => x.StructureType.OwnerChangeWinsGame == true) && effectType.TreatyEffects.Any(x => x.TreatyEffectType.EffectGiveInfluence == true))
                    {
                        return(Content("Cannot trade influence on victory planets"));
                    }
                }
                db.TreatyEffects.InsertOnSubmit(effect);
            }
            if (delete != null)
            {
                db.TreatyEffects.DeleteOnSubmit(db.TreatyEffects.Single(x => x.TreatyEffectID == delete));
            }
            db.SaveChanges();

            if (!string.IsNullOrEmpty(propose))
            {
                treaty.TreatyState = TreatyState.Proposed;

                db.Events.InsertOnSubmit(PlanetwarsEventCreator.CreateEvent("{0} proposes a new treaty between {1} and {2} - {3}", treaty.AccountByProposingAccountID, treaty.FactionByProposingFactionID, treaty.FactionByAcceptingFactionID, treaty));

                db.SaveChanges();
                return(RedirectToAction("Detail", new { id = treaty.ProposingFactionID }));
            }


            return(View("FactionTreatyDefinition", db.FactionTreaties.Find(treaty.FactionTreatyID)));
        }