Example #1
0
        public SearcherF()
        {
            InitializeComponent();
            Icon        = Icon.ExtractAssociatedIcon(Application.ExecutablePath);
            MinimumSize = MaximumSize = Size;
            MaximizeBox = false;

            Load += (sender, e) =>
            {
                ImageList imgList = new ImageList();
                for (int i = 0; i < FilesManager.BuildSets.Count; i++)
                {
                    BuildSet set = FilesManager.BuildSets[i];
                    imgList.Images.Add(set.Image);
                }

                listView1.SmallImageList = imgList;
            };


            textBox1.TextChanged += (sender, e) =>
            {
                if (textBox1.Text.Length > 1)
                {
                    SearchByWord(textBox1.Text);
                }
                else if (textBox1.Text.Length == 0)
                {
                    listView1.Items.Clear();
                }
            };

            listView1.MouseDoubleClick += (sender, e) =>
            {
                if (listView1.SelectedIndices.Count == 0 || listView1.SelectedIndices[0] < 0)
                {
                    return;
                }

                ListViewItem item = listView1.GetItemAt(e.X, e.Y);
                if (item?.Tag is BuildingEntry entry)
                {
                    if (!Global.FreeView)
                    {
                        Global.FreeView = true;
                    }
                    Global.X     = entry.Location.X;
                    Global.Y     = entry.Location.Y;
                    Global.Facet = entry.Map == 7 ? 0 : entry.Map;
                }
            };

            FormClosing += (sender, e) =>
            {
                if (Global.FreeView)
                {
                    Global.FreeView = false;
                }
            };
        }
Example #2
0
        public static BuildSet GetMatchBuild(MatchDetail match, Participant participant)
        {
            if (PotentialUpgrades == null)
            {
                InitializePotentialUpgrades();
            }
            var set = new BuildSet()
            {
                HasMatchData = true
            };

            set.TimeSince = GetTimeSince(match.MatchCreation);

            var timeline          = match.Timeline;
            var allPurchasedItems = getAllPurchasedItems(timeline, participant.ParticipantId);

            set.InitialPurchase = getStartingItems(timeline, participant.ParticipantId);
            set.FinalBuild      = getFinalBuild(participant);
            set.RushItem        = getRushItem(allPurchasedItems.ToList(), set.InitialPurchase.Items.ToList());

            var allConsumables = getConsumables(allPurchasedItems.ToList());

            if (allConsumables.Count > 0)
            {
                set.Consumables = (getPurchaseSet("Consumables", allConsumables, includePrice: false));
            }

            set.FullBuild        = set.FinalBuild.Items.Count == 7 && !(set.FinalBuild.Items.Any(x => PotentialUpgrades.ContainsKey(x.Id.ToString())));
            set.Id               = match.MatchId;
            set.MatchDataFetched = true;
            return(set);
        }
Example #3
0
        private Node AddRoot(string name, Bitmap img, CheckState enabled, BuildSet set)
        {
            MyRoot node = new MyRoot(name, img, enabled)
            {
                Tag = set
            };

            _model.Nodes.Add(node);
            return(node);
        }
Example #4
0
 public static bool Start(BuildSet BuildSettings)
 {
     try
     {
         mset = new MergeSet().ConvertMergeSet(BuildSettings);
         Console.WriteLine("[+] Merging with an application binary...");
         start_merge(); // Start merge
         return(true);
     }
     catch (StartMergeError)
     {
         return(false);
     }
 }
