Ejemplo n.º 1
0
 public MeshBoundary(string name1, PatchType type1, string neighbourPatch1)
 {
     Faces = new List<List<int>>();
     Name = name1;
     Type = type1;
     NeighbourPatch = neighbourPatch1;
 }
Ejemplo n.º 2
0
 public MeshBoundary(string name1, PatchType type1, string neighbourPatch1, IEnumerable<int> faces1)
 {
     Faces = new List<List<int>>();
     Name = name1;
     Type = type1;
     NeighbourPatch = neighbourPatch1;
     Faces.Add(new List<int>(faces1));
 }
Ejemplo n.º 3
0
 protected override void Setup()
 {
     if (TypeLayout.NativePointerSize == 4)
     {
         NativePatchType = PatchType.I4;
     }
     else
     {
         NativePatchType = PatchType.I8;
     }
 }
Ejemplo n.º 4
0
        private static byte GetPatchTypeSize(PatchType patchType)
        {
            switch (patchType)
            {
            case PatchType.I32: return(32);

            case PatchType.I64: return(64);
            }

            throw new CompilerException($"unknown patch type: {patchType}");
        }
Ejemplo n.º 5
0
 public Patch(string owner, PatchType type, int index, int multiplyer, int config)
 {
     this.weeds      = true;
     this.status     = 0;
     this.lastUpdate = Environment.TickCount;
     this.ownerName  = owner;
     this.patchType  = type;
     this.index      = index;
     this.multiplyer = multiplyer;
     this.configId   = config;
 }
Ejemplo n.º 6
0
        private static bool Patch(string filepath, PatchType type, IOffset offsets)
        {
            switch (type)
            {
            case PatchType.Farclip:
                return(ApplyPatch(filepath, offsets.SetFarclipPattern.Clone()));

            default:
                return(false);
            }
        }
Ejemplo n.º 7
0
        public void PatchConstructor <TClass>(
            Type[] parameters,
            PatchType patchType,
            string prefixMethodName  = default,
            string postfixMethodName = default)
            where TClass : class
        {
            var m = AccessTools.Constructor(typeof(TClass), parameters);

            this.PatchMethod <TClass>(m, patchType, prefixMethodName, postfixMethodName);
        }
Ejemplo n.º 8
0
 protected override void Initialize()
 {
     if (TypeLayout.NativePointerSize == 4)
     {
         NativePatchType = PatchType.I32;
     }
     else
     {
         NativePatchType = PatchType.I64;
     }
 }
Ejemplo n.º 9
0
 public Patch(string owner, PatchType type, int index, int multiplyer, int config)
 {
     this.weeds = true;
     this.status = 0;
     this.lastUpdate = Environment.TickCount;
     this.ownerName = owner;
     this.patchType = type;
     this.index = index;
     this.multiplyer = multiplyer;
     this.configId = config;
 }
Ejemplo n.º 10
0
        private static byte GetPatchTypeSize(PatchType patchType)
        {
            switch (patchType)
            {
            case PatchType.I4: return(32);

            case PatchType.I8: return(64);

            default:
                throw new CompilerException("unknown patch type: " + patchType.ToString());
            }
        }
Ejemplo n.º 11
0
 public Patch(string owner, PatchType type, int index, int configId, int[] configArray, long timeToGrow, int crop, int multiplyer)
 {
     this.ownerName = owner;
     this.patchType = type;
     this.index = index;
     this.configId = configId;
     this.configArray = configArray;
     this.timeToGrow = timeToGrow;
     this.multiplyer = multiplyer;
     this.weeds = true;
     this.status = 0;
 }
Ejemplo n.º 12
0
 /// <summary>
 /// 打补丁
 /// </summary>
 /// <param name="type">两种打补丁的方式:精准(指定位置替换)、通用(特征码替换)</param>
 /// <returns></returns>
 public bool Patch(PatchType type)
 {
     if (type == PatchType.Accurate)
     {
         AccuratePatch();
     }
     else
     {
         CommonPatch();
     }
     return(true);
 }
