八门神器是安卓、iOS、塞班平台上通用的游戏修改工具，可以修改内存中的数值和参数。在游戏运行时，内存和处理器都会对于游戏进行非常复杂的数据交换和变更。因为游戏有很多的数据，例如金钱、HP值、等级、攻击力、防御力、战斗力等数据，尤其是PVE战斗在客户端进行。服务器校验缺失等。而这些数据，就在内存和处理器的各个地址当中，玩家只需要在八门神器中搜索相关的数据值，八门神器就会将搜索出记录此数据的各个地址显示，玩家进行多次的数据变更后再次搜索，到最后就会确定此地址到底是哪一个，然后将此地址的数值进行修改，回到游戏中，相关的数据也会变化，八门神器的原理就如金山游侠、整人专家、游戏修改大师等类型的修改软件，只不过八门神器只可以在智能手机中使用而已。

对于八门神器在修改游戏时发生无法修改或无法保存修改后的数据等情况，是因为游戏本身经过特殊处理。安全整型。主要用来内存存放功能。防止八门神器等外挂篡改。根据外挂机制可以在游戏开发中内存整形的简单加密。也就是真实值A隐藏。内存中值只是A的影子而已。具体原理就是或与运算的巧妙应用。

或运算原理

```java
1.常数A或变量=常数B。变量或常数A=常数B。
常数A：383391203
常数B：34603266
分析：分布转换成二进制得出结论公式
10110110110100001010111100011
&
0X01X00X10X0XXXX0X0X1000XXX10
等于：
00010000100000000000100000010
结论:变量有规律，其中X可以是0或者1
则12个X可以取值个数为：1<<13=8192个数
例如：
?383391203&34867974;
00010000101000000101100000110
?383391203&34867978;
00010000101000000101100001010
?383391203&34867982;
00010000101000000101100001110
```

与运算原理

```java
2.常数A与变量=常数B。变量与常数A=常数B
常数A：383391203
常数B：1459600891
分析：分布转换成二进制得出结论公式
0010110110110100001010111100011
|
10X0XX0XX1XX1X1101X1X0XXXX110XX
等于：
1010110111111111011110111111011
例如：
?383391203|1076739384;
1000000001011011011110100111000
?383391203|1076210840;
1000000001001011010110010011000
?383391203|1076209688;
1000000001001011010100000011000
?383391203|1076210168;
1000000001001011010100111111000
```

得出结论。发散思维。推广应用。

```java
最后结论是把32位整形拆分：每位分解成两个整数表示：算法即可得出参照SaftInt类
XXX0X01X	00X10X0X	XXX0X0X1	000XXX10
010X0XX0	XX1XX1X1	101X1X0X	XXX110XX
拓展:把整数对应位分别去除来
应用推广：
    如何一个整数A可以和另外一个变量互转。
    有了这个依据则可以用于游戏开发中内存整形的简单加密。
    也就是真实值A隐藏。内存中值只是A的影子而已。
```

Gk8SafeInt.cs

```c#
using System.Collections;

/**
 * 安全整型:用主要用来内存存放功能。防止八门神器外挂等
 * @Thinker
 **/
public class Gk8SafeInt
{
	private int m_nInt1;			//内放整型1
	private int m_nInt2;			//内放整型2
	//private int m_nMaskRnd;			//随机掩码
	
	//XXX0X01X	00X10X0X	XXX0X0X1	000XXX10
	//010X0XX0	XX1XX1X1	101X1X0X	XXX110XX
	//取对应位
	static int g_nMaskBit1=383391203;
	static int g_nMaskBit2=-383391204;
	//合并
	static int g_nUionBit1=1076209688;
	static int g_nUionBit2=34603266;

public override string ToString ()
	{
		return GetInt().ToString ();
	}
	
	private void MakeInt(int nValue)
	{
		//m_nMaskRnd=383391203;
		m_nInt1=g_nMaskBit1&nValue|g_nUionBit1;
		m_nInt2=g_nMaskBit2&nValue|g_nUionBit2;
	}

private int GetInt()
	{
		return (m_nInt1&g_nMaskBit1)+(m_nInt2&g_nMaskBit2);
	}

public Gk8SafeInt()
	{
		MakeInt(0);
	}
	
	public Gk8SafeInt(int nValue)
	{
		MakeInt(nValue);
	}

public static explicit operator Gk8SafeInt(int nValue)
	{
		return new Gk8SafeInt(nValue);
	}
	public static implicit operator int(Gk8SafeInt iSafeInt)
	{
		return iSafeInt.GetInt();
	}
	//重载加减乘除
	public static Gk8SafeInt operator + (Gk8SafeInt iSafeInt,int nValue)
	{
		int n=iSafeInt.GetInt();
		n+=nValue;
		return  new Gk8SafeInt(n);
	}
	public static Gk8SafeInt operator - (Gk8SafeInt iSafeInt,int nValue)
	{
		int n=iSafeInt.GetInt();
		n-=nValue;
		return  new Gk8SafeInt(n);
	}
	public static Gk8SafeInt operator * (Gk8SafeInt iSafeInt,int nValue)
	{
		int n=iSafeInt.GetInt();
		n*=nValue;
		return  new Gk8SafeInt(n);
	}
	public static Gk8SafeInt operator / (Gk8SafeInt iSafeInt,int nValue)
	{
		int n=iSafeInt.GetInt();
		n/=nValue;
		return  new Gk8SafeInt(n);
	}
	//重载比较操作
	public static bool operator < (Gk8SafeInt iSafeInt,int nValue)
	{
        if(iSafeInt.GetInt()< nValue) return true;
		return false;
	}
	public static bool operator <= (Gk8SafeInt iSafeInt,int nValue)
	{
        if(iSafeInt.GetInt()<= nValue) return true;
		return false;
	}
	public static bool operator == (Gk8SafeInt iSafeInt,int nValue)
	{
		if(iSafeInt.GetInt()==nValue) return true;
		return false;
	}
	public static bool operator != (Gk8SafeInt iSafeInt,int nValue)
	{
        if(iSafeInt.GetInt()!=nValue) return true;
		return false;
	}
	public static bool operator >= (Gk8SafeInt iSafeInt,int nValue)
	{
		if(iSafeInt.GetInt()>=nValue) return true;
		return false;
	}
	public static bool operator > (Gk8SafeInt iSafeInt,int nValue)
	{
        if(iSafeInt.GetInt()>nValue) return true;
		return false;
	}
}
```

ITPub博客

或与运算和安全整数(数的影子)

最新文章