Example #5
0
        /// <summary>
        /// Start check BuildSet data
        /// </summary>
        /// <param name="bset">BuildSet Object</param>
        /// <returns></returns>
        public static bool Start(ref BuildSet bset)
        {
            try
            {
                Directory.Delete(bset.tmp_folder_path, true);
            }
            catch { }

            Console.WriteLine("[+] Checking file path data...");
            if (!File.Exists(bset.source_path))
            {
                Console.WriteLine("[-] This file is not found: [" + bset.source_path + "]\r\n");
                return(false);
            }
            else if (!Directory.Exists(bset.python_path))
            {
                Console.WriteLine("[-] This directory is not found: [" + bset.python_path + "]\r\n");
                return(false);
            }
            else if (!File.Exists(bset.python_binary_path))
            {
                Console.WriteLine("[-] The compiler is missing: [" + bset.python_binary_path + "]\r\n");
                return(false);
            }

            try
            {
                // Can read output binary
                if (bset.output_path == Path.GetFileName(bset.output_path))
                {
                    bset.output_path = bset.source_folder_path + @"\" + bset.output_path;
                }
                using (FileStream fs = new FileStream(bset.output_path, FileMode.Create))
                {
                }
            }
            catch
            {
                if (bset.one_file)
                {
                    bset.output_path = bset.source_folder_path + @"\" + Path.GetFileNameWithoutExtension(bset.source_path) + ".exe";
                }
                else
                {
                    bset.output_path = bset.source_folder_path + @"\pyDotexe_" + Path.GetFileNameWithoutExtension(bset.source_path) + @"\" + Path.GetFileNameWithoutExtension(bset.source_path) + ".exe";
                }
            }
            return(true);
        }
Example #6
0
 public void LoadXML(XmlElement root)
 {
     foreach (XmlElement node in root["labels"])
     {
         string name = node.ToText("name");
         if (!string.IsNullOrEmpty(name))
         {
             BuildSet set = FilesManager.BuildSets.FirstOrDefault(s => s.Name == name);
             if (set != null)
             {
                 set.IsEnabled = node.ToText("enabled").ToBool();
             }
         }
     }
 }
Example #7
0
        public static BuildSet GetGameBuild(Game game, Summoner summoner)
        {
            if (PotentialUpgrades == null)
            {
                InitializePotentialUpgrades();
            }
            var set = new BuildSet();

            set.TimeSince        = GetTimeSince(game.CreateDate);
            set.FinalBuild       = getFinalBuild(game.Statistics);
            set.Champion         = getChampion(game.ChampionId);
            set.FullBuild        = set.FinalBuild.Items.Count == 7 && !(set.FinalBuild.Items.Any(x => PotentialUpgrades.ContainsKey(x.Id.ToString())));
            set.Id               = game.GameId;
            set.SummonerId       = summoner.Id;
            set.MatchDataFetched = false;
            set.TotalDamageDealt = game.Statistics.TotalDamageDealt;
            return(set);
        }
Example #8
0
        public ActionResult Index(BuildSet typeId = BuildSet.Random)
        {
            if (typeId == BuildSet.Random)
            {
                typeId = (BuildSet)new Random(Guid.NewGuid().GetHashCode()).Next(1, Enum.GetNames(typeof(BuildSet)).Length);
            }

            var builds =
                _buildsDomain.GetBuilds(Server.MapPath(string.Format(@"~/App_Data/BuildSets/{0}.json", typeId.GetDescription())));

            var vm = new ViewModels.BuildStatus
            {
                BuildSet = typeId,
                Builds = builds,
                IsRedAlertEnabled = _commonDomain.GetRedAlert(Server.MapPath(@"~/App_Data/RedAlert.json")).IsEnabled
            };

            return View(vm.Builds.Count() > 8 ? "HighCount" : "LowCount", vm);
        }
Example #9
0
        void OnRepositoryChange(GithubRepository repository, List <Commit> commits)
        {
            foreach (var commit in commits)
            {
                if (commit.BuildSet != null)
                {
                    continue;
                }

                // Spawn a set of builds for this commit.
                var buildSet = new BuildSet {
                    Commit = commit
                };

                commit.BuildSet = buildSet;

                Branch branch;
                commit.Branch.TryGetTarget(out branch);

                Repository repo;
                branch.Repository.TryGetTarget(out repo);

                var buildConfiguration = repo.Project.DefaultBuildConfiguration;
                buildConfiguration.Directory = Options.OutputDir;

                Log.Message("Spawning new build for {0}/{1}", repo.Project.Name,
                            commit.ToString());

                var build = new Build(repo.Project, commit, buildConfiguration);
                buildSet.Builds.Add(build);

                Database.AddBuild(build);

                BuildQueue.AddBuild(build);
            }
        }
