예제 #1
0
        public override void Core_Update()
        {
            try
            {
                List.Clear();
                Patches.Clear();
                string[] files = Directory.GetFiles(Core.Path_Patches);

                foreach (string file in files)
                {
                    if (file.EndsWith(".feh", StringComparison.OrdinalIgnoreCase))
                    {
                        HackManager patch = new HackManager();
                        patch.OpenFile(file);
                        Patches.Add(patch);

                        List.Add(Tuple.Create(
                                     patch.HackAuthor,
                                     patch.HackName,
                                     patch.IsApplied()));
                    }
                }
            }
            catch (Exception ex)
            {
                Program.ShowError("The patch list could not be loaded onscreen.", ex);
            }
        }
예제 #2
0
 public void Dispose()
 {
     foreach (var patch in Patches)
     {
         patch.Disable();    // this could also be done with Dispose
     }
     Patches.Clear();
 }
예제 #3
0
        public void DoSearch()
        {
            foreach (var card in Cards)
            {
                card.IsDisplayed = true;
            }

            foreach (var card in Cards)
            {
                var isNameMatch          = string.IsNullOrEmpty(CardNameSearch) ? true : card.Info.Name.ToLower().Contains(CardNameSearch.ToLower());
                var isPatchMatch         = string.IsNullOrEmpty(PatchSearch) ? true : card.Info.Patch.Contains(PatchSearch);
                var isNpcMatch           = string.IsNullOrEmpty(NPCNameSearch) ? true : card.Info.NPCs.FirstOrDefault(n => n.ToLower().Contains(NPCNameSearch.ToLower())) != null;
                var isMinDifficultyMatch = string.IsNullOrEmpty(MinDifficultySearch) ? true : card.Difficulty >= int.Parse(MinDifficultySearch);
                var isMaxDifficultyMatch = string.IsNullOrEmpty(MaxDifficultySearch) ? true : card.Difficulty <= int.Parse(MaxDifficultySearch);
                var isCollectionMatch    = string.IsNullOrEmpty(CollectedSearch) || CollectedSearch == "No Preference" ? true : (CollectedSearch == "Collected" && card.IsCollected) || (CollectedSearch == "Uncollected" && !card.IsCollected);

                card.IsDisplayed = isNameMatch && isPatchMatch && isNpcMatch && isMinDifficultyMatch && isMaxDifficultyMatch && isCollectionMatch;
            }

            // store fields for resetting later
            var cardName = CardNameSearch;
            var patch    = PatchSearch;
            var npcName  = NPCNameSearch;

            CardNames.Clear();
            Patches.Clear();
            NPCNames.Clear();

            var displayedCards = Cards.Where(c => c.IsDisplayed);

            foreach (var displayedCard in displayedCards)
            {
                if (!CardNames.Contains(displayedCard.Info.Name))
                {
                    CardNames.Add(displayedCard.Info.Name);
                }

                if (!Patches.Contains(displayedCard.Info.Patch))
                {
                    Patches.Add(displayedCard.Info.Patch);
                }

                foreach (var npc in displayedCard.Info.NPCs)
                {
                    if (!NPCNames.Contains(npc))
                    {
                        NPCNames.Add(npc);
                    }
                }
            }

            // set fields back after the search
            CardNameSearch = cardName;
            PatchSearch    = patch;
            NPCNameSearch  = npcName;
        }
예제 #4
0
        public void ReloadPatches()
        {
            foreach (var patch in Patches)
            {
                patch.Disable();
            }
            Patches.Clear();

            LoadPatches();
        }
예제 #5
0
 public void Patch()
 {
     foreach (int patch in Patches)
     {
         long address = Address;
         int  @int    = VMB.GetInt(patch);
         int  value   = VMBuffer.EncodeInstructionBranch(VMBuffer.GetInstruction(@int), patch);
         VMB.SetInt(patch, value);
     }
     Patches.Clear();
 }
예제 #6
0
        public override void Draw()
        {
            Patches.Clear();
            UISys.Skin().DrawBox((int)WidX, (int)WidY, (int)WidW, (int)WidH);
            UISys.Skin().DrawBoxText((int)(WidX + WidW / 2 - UISys.Skin().SmallFont.Width(Name) / 2), (int)WidY + 8, Name);
            int oy = Scroll.Current;
            int dy = 25 - oy;

            sy = -1;
            ey = -1;
            foreach (var i in ItemRoot.Sub)
            {
                dy = DrawItem(i, dy);
            }
            Scroll.Max   = (dy + oy);
            Scroll.ViewH = (ey - sy);
            Scroll.Rebuild();
        }