Ejemplo n.º 13
0
 public Patch(string owner, PatchType type, int index, int configId, int[] configArray, long timeToGrow, int crop, int multiplyer)
 {
     this.ownerName   = owner;
     this.patchType   = type;
     this.index       = index;
     this.configId    = configId;
     this.configArray = configArray;
     this.timeToGrow  = timeToGrow;
     this.multiplyer  = multiplyer;
     this.weeds       = true;
     this.status      = 0;
 }
Ejemplo n.º 14
0
        public void PatchMethod <TClass>(
            string methodName,
            Type[] parameters,
            PatchType patchType,
            Type[] generics          = null,
            string prefixMethodName  = default,
            string postfixMethodName = default)
            where TClass : class
        {
            var m = AccessTools.Method(typeof(TClass), methodName, parameters, generics);

            this.PatchMethod <TClass>(m, patchType, prefixMethodName, postfixMethodName);
        }
Ejemplo n.º 15
0
        public void PatchMethod(
            Type classType,
            string methodName,
            Type[] parameters,
            PatchType patchType,
            Type[] generics          = null,
            string prefixMethodName  = default,
            string postfixMethodName = default)
        {
            var m = AccessTools.Method(classType, methodName, parameters, generics);

            this.PatchMethod(classType, m, patchType, prefixMethodName, postfixMethodName);
        }
Ejemplo n.º 16
0
        /*********
        ** Public Methods
        *********/
        /// <summary>Constructs an instance.</summary>
        /// <param name="patchType">The type of patch the method is.</param>
        /// <param name="type">The type that contains the method to patch.</param>
        /// <param name="methodName">The name of the method to patch; otherwise, <see langword="null"/> to patch a constructor.</param>
        /// <param name="parameterTypes">The types of parameters of the method to patch.</param>
        public PatchAttribute(PatchType patchType, Type type, string methodName, Type[] parameterTypes = null)
        {
            PatchType = patchType;

            if (methodName == null)
            {
                OriginalMethod = AccessTools.Constructor(type, parameterTypes) ?? throw new MissingMethodException($"Couldn't find constructor '{type.FullName}({string.Join(", ", (parameterTypes ?? new Type[0]).Select(parameterType => parameterType.Name))})'");
            }
            else
            {
                OriginalMethod = AccessTools.Method(type, methodName, parameterTypes) ?? throw new MissingMethodException($"Couldn't find method '{type.FullName}.{methodName}({string.Join(", ", (parameterTypes ?? new Type[0]).Select(parameterType => parameterType.Name))})'");
            }
        }
Ejemplo n.º 17
0
        /// <summary>
        /// Initializes a new instance of LinkRequest.
        /// </summary>
        /// <param name="linkType">Type of the link.</param>
        /// <param name="patchType">Type of the patch.</param>
        /// <param name="patchSymbol">The patch symbol.</param>
        /// <param name="patchOffset">The patch offset.</param>
        /// <param name="referenceSymbol">The reference symbol.</param>
        /// <param name="referenceOffset">The reference offset.</param>
        ///
        public LinkRequest(LinkType linkType, PatchType patchType, LinkerSymbol patchSymbol, int patchOffset, LinkerSymbol referenceSymbol, int referenceOffset)
        {
            Debug.Assert(patchSymbol != null);
            Debug.Assert(referenceSymbol != null);

            LinkType  = linkType;
            PatchType = patchType;

            PatchSymbol = patchSymbol;
            PatchOffset = patchOffset;

            ReferenceSymbol = referenceSymbol;
            ReferenceOffset = referenceOffset;
        }
