多副本
	1个副本，假设我们存储2个备份副本,那么总共就3个副本了,10个副本数据就是30个副本要存储，
	这样我们同一个数据也只是能容忍丢掉3次。
EC
	1个副本，10个副本数据我们如果n=10, m=4, 只需要14个副本。这样我们可以容忍你丢掉任意3个副本。

Package		Version			Notes
GNU Make	3.79, 3.79.1	Makefile/build processor
GCC			>=4.8.0			C/C++ compiler1
python		>=2.7			Automated test suite2
zlib		>=1.2.3.4		Compression library3

void InitResolution() {
    if (ClientConfig.PLATFORM != PlatformType.Android) {
        return;
    }

    int width = Screen.currentResolution.width;
    int height = Screen.currentResolution.height;
    int targetWidth = 960;
    int targetHeight = 640;

    if (width <= targetWidth || height <= targetHeight) 
        return;

    float targetRatio = targetWidth / (float)targetHeight;
    float currentRatio = width / (float)height;

    if (targetRatio < currentRatio) {
        targetWidth = (int)Mathf.CeilToInt(targetHeight * currentRatio);
    } else if (targetRatio > currentRatio) {
        targetHeight = (int)Mathf.FloorToInt(targetWidth / currentRatio);
    }
    Screen.SetResolution(targetWidth, targetHeight, true);
}

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public enum OBJ_TYPE{
	MON = 1,
	PET = 2,
	PLAYER = 3
}

public enum MON_TYPE{
	NORMAL = 1,
	LEGEND = 2
}

public enum PET_TYPE{
	NORMAL = 1,
	LEGEND = 2
}

public enum PLAYER_TYPE{
	NORMAL = 1,
	LEGEND = 2
}

abstract class Ab_ObjFactory{
	public abstract List<Ab_Obj> Create();
}

abstract class Ab_Obj{

	public abstract void Init();

	protected OBJ_TYPE _type = 0;
	public abstract OBJ_TYPE Type {
		get;
		set;
	}

	public static T Create<T>() where T : Ab_Obj, new(){
		T t = new T ();
		return t;
	}

}

abstract class Ab_ObjMon : Ab_Obj{
	public override OBJ_TYPE Type{
		get{ 
			return OBJ_TYPE.MON;
		}
		set{ 
			_type = OBJ_TYPE.MON;
		}
	}

	protected MON_TYPE _subType;
	public abstract MON_TYPE SubType{
		get;
		set;
	}
}

abstract class Ab_ObjPet : Ab_Obj{
	public override OBJ_TYPE Type{
		get{ 
			return OBJ_TYPE.PET;
		}
		set{ 
			_type = OBJ_TYPE.PET;
		}
	}

	protected PET_TYPE _subType;
	public abstract PET_TYPE SubType{
		get;
		set;
	}


}

abstract class Ab_ObjPlayer : Ab_Obj{
	public override OBJ_TYPE Type{
		get{ 
			return OBJ_TYPE.PLAYER;
		}
		set{ 
			_type = OBJ_TYPE.PLAYER;
		}
	}

	protected PLAYER_TYPE _subType;
	public abstract PLAYER_TYPE SubType{
		get;
		set;
	}
}


class ObjNormalMon : Ab_ObjMon{
	public override MON_TYPE SubType{
		get{ 
			return MON_TYPE.NORMAL;
		}
		set{ 
			_subType = MON_TYPE.NORMAL;
		}
	}
	public override void Init(){
		Debug.Log("创建对象 NormalMon");
	}

}

class ObjLegendMon : Ab_ObjMon{
	public override MON_TYPE SubType{
		get{ 
			return MON_TYPE.LEGEND;
		}
		set{ 
			_subType = MON_TYPE.LEGEND;
		}
	}
	public override void Init(){
		Debug.Log ("创建对象 LegendMon");
	}
}

class ObjNormalPet : Ab_ObjPet{
	public override PET_TYPE SubType{
		get{ 
			return PET_TYPE.NORMAL;
		}
		set{ 
			_subType = PET_TYPE.NORMAL;
		}
	}
	public override void Init(){
		Debug.Log("创建对象 NormalPet");
	}
}

class ObjLegendPet : Ab_ObjPet{
	public override PET_TYPE SubType{
		get{ 
			return PET_TYPE.LEGEND;
		}
		set{ 
			_subType = PET_TYPE.LEGEND;
		}
	}

	public override void Init(){
		Debug.Log("创建对象 LegendPet");
	}
}

class ObjNormalPlayer : Ab_ObjPlayer{
	public override PLAYER_TYPE SubType{
		get{ 
			return PLAYER_TYPE.NORMAL;
		}
		set{ 
			_subType = PLAYER_TYPE.NORMAL;
		}
	}

	public override void Init(){
		Debug.Log("创建对象 NormalPlayer");
	}
}

class ObjLegendPlayer : Ab_ObjPlayer{
	public override PLAYER_TYPE SubType{
		get{ 
			return PLAYER_TYPE.LEGEND;
		}
		set{ 
			_subType = PLAYER_TYPE.LEGEND;
		}
	}

	public override void Init(){
		Debug.Log ("创建对象 LegendPlayer");
	}
}


class DungeonAFactory : Ab_ObjFactory{
	public override List<Ab_Obj>  Create(){
		List<Ab_Obj> objList = new List<Ab_Obj> ();
		objList.AddRange( CreateMon ());
		objList.AddRange( CreatePet ());
		return objList;
	}