Example #10
0
        public override void OnFrame(Tyr tyr)
        {
            tyr.NexusAbilityManager.PriotitizedAbilities.Add(948);
            tyr.NexusAbilityManager.PriotitizedAbilities.Add(950);
            tyr.buildingPlacer.BuildCompact = true;

            FlyerAttackTask.Task.RequiredSize = RequiredSize;
            IdleTask.Task.FearEnemies         = true;

            DefenseTask.Task.IgnoreEnemyTypes.Add(UnitTypes.VIKING_FIGHTER);

            FlyerDestroyTask.Task.Stopped = !DefendReapers;
            FlyerAttackTask.Task.Stopped  = DefendReapers;

            if (Count(UnitTypes.PROBE) <= 18)
            {
                BaseWorkers.WorkersPerGas = 0;
            }
            else
            {
                BaseWorkers.WorkersPerGas = 3;
            }

            if (tyr.EnemyRace == Race.Zerg)
            {
                Beyond2Cannons = tyr.EnemyStrategyAnalyzer.TotalCount(UnitTypes.ZERGLING) > 0 || Count(UnitTypes.STARGATE) >= 3;
            }

            if (tyr.Frame == 118)
            {
                tyr.Chat("Time for some monobattles!");
            }
            if (tyr.Frame == 163)
            {
                if (BuildCarriers)
                {
                    tyr.Chat("I choose Carriers! :D");
                }
                else
                {
                    tyr.Chat("I choose Skillrays! :D");
                }
            }

            if (!LiftingDetected)
            {
                foreach (Unit unit in tyr.Enemies())
                {
                    if (unit.IsFlying && UnitTypes.BuildingTypes.Contains(unit.UnitType))
                    {
                        LiftingDetected = true;
                    }
                }
            }

            if (LiftingDetected && tyr.EnemyManager.EnemyBuildings.Count == 0 && !ChasingLiftedBuildings)
            {
                ChasingLiftedBuildings = true;
                tyr.TaskManager.Add(new ElevatorChaserTask());
            }


            if (!DefendRush && tyr.Frame <= 4800 && Tyr.Bot.EnemyRace != Race.Zerg)
            {
                int enemyCount = 0;
                foreach (Unit enemy in tyr.Enemies())
                {
                    if (SC2Util.DistanceSq(enemy.Pos, tyr.MapAnalyzer.StartLocation) <= 40 * 40)
                    {
                        enemyCount++;
                    }
                }

                if (enemyCount >= 3)
                {
                    DefendRush = true;
                }
            }

            if ((tyr.EnemyRace == Race.Terran || tyr.EnemyRace == Race.Random) &&
                ReaperDefenseCannonStep.DesiredPos == null &&
                !SkipDefenses)
            {
                foreach (Unit unit in tyr.Enemies())
                {
                    if (unit.UnitType == UnitTypes.REAPER &&
                        Tyr.Bot.MapAnalyzer.StartArea[(int)System.Math.Round(unit.Pos.X), (int)System.Math.Round(unit.Pos.Y)])
                    {
                        Point2D dir    = SC2Util.Point(unit.Pos.X - tyr.MapAnalyzer.StartLocation.X, unit.Pos.Y - tyr.MapAnalyzer.StartLocation.Y);
                        float   length = (float)System.Math.Sqrt(dir.X * dir.X + dir.Y * dir.Y);
                        dir = SC2Util.Point(dir.X / length, dir.Y / length);

                        ReaperDefenseCannonStep.DesiredPos = SC2Util.Point(tyr.MapAnalyzer.StartLocation.X + dir.X * 4f, tyr.MapAnalyzer.StartLocation.Y + dir.Y * 4f);
                        break;
                    }
                }
            }

            if (!DefendReapers && tyr.EnemyStrategyAnalyzer.Count(UnitTypes.REAPER) >= 2)
            {
                FearVikingsController.Stopped = false;
                DefendReapers = true;
                tyr.buildingPlacer.SpreadCannons = false;
                tyr.buildingPlacer.BuildCompact  = true;
                WorkerTask.Task.StopTransfers    = true;
                HideBaseTask.Task.BuildNexus     = true;

                IdleTask.Task.OverrideTarget = FarBase.BaseLocation.Pos;
                DefenseTask.Task.Stopped     = true;
                RequiredSize = 8;

                Set  = new BuildSet();
                Set += HiddenBasePylons();
                Set += HiddenBaseBuild();
            }

            /*
             * if (tyr.EnemyStrategyAnalyzer.Count(UnitTypes.REAPER) >= 2
             *  && NaturalMirrorCannonStep.DesiredBase == null)
             * {
             *  PotentialHelper helper = new PotentialHelper(tyr.BaseManager.Natural.BaseLocation.Pos);
             *  helper.Magnitude = 8;
             *  helper.From(tyr.BaseManager.NaturalDefensePos);
             *  NaturalMirrorCannonStep.DesiredPos = helper.Get();
             *  NaturalMirrorPylonStep.DesiredPos = helper.Get();
             * }
             */
        }