Ejemplo n.º 18
0
        /*********
        ** Protected methods
        *********/
        /// <summary>Construct an instance.</summary>
        /// <param name="logName">A unique name for this patch shown in log messages.</param>
        /// <param name="type">The patch type.</param>
        /// <param name="contentPack">The content pack which requested the patch.</param>
        /// <param name="assetName">The normalized asset name to intercept.</param>
        /// <param name="conditions">The conditions which determine whether this patch should be applied.</param>
        /// <param name="normalizeAssetName">Normalize an asset name.</param>
        /// <param name="fromAsset">The normalized asset key from which to load the local asset (if applicable), including tokens.</param>
        protected Patch(string logName, PatchType type, ManagedContentPack contentPack, IManagedTokenString assetName, IEnumerable <Condition> conditions, Func <string, string> normalizeAssetName, IManagedTokenString fromAsset = null)
        {
            this.LogName                = logName;
            this.Type                   = type;
            this.ContentPack            = contentPack;
            this.ManagedRawTargetAsset  = assetName;
            this.Conditions             = conditions.ToArray();
            this.NormalizeAssetNameImpl = normalizeAssetName;
            this.PrivateContext         = new LocalContext(scope: this.ContentPack.Manifest.UniqueID);
            this.ManagedRawFromAsset    = fromAsset;

            this.Contextuals
            .Add(this.Conditions)
            .Add(assetName);
        }
Ejemplo n.º 19
0
        /// <summary>
        /// c.根据补丁信息,安装补丁
        /// 两种打补丁的方式:精准(指定位置替换)、通用(特征码替换)
        /// </summary>
        /// <param name="type">两种打补丁的方式:精准(指定位置替换)、通用(特征码替换)</param>
        /// <returns></returns>
        public bool Patch(PatchType type = PatchType.Accurate)
        {
            // 首先验证文件修改器是否没问题
            foreach (FileHexEditor editor in editors)
            {
                if (type == PatchType.Accurate && editor.FileModifyInfo == null)
                {
                    throw new Exception("补丁安装失败,原因:文件修改器初始化失败!");
                }
                if (type == PatchType.Common && editor.FileCommonModifyInfo == null)
                {
                    throw new Exception("补丁安装失败,原因:特征码修改器初始化失败!");
                }
            }
            // 再备份所有文件
            foreach (FileHexEditor editor in editors)
            {
                editor.Backup();
            }
            // 打补丁!
            List <FileHexEditor> done = new List <FileHexEditor>(); // 已经打上补丁的

            try
            {
                foreach (FileHexEditor editor in editors)
                {
                    bool success = editor.Patch(type);
                    if (!success)
                    {
                        editor.Restore();
                    }
                    else
                    {
                        done.Add(editor);
                    }
                }
            }
            catch (Exception ex)
            {
                // 恢复所有已经打上补丁的文件
                foreach (FileHexEditor editor in done)
                {
                    editor.Restore();
                }
                throw ex;
            }
            return(true);
        }
Ejemplo n.º 20
0
        private static RelocationType ConvertType(PatchType patchType, LinkType linkType, MachineType machineType)
        {
            if (machineType == MachineType.Intel386)
            {
                if (linkType == LinkType.AbsoluteAddress)
                {
                    return(RelocationType.R_386_32);
                }
                else if (linkType == LinkType.RelativeOffset)
                {
                    return(RelocationType.R_386_PC32);
                }
            }

            return(RelocationType.R_386_NONE);
        }
Ejemplo n.º 21
0
        /// <summary>
        /// Re-evaluate the type of the patch, sets the Type.
        /// </summary>
        private void EvaluateType()
        {
            long negspan = (long)(StartOffset - EndOffset);

            if (StartOffset == EndOffset && EndMove == _patchdata.Length)
            {
                Type = PatchType.Insert;
            }
            else if (_patchdata.Length == 0 && negspan == EndMove)
            {
                Type = PatchType.Delete;
            }
            else
            {
                Type = PatchType.Replace;
            }
        }
Ejemplo n.º 22
0
 public DolPatch(String path, UInt32 start, UInt32 end, Int32 offset) : this(path)
 {
     var tmp = default(UInt32);
     if (start > end)
     {
         tmp   = end;
         end   = start;
         start = tmp;
     }
     if (this.GetFileAddress((UInt32)(start + offset)) == 0 ||
         this.GetFileAddress((UInt32)(end + offset)) == 0)
     {
         throw new Exception("addr out of memory boundaries");
     }
     this.StartAddress = start;
     this.EndAddress   = end;
     this.Offset       = offset;
     this._PatchType   = PatchType.ScrollCode;
 }