예제 #7
0
        private void BuildPatches()
        {
            var points = GetVoronoiPoints(NumPatches, Center).ToList();

            var v = Voronoi.Build(points);

            for (var i = 0; i < 3; i++)
            {
                var toRelax = v.Points.Take(3).ToList();
                toRelax.Add(v.Points[NumPatches]);
                v = Voronoi.Relax(v, toRelax);
            }

            v = Voronoi.Relax(v);

            var comparer = new Vector2LengthComparer();

            v.Points.Sort(comparer);

            var regions = v.Partitioning();

            Patches.Clear();
            foreach (var region in regions)
            {
                Patches.Add(Patch.FromRegion(this, region));
            }

            var patchesInTown = Patches.OrderBy(p => (Center - p.Center).magnitude).Take(NumPatches).ToList();

            // Find random patch at the outside of town to place water
            if (Options.Water)
            {
                var firstWaterPatch = patchesInTown.Where(p => p.GetAllNeighbours().Any(n => !n.WithinCity))
                                      .OrderBy(p => Random.value).First();
                firstWaterPatch.Water = true;

                Vector2 waterDirection = (firstWaterPatch.Center - Center).normalized;


                var toCheck = new List <Patch> {
                    firstWaterPatch
                };
                while (toCheck.Any())
                {
                    var checking = toCheck[0];
                    toCheck.RemoveAt(0);

                    var waterPatches = checking.GetAllNeighbours().Except(patchesInTown)
                                       .Where(n => Math.Abs(GeometryHelpers.AngleComparedTo(Center - n.Center, waterDirection)) < Math.PI / 4)
                                       .Where(n => !n.Water).ToList();
                    foreach (var waterPatch in waterPatches)
                    {
                        waterPatch.Water = true;
                        toCheck.Add(waterPatch);
                    }
                }
            }

            patchesInTown = Patches.Where(p => !p.Water).OrderBy(p => (Center - p.Center).magnitude).Take(NumPatches)
                            .ToList();

            foreach (var patch in patchesInTown)
            {
                patch.WithinCity  = true;
                patch.WithinWalls = true;
            }

            Castle = new Castle(patchesInTown.Last());

            Market = patchesInTown.First();
            Market.IsCityCenter = true;

            var circumference = FindCircumference(patchesInTown);
            var smoothAmount  = Math.Min(1f, 40f / circumference.Vertices.Count);

            if (Options.Walls)
            {
                SmoothPatches(circumference, smoothAmount);
            }

            if (Options.Water)
            {
                var waterCircumference = FindCircumference(Patches.Where(p => p.Water));
                SmoothPatches(waterCircumference, 0.2f);
                WaterBorder.Clear();
                WaterBorder.AddRange(waterCircumference.Vertices);
            }
        }
        internal void ComputeTrajectory()
        {
            if (!VesselHasParts)// || AttachedVessel.LandedOrSplashed)
            {
                increment_time = 0d;
                Patches.Clear();
                return;
            }

            try
            {
                // start of trajectory calculation in current frame
                increment_time = Util.Clocks;

                // create or update aerodynamic model
                if (aerodynamicModel_ == null || !aerodynamicModel_.IsValidFor(AttachedVessel.mainBody))
                {
                    aerodynamicModel_ = AerodynamicModelFactory.GetModel(this, AttachedVessel.mainBody);
                }
                else
                {
                    aerodynamicModel_.UpdateVesselMass();
                }

                // if there is no ongoing partial computation, start a new one
                if (partialComputation_ == null)
                {
                    //total_time = Util.Clocks;

                    // restart the public buffers
                    patchesBackBuffer_.Clear();
                    maxAccelBackBuffer_ = 0;

                    // Create enumerator for Trajectory increment calculator
                    partialComputation_ = ComputeTrajectoryIncrement().GetEnumerator();
                }

                // we are finished when there are no more partial computations to be done
                bool finished = !partialComputation_.MoveNext();

                // when calculation is finished,
                if (finished)
                {
                    // swap the buffers for the patches and the maximum acceleration,
                    // "publishing" the results
                    List <Patch> tmp = Patches;
                    Patches            = patchesBackBuffer_;
                    patchesBackBuffer_ = tmp;

                    MaxAccel = maxAccelBackBuffer_;

                    // Reset partial computation
                    partialComputation_.Dispose();
                    partialComputation_ = null;

                    // how long did the whole calculation take?
                    //total_time = Util.ElapsedMilliseconds(total_time);
                }

                // how long did the calculation in this frame take?
                increment_time = Util.ElapsedMilliseconds(increment_time);
            }
            catch (Exception)
            {
                ++ErrorCount;
                throw;
            }
        }