	public List<Ab_Obj> CreateMon(){
		List<Ab_Obj> objList = new List<Ab_Obj> ();
		ObjNormalMon normalMon = Ab_Obj.Create<ObjNormalMon> ();
		normalMon.Init ();
		objList.Add (normalMon);
		ObjLegendMon legendMon = Ab_Obj.Create<ObjLegendMon> ();
		legendMon.Init ();
		objList.Add (legendMon);
		return objList;
	}

	public List<Ab_Obj> CreatePet(){
		List<Ab_Obj> objList = new List<Ab_Obj> ();
		ObjNormalPet normalPet = Ab_Obj.Create<ObjNormalPet>();
		normalPet.Init ();
		objList.Add (normalPet);
		ObjLegendPet legendPet = Ab_Obj.Create<ObjLegendPet> ();
		legendPet.Init ();
		objList.Add (legendPet);
		return objList;
	}
}

class DungeonBFactory : Ab_ObjFactory{
	public override List<Ab_Obj>  Create(){
		List<Ab_Obj> objList = new List<Ab_Obj> ();
		objList.AddRange( CreateMon ());
		objList.AddRange( CreatePet ());
		return objList;
	}

	public List<Ab_Obj> CreateMon(){
		List<Ab_Obj> objList = new List<Ab_Obj> ();
		ObjLegendMon legendAMon = Ab_Obj.Create<ObjLegendMon> ();
		legendAMon.Init ();
		objList.Add (legendAMon);
		ObjLegendMon legendBMon = Ab_Obj.Create<ObjLegendMon> ();
		legendBMon.Init ();
		objList.Add (legendBMon);
		return objList;
	}

	public List<Ab_Obj> CreatePet(){
		List<Ab_Obj> objList = new List<Ab_Obj> ();
		ObjLegendPet legendAPet = Ab_Obj.Create<ObjLegendPet> ();
		legendAPet.Init ();
		objList.Add (legendAPet);
		ObjLegendPet legendBPet = Ab_Obj.Create<ObjLegendPet> ();
		legendBPet.Init ();
		objList.Add (legendBPet);
		return objList;
	}
}

class ArenaFactory : Ab_ObjFactory{

	public override List<Ab_Obj>  Create(){
		List<Ab_Obj> objList = new List<Ab_Obj> ();
		objList.AddRange( CreatePlayer ());
		return objList;
	}

	public List<Ab_Obj> CreatePlayer(){
		List<Ab_Obj> objList = new List<Ab_Obj> ();
		ObjNormalPlayer normalAPet = Ab_Obj.Create<ObjNormalPlayer> ();
		normalAPet.Init ();
		objList.Add (normalAPet);
		ObjLegendPlayer legendBPet = Ab_Obj.Create<ObjLegendPlayer> ();
		legendBPet.Init ();
		objList.Add (legendBPet);
		return objList;
	}
}

public class main : MonoBehaviour {

	void Awake() {
		DungeonAFactory normalMonFactory = new DungeonAFactory();
		DungeonBFactory normalPetFactory = new DungeonBFactory();
		ArenaFactory arenaFactory = new ArenaFactory ();
		normalMonFactory.Create ();
		normalPetFactory.Create ();
		arenaFactory.Create ();
	}

	// Use this for initialization
	void Start () {
		
	}
	
	// Update is called once per frame
	void Update () {
	
	}




}

%% check if connecting node is allowed to connect with allow-node-scheme
is_allowed(#hs_data{other_node = Node, 
		    allowed = Allowed} = HSData) ->
    case lists:member(Node, Allowed) of
	false when Allowed =/= [] ->
	    send_status(HSData, not_allowed),
	    error_msg("** Connection attempt from "
		      "disallowed node ~w ** ~n", [Node]),
	    ?shutdown(Node);
	_ -> true
    end.

%% wait for challenge response after send_challenge
recv_challenge_reply(#hs_data{socket = Socket, 
			      other_node = NodeB,
			      f_recv = FRecv}, 
		     ChallengeA, Cookie) ->
    case FRecv(Socket, 0, infinity) of
	{ok,[$r,CB3,CB2,CB1,CB0 | SumB]} when length(SumB) =:= 16 ->
	    SumA = gen_digest(ChallengeA, Cookie),
	    ChallengeB = ?u32(CB3,CB2,CB1,CB0),
	    ?trace("recv_reply: challenge=~w digest=~p\n",
		   [ChallengeB,SumB]),
	    ?trace("sum = ~p\n", [SumA]),
	    case list_to_binary(SumB) of
		SumA ->
		    ChallengeB;
		_ ->
		    error_msg("** Connection attempt from "
			      "disallowed node ~w ** ~n", [NodeB]),
		    ?shutdown(NodeB)
	    end;
	_ ->
	    ?shutdown(no_node)
    end.

gen_challenge() ->
    A = erlang:phash2([erlang:node()]),
    B = erlang:monotonic_time(),
    C = erlang:unique_integer(),
    {D,_}   = erlang:statistics(reductions),
    {E,_}   = erlang:statistics(runtime),
    {F,_}   = erlang:statistics(wall_clock),
    {G,H,_} = erlang:statistics(garbage_collection),
    %% A(8) B(16) C(16)
    %% D(16),E(8), F(16) G(8) H(16)
    ( ((A bsl 24) + (E bsl 16) + (G bsl 8) + F) bxor
      (B + (C bsl 16)) bxor 
      (D + (H bsl 16)) ) band 16#ffffffff.