Ejemplo n.º 23
0
 public PatchDescriptor(MethodInfo method, PatchAttribute attr)
 {
     patchMethod    = method;
     patchAttribute = attr;
     if (patchAttribute is ReplaceAttribute)
     {
         patchType = PatchType.Replace;
     }
     else if (patchAttribute is PreHookAttribute)
     {
         patchType = PatchType.PreHook;
     }
     else if (patchAttribute is PostHookAttribute)
     {
         patchType = PatchType.PostHook;
     }
     else
     {
         throw new ArgumentException("Unknown PatchAttribute! " + attr, "attr");
     }
 }
Ejemplo n.º 24
0
        public static bool PatchEdiabas(StringBuilder sr, PatchType patchType, int adapterType, string dirName, BluetoothDeviceInfo devInfo, WlanInterface wlanIface, string pin)
        {
            try
            {
                sr.AppendFormat(Resources.Strings.PatchDirectory, dirName);
                if (!PatchFiles(sr, dirName))
                {
                    return(false);
                }
                string configFile = Path.Combine(dirName, ConfigFileName);
                if (!UpdateConfigFile(configFile, adapterType, devInfo, wlanIface, pin))
                {
                    sr.Append("\r\n");
                    sr.Append(Resources.Strings.PatchConfigUpdateFailed);
                    return(false);
                }
                sr.Append("\r\n");
                sr.Append(Resources.Strings.PatchConfigUpdateOk);
                switch (patchType)
                {
                case PatchType.Istad:
                    sr.Append("\r\n");
                    sr.Append(Resources.Strings.PatchInstadInfo);
                    break;

                case PatchType.VasPc:
                    sr.Append("\r\n");
                    sr.Append(Resources.Strings.PatchVaspcInfo);
                    break;
                }
            }
            catch (Exception)
            {
                sr.Append("\r\n");
                sr.Append(Resources.Strings.PatchConfigUpdateFailed);
                return(false);
            }
            return(true);
        }
Ejemplo n.º 25
0
        private void button5_Click(object sender, EventArgs e)
        {
            PatchType PatchType = (PatchType)cbDataFormat.SelectedIndex;

            int PatchSize = PatchManager.PatchTypeLength(PatchType);

            if (PatchSize == 0)
            {
                if (!Common.ReadNumeric(textBox2.Text, ref PatchSize))
                {
                    return;
                }

                if (PatchSize < 0)
                {
                    return;
                }
            }

            uint addr = 0;

            if (Common.ReadHex(txAddress.Text, ref addr))
            {
                Patch DataPatch = new Patch();

                DataPatch.DisplayAs = PatchType;
                DataPatch.Name      = string.Format("Patched {0}", PatchType);
                DataPatch.Module    = "";
                DataPatch.Offset    = addr;

                // TODO: Read original memory at this location
                DataPatch.Original = Nops(PatchSize);
                DataPatch.Patched  = Nops(PatchSize);
                patchMan.Data.Add(DataPatch);

                RefreshPatches();
            }
        }
Ejemplo n.º 26
0
	    public FileHeader(byte[] b, int offset)
        {
		    buf = b;
		    startOffset = offset;
		    changeType = ChangeType.MODIFY; // unless otherwise designated
		    patchType = PatchType.UNIFIED;
	    }