Example #11
0
        /// <summary>
        /// Start source-file analysis
        /// </summary>
        /// <param name="BuildSettings">BuildSet Object</param>
        /// <returns></returns>
        public static bool Start(ref BuildSet BuildSettings)
        {
            try
            {
                bset = BuildSettings;
                if (!bset.standalone)
                {
                    bset.module_path.Add(bset.source_path);
                    bset.except_file_list.Add(bset.python_path.Replace(@"\", @"\\"));
                }

                Console.WriteLine("[+] Getting imported default modules path...");
                get_import_modules_name(); // Get imported module names by source code.
                make_module_loader();      // // Make module loader file. (pyDotexe_module_loader.py)
                get_import_file_path();    // Start module loader by Python-Shell and Get module paths.

                Console.WriteLine("\r\n[+] Searching selected modules...");
                if (bset.hooks)
                {
                    check_copy_hooks(); // Check some modules.
                }
                import_pyfilecmd();     // Search selected python file by Regex.
                import_pydircmd();      // Search seletcted python folder by Regex.

                if (bset.except_file_list.Count != 0)
                {
                    Console.WriteLine("\r\n[+] Excluding selected module files and folders...");
                    exc_pyfile(); // Exclude selected module names by file.
                }

                if (extract_pyd()) // Search for pyd files by Python module paths list
                {
                    Console.WriteLine("\r\n[+] Getting Dynamic-Link-Library by *.pyd files...");
                    analysis_pyd();         // Open pyd files and Get some DLL file names.
                    search_dll_in_folder(); // Search DLL file by names.
                }

                if (bset.check_only)
                {
                    show_module_list();
                    return(false);
                }

                return(true);
            }
            catch (GetImportDataError ex)
            {
                Console.WriteLine("[-] Could not read main-source file.\r\n[!] " + ex.Message);
            }
            catch (MakeModuleLoaderError ex)
            {
                Console.WriteLine("[-] Could not make 'module_load_pyDotexe.py' file.\r\n[!] " + ex.Message);
            }
            catch (GetImportFilePathError)
            {
                Console.WriteLine("[-] Import error found. Please check your code or file path.");
            }
            catch (GetModulesByProcessError ex)
            {
                Console.WriteLine("[-] Could not get python modules.\r\n[!] " + ex.Message);
            }
            finally
            {
                try
                {
                    File.Delete(bset.module_load_path);
                }
                catch { }
            }
            return(false);
        }
Example #12
0
        /// <summary>
        /// Start build and marge
        /// </summary>
        /// <param name="BuildSettings">BuildSet Object</param>
        /// <returns></returns>
        public static bool Start(ref BuildSet BuildSettings)
        {
            try
            {
                bset = BuildSettings;
                if (bset.standalone)
                {
                    if (bset.all_imports)
                    {
                        Console.WriteLine("\r\n[+] Copying all modules file...");
                        copy_all_modules(); // Import all modules.
                    }
                    else
                    {
                        Console.WriteLine("\r\n[+] Copying Python libraries and compiler...");
                        import_dll_compiler(); // Copy python libraries to TMP folder.
                    }
                }

                Console.WriteLine("\r\n[+] Copying imported modules...");
                copy_module_file(); // Copy selected files to TMP folder.

                if ((bset.resource_folder.Count != 0) | (bset.resource_file.Count != 0))
                {
                    Console.WriteLine("[+] Copying selected resources data...");
                    copy_resources(); // Copy delected resource files to TMP folder.
                    Console.WriteLine();
                }

                if (bset.debug) // Debug mode only.
                {
                    Console.WriteLine("\r\n");
                    Analysis.show_module_list();
                    Console.WriteLine("\r\n[+] Debug path and command-options extracted. You can start in Command-Lines.");
                    string startCMD = "";
                    string startApp = "";

                    if (bset.standalone)
                    {
                        startApp = "\"" + bset.tmp_module_path + @"\" + Path.GetFileName(bset.default_python_bin) + "\"";
                        startCMD = "\"" + bset.tmp_module_path + @"\" + Path.GetFileNameWithoutExtension(bset.source_path) + bset.default_src_ex + "\"";
                    }
                    else
                    {
                        startApp = "python";
                        startCMD = "\"" + bset.tmp_module_path + @"\" + Path.GetFileNameWithoutExtension(bset.source_path) + bset.default_src_ex + "\"";
                    }

                    Console.WriteLine("[*] " + startApp + " " + startCMD);
                    try
                    {
                        using (StreamWriter sw = new StreamWriter(bset.tmp_folder_path + @"\pydotexe_debug.bat"))
                        {
                            sw.WriteLine(startApp + " " + startCMD);
                            sw.WriteLine("pause");
                        }
                        Process.Start(bset.tmp_folder_path + @"\pydotexe_debug.bat");
                    } catch { }
                    return(false);
                }

                if (!bset.zip_out & bset.add_fixed)
                {
                    add_fixes_argv_path();                                 // Add file path fixed.
                }
                if (bset.optimize)
                {
                    Console.WriteLine("[+] Optimizing Python modules...");
                    optimize_code_start();
                }

                if (bset.standalone)
                {
                    Console.WriteLine("[+] Compiling imported modules...");
                    replace_compile_file(); // Replace default source codes file to compiled file.
                }

                if (bset.one_file)
                {
                    Console.WriteLine("[+] Creating image file...");
                    compress_modules(); // Compress TMP folder.
                }
                else
                {
                    Console.WriteLine("[+] Copying to out-folder path...");
                    string dir_path = Path.GetDirectoryName(bset.output_path);
                    if (!Directory.Exists(dir_path))
                    {
                        new DirectoryInfo(dir_path).Create();
                    }
                    copy_folder(bset.tmp_module_path, dir_path);
                }

                if (bset.zip_out) // Zip-out mode only
                {
                    try
                    {
                        File.Copy(bset.zip_path, bset.source_folder_path + @"\" + Path.GetFileNameWithoutExtension(bset.source_path) + ".zip", true);
                    }
                    catch (Exception ex) { throw new CompressModulesError(ex.Message); }

                    Console.WriteLine("\a\r\n[+] File compression completed.");
                    Console.WriteLine("[*] " + bset.source_folder_path + @"\" + Path.GetFileNameWithoutExtension(bset.source_path) + ".zip");
                    try
                    {
                        Directory.Delete(bset.tmp_folder_path, true);
                    }
                    catch { }
                    return(false);
                }

                marge_application(); // Merge application binary.
                return(true);
            }
            catch (CreateTmpError)
            {
                Console.WriteLine("[-] Could not make temporary folder.");
            }
            catch (ImportDllCompilerError)
            {
                Console.WriteLine("\r\n[-] Could not copy the file: python.exe, pythonw.exe, python" + bset.py_version + ".dll or Source code.");
            }
            catch (ReplaceCompileFileError)
            {
                Console.WriteLine("[-] Could not compile python sources.");
            }
            catch (CompressModulesError)
            {
                Console.WriteLine("[-] Could not create image file.");
            }
            catch (MargeApplicationError)
            {
            }
            return(false);
        }