Ejemplo n.º 27
0
        /// <summary>
        ///     パッチの種類を設定する
        /// </summary>
        /// <param name="gameType">ゲームの種類</param>
        private static void SetPatchType(GameType gameType)
        {
            switch (gameType)
            {
                case GameType.Unknown: // 不明
                    _patchType = PatchType.Unknown;
                    AppendLog("PatchType: Unknown\n\n");
                    break;

                case GameType.CrusaderKings:
                    _patchType = PatchType.CrusaderKings;
                    AppendLog("PatchType: Crusader Kings\n\n");
                    break;

                case GameType.EuropaUniversalis2:
                    _patchType = PatchType.EuropaUniversalis2;
                    AppendLog("PatchType: Europa Universalis 2\n\n");
                    break;

                case GameType.ForTheGlory:
                    _patchType = PatchType.ForTheGlory;
                    AppendLog("PatchType: For the Glory\n\n");
                    break;

                case GameType.Victoria:
                    _patchType = PatchType.Victoria;
                    AppendLog("PatchType: Victoria\n\n");
                    break;

                case GameType.HeartsOfIron:
                    _patchType = PatchType.HeartsOfIron;
                    AppendLog("PatchType: Hearts of Iron\n\n");
                    break;

                case GameType.HeartsOfIron2:
                    _patchType = PatchType.HeartsOfIron2;
                    AppendLog("PatchType: Hearts of Iron 2\n\n");
                    break;

                case GameType.ArsenalOfDemocracy:
                    _patchType = PatchType.ArsenalOfDemocracy;
                    AppendLog("PatchType: Arsenal of Democracy\n\n");
                    break;

                case GameType.DarkestHour:
                    _patchType = PatchType.DarkestHour;
                    AppendLog("PatchType: Darkest Hour\n\n");
                    break;

                default:
                    _patchType = PatchType.Unknown;
                    AppendLog("PatchType: Unknown\n\n");
                    break;
            }
        }
Ejemplo n.º 28
0
        /// <summary>
        ///     バージョンを判別する
        /// </summary>
        /// <returns>判別に成功すればtrueを返す</returns>
        private static bool IdentifyGameVersion()
        {
            switch (_patchType)
            {
                case PatchType.HeartsOfIron2:
                case PatchType.ArsenalOfDemocracy:
                case PatchType.DarkestHour:
                    break;

                default:
                    // バージョン判別の必要ないゲームでは何もせずに戻る
                    return true;
            }

            AppendLog("ScanBinary - 特定バイナリを探す\n");
            AppendLog("  \"%XX バージョン文字列\"を探します\n");

            byte[] pattern;
            List<uint> l;
            uint offset;
            switch (_patchType)
            {
                case PatchType.HeartsOfIron2:
                    // Doomsday Armageddon v X.X
                    pattern = new byte[]
                    {
                        0x44, 0x6F, 0x6F, 0x6D, 0x73, 0x64, 0x61, 0x79,
                        0x20, 0x41, 0x72, 0x6D, 0x61, 0x67, 0x65, 0x64,
                        0x64, 0x6F, 0x6E, 0x20, 0x76, 0x20
                    };
                    l = BinaryScan(_data, pattern, 0, (uint) _fileSize);
                    if (l.Count == 0)
                    {
                        // Iron Cross Armageddon X.XX
                        pattern = new byte[]
                        {
                            0x49, 0x72, 0x6F, 0x6E, 0x20, 0x43, 0x72, 0x6F,
                            0x73, 0x73, 0x20, 0x41, 0x72, 0x6D, 0x61, 0x67,
                            0x65, 0x64, 0x64, 0x6F, 0x6E, 0x20
                        };
                        l = BinaryScan(_data, pattern, 0, (uint) _fileSize);
                        if (l.Count == 0)
                        {
                            return false;
                        }
                        offset = l[0] + (uint) pattern.Length;
                        _gameVersion = (_data[offset] - '0') * 100 + (_data[offset + 2] - '0') * 10 +
                                       (_data[offset + 3] - '0');
                    }
                    else
                    {
                        offset = l[0] + (uint) pattern.Length;
                        _gameVersion = (_data[offset] - '0') * 100 + (_data[offset + 2] - '0') * 10;
                    }
                    break;

                case PatchType.ArsenalOfDemocracy:
                    // Arsenal of Democracy X.XX
                    pattern = new byte[]
                    {
                        0x41, 0x72, 0x73, 0x65, 0x6E, 0x61, 0x6C, 0x20,
                        0x6F, 0x66, 0x20, 0x44, 0x65, 0x6D, 0x6F, 0x63,
                        0x72, 0x61, 0x63, 0x79, 0x20
                    };
                    l = BinaryScan(_data, pattern, 0, (uint) _fileSize);
                    if (l.Count == 0)
                    {
                        // Arsenal Of Democracy v X.XX
                        pattern = new byte[]
                        {
                            0x41, 0x72, 0x73, 0x65, 0x6E, 0x61, 0x6C, 0x20,
                            0x4F, 0x66, 0x20, 0x44, 0x65, 0x6D, 0x6F, 0x63,
                            0x72, 0x61, 0x63, 0x79, 0x20, 0x76, 0x20
                        };
                        l = BinaryScan(_data, pattern, 0, (uint) _fileSize);
                        if (l.Count == 0)
                        {
                            return false;
                        }
                    }
                    offset = l[0] + (uint) pattern.Length;
                    _gameVersion = (_data[offset] - '0') * 100 + (_data[offset + 2] - '0') * 10 +
                                   (_data[offset + 3] - '0');
                    break;

                case PatchType.DarkestHour:
                    // Darkest Hour v X.XX
                    pattern = new byte[]
                    {
                        0x44, 0x61, 0x72, 0x6B, 0x65, 0x73, 0x74, 0x20,
                        0x48, 0x6F, 0x75, 0x72, 0x20, 0x76, 0x20
                    };
                    l = BinaryScan(_data, pattern, 0, (uint) _fileSize);
                    if (l.Count == 0)
                    {
                        return false;
                    }
                    offset = l[0] + (uint) pattern.Length;
                    _gameVersion = (_data[offset] - '0') * 100 + (_data[offset + 2] - '0') * 10 +
                                   (_data[offset + 3] - '0');
                    break;

                default:
                    // Doomsday Armageddon v X.X
                    pattern = new byte[]
                    {
                        0x44, 0x6F, 0x6F, 0x6D, 0x73, 0x64, 0x61, 0x79,
                        0x20, 0x41, 0x72, 0x6D, 0x61, 0x67, 0x65, 0x64,
                        0x64, 0x6F, 0x6E, 0x20, 0x76, 0x20
                    };
                    l = BinaryScan(_data, pattern, 0, (uint) _fileSize);
                    if (l.Count == 0)
                    {
                        return false;
                    }
                    offset = l[0] + (uint) pattern.Length;
                    _gameVersion = (_data[offset] - '0') * 100 + (_data[offset + 2] - '0') * 10;
                    break;
            }

            AppendLog("ScanBinary passed\n\n");

            switch (_patchType)
            {
                case PatchType.HeartsOfIron2:
                    if (_gameVersion < 110)
                    {
                        _patchType = PatchType.IronCrossHoI2;
                        AppendLog("PatchType: Iron Cross / Hearts of Iron 2\n\n");
                    }
                    else if (_gameVersion <= 120)
                    {
                        _patchType = PatchType.HeartsOfIron212;
                        AppendLog("PatchType: Hearts of Iron 2 1.2\n\n");
                    }
                    else
                    {
                        _patchType = PatchType.HeartsOfIron2;
                        AppendLog("PatchType: Hearts of Iron 2\n\n");
                    }
                    break;

                case PatchType.ArsenalOfDemocracy:
                    if (_gameVersion <= 104)
                    {
                        _patchType = PatchType.ArsenalOfDemocracy104;
                        AppendLog("PatchType: Arsenal of Democracy 1.04\n\n");
                    }
                    else if (_gameVersion <= 107)
                    {
                        _patchType = PatchType.ArsenalOfDemocracy107;
                        AppendLog("PatchType: Arsenal of Democracy 1.07\n\n");
                    }
                    else if (_gameVersion <= 109)
                    {
                        _patchType = PatchType.ArsenalOfDemocracy109;
                        AppendLog("PatchType: Arsenal of Democracy 1.09\n\n");
                    }
                    else
                    {
                        _patchType = PatchType.ArsenalOfDemocracy;
                        AppendLog("PatchType: Arsenal of Democracy\n\n");
                    }
                    break;

                case PatchType.DarkestHour:
                    if (_gameVersion <= 102)
                    {
                        _patchType = PatchType.DarkestHour102;
                        AppendLog("PatchType: Darkest Hour 1.02\n\n");
                    }
                    else
                    {
                        _patchType = PatchType.DarkestHour;
                        AppendLog("PatchType: Darkest Hour\n\n");
                    }
                    break;
            }

            return true;
        }