private LayerMask LayerMaskField( string label, LayerMask layerMask) {
		List<string> layers = new List<string>();
		List<int> layerNumbers = new List<int>();
		
		for (int i = 0; i < 32; i++) {
			string layerName = LayerMask.LayerToName(i);
			if (layerName != "") {
				layers.Add(layerName);
				layerNumbers.Add(i);
			}
		}
		int maskWithoutEmpty = 0;
		for (int i = 0; i < layerNumbers.Count; i++) {
			if (((1 << layerNumbers[i]) & layerMask.value) > 0)
				maskWithoutEmpty |= (1 << i);
		}
		maskWithoutEmpty = EditorGUILayout.MaskField( label, maskWithoutEmpty, layers.ToArray());
		int mask = 0;
		for (int i = 0; i < layerNumbers.Count; i++) {
			if ((maskWithoutEmpty & (1 << i)) > 0)
				mask |= (1 << layerNumbers[i]);
		}
		layerMask.value = mask;
		return layerMask;
	}

 void Awake()
 {
     pubbleLayerMask = 1 << (LayerMask.NameToLayer("PlayObject"));//实例化mask到cube这个自定义的层级之上。
     //此处手动修改layer ，因为NGUI的layer 默认初始化为UI,一定要写在Awake函数
     gameObject.layer = ConstantValue.PubbleMaskLayer;
     defaultLayer = 1 << (LayerMask.NameToLayer("Default"));
 }

	 void HorizontalCollisions (ref Vector3 velocity, LayerMask cMask) {
		float dirX 		= Mathf.Sign (velocity.x);																		        // direction of velocity in the x component
		float rayLength = Mathf.Abs (velocity.x) + skinWidth;															        // length of raycast ray, equal to velocity in the x component
		for (int i = 0; i < horRayCount; i++) { 
			Vector2 	 rayOrigin	 = (dirX == -1)?rayCastOrigins.botLeft:rayCastOrigins.botRight;						        // checks direction of velocity in the x component and assigns an origin respectively
			rayOrigin 				+= Vector2.up * (horRaySpacing * i);												        // adds origin for each ray along boundry 
			RaycastHit2D hit		 = Physics2D.Raycast (rayOrigin, Vector2.right * dirX, rayLength, cMask);	        		// creates ray at each ray origin in the direction of velocity with the length of velocity while ignoring objects not in the layer mask collisionMask
			Debug.DrawRay(rayOrigin, Vector2.right * dirX * rayLength, Color.red);
			if (hit) {																									        // if ray collides with object in layer mask collisionMask
				float slopeAngle = Vector2.Angle(hit.normal, Vector2.up);
				if (i == 0 && slopeAngle <= maxClimbAngle){
					float distanceToSlopeStart = 0;                                                                             // temp variable for distance to slope
					if (slopeAngle != collisionsInfo.slopeAngleOld) {                                                           // checks change in slope
						distanceToSlopeStart = hit.distance - skinWidth;                                                        // assigns distance minus skin width to temp variable
						velocity.x 			-= distanceToSlopeStart * dirX;                                                     // subtracts temp value from velocity in the x axis with respect to direction
					}
					ClimbSlope (ref velocity, slopeAngle);                                                                      // calls ClimbSlope () method which checks collisions on slopes
					velocity.x += distanceToSlopeStart * dirX;                                                                  // adds temp value to velocity in the x axis with respect to direction
				}
				if (!collisionsInfo.climbingSlope || slopeAngle > maxClimbAngle){
				velocity.x  = (hit.distance - skinWidth) * dirX;												                // if hit assigns distance from boundry to object collided to velocity in the x component
				rayLength  	= hit.distance;																	                    // assigns distance from boundry to object collided to rayLegth, as to not get confused if not all rays are colliding with same object distance
				if (collisionsInfo.climbingSlope){
					velocity.y = Mathf.Tan (collisionsInfo.slopeAngle * Mathf.Deg2Rad) * Mathf.Abs(velocity.x);                 // Trig! 
				}
				collisionsInfo.left  = dirX == -1;                                                                      
				collisionsInfo.right = dirX == 1;
				} 
			}		
		}
	}

 public NetBehaviour(GameObject gameObject, LayerMask interActable)
 {
     this.gameObject = gameObject;
     this.range = 2.5f;
     this.interActable = interActable;
     lastTimeFire = 0;
 }

 public void ChangeObjectLayermask(LayerMask newMask)
 {
     foreach (Transform trans in gameObject.GetComponentsInChildren<Transform>(true))
     {
         trans.gameObject.layer = (int)Mathf.Log(newMask.value, 2);
     }
 }

 void Start()
 {
     zeroMask = LayerMask.NameToLayer("ZeroView");
     oneMask = LayerMask.NameToLayer("OneView");
     zeroMaskBack = LayerMask.NameToLayer ("ZeroViewBack");
     oneMaskBack = LayerMask.NameToLayer ("OneViewBack");
 }

	public void Initialize (LayerMask terrainMask, LayerMask objectMask, Transform foliageContainer, float newYearLength)
	{
		terrainLayerMask = terrainMask;
		objectLayerMask = objectMask;
		container = foliageContainer;
		yearLength = newYearLength;
	}

    protected override void Awake()
    {
        base.Awake();
        _controller = GetComponent<CharacterController>();

        _groundLayers = 1 << LayerMask.NameToLayer("Environment") | 1 << LayerMask.NameToLayer("StickingWall");
    }

 // Use this for initialization
 void Start()
 {
     drag = GetComponent<DragableBlock>();
     blocks = LayerMask.GetMask("Blocks");
     rotBy90 = Quaternion.Euler(0, 90, 0);
     rotByNeg90 = Quaternion.Euler(0, -90, 0);
 }

	private void Setup(Vector2 heading, LayerMask layer)
	{
		Heading = heading;
		Layer = layer;

		StartCoroutine(Timer());
	}

    public override float ChanceToHit(GameObject target)
    {
        if (Vector3.Distance(this.transform.position, target.transform.position) > range)
        {
            //out of range
            return 0;
        }

        Ray ray = new Ray(this.transform.position, target.transform.position - this.transform.position);
        RaycastHit hit;
        LayerMask layerMask = new LayerMask();
        layerMask = layerMask << LayerMask.NameToLayer("Avoid");

        if (Physics.Raycast(ray, out hit, range, layerMask))
        {
            if (hit.collider.gameObject != target)
            {
                //not aimed at target
                return 0;
            }
        }

        Vector3 direction = target.transform.position - this.transform.position;
        direction.Normalize();
        float chance = Vector3.Dot(this.transform.forward, direction);

        return chance;
    }

  public void Reset()
    {
        Awake();

        // UnityChan2DController
        maxSpeed = 10f;
        jumpPower = 1000;
        backwardForce = new Vector2(-4.5f, 5.4f);
        whatIsGround = 1 << LayerMask.NameToLayer("Ground");

        // Transform
        transform.localScale = new Vector3(1, 1, 1);

        // Rigidbody2D
        m_rigidbody2D.gravityScale = 3.5f;
        m_rigidbody2D.fixedAngle = true;

        // BoxCollider2D
        m_boxcollier2D.size = new Vector2(1, 2.5f);
        m_boxcollier2D.offset = new Vector2(0, -0.25f);

        // Animator
        m_animator.applyRootMotion = false;

		speedlevel = 1;
		gameflg = true;
		bonusflg = false;
		jumpconstraint = 0;
		bonusJump = 0;
		GameSC = 0;
		Score.bonusgauge = 0;
		gamed = true;
    }

 public void SetWallAvoidanceProperties(float strengthMultiplier, float avoidanceForce, float maxViewDistance, LayerMask obstacleLayer)
 {
     wallAvoidance.strengthMultiplier = strengthMultiplier;
     wallAvoidance.avoidanceForce = avoidanceForce;
     wallAvoidance.maxViewDistance = maxViewDistance;
     wallAvoidance.obstacleLayer = obstacleLayer;
 }

 void Awake()
 {
     playerController = GameObject.FindGameObjectWithTag ("Player").GetComponent<PlayerController> ();
     ShotSpawnPos = GameObject.FindGameObjectWithTag("ShotSpawn");
     ShootableMask = LayerMask.GetMask ("Shootable"); // get a reference to the shootable mask
     ShotLine = ShotSpawnPos.GetComponent<LineRenderer> ();   // get reference to the line AKA bullet
 }

	void Awake ()
	{

		tipsBlockLayerMask = 1 << gameObject.layer;

		maskedLayer = 1 << ISSCLayerManager.blockLayer;
	}

 public void setHoming(float turn, float maxDist, float maxAngle, LayerMask voituresLayer)
 {
     this.turn = turn;
     this.maxDistance = maxDist;
     this.maxAngle = maxAngle;
     this.voituresLayer = voituresLayer;
 }

 public static Transform WithinSight(Transform transform, Vector3 positionOffset, float fieldOfViewAngle, float viewDistance, LayerMask objectLayerMask)
 {
     Transform objectFound = null;
     var hitColliders = Physics.OverlapSphere(transform.position, viewDistance, objectLayerMask);
     if (hitColliders != null)
     {
         float minAngle = Mathf.Infinity;
         for (int i = 0; i < hitColliders.Length; ++i)
         {
             float angle;
             Transform obj;
             // Call the WithinSight function to determine if this specific object is within sight
             if ((obj = WithinSight(transform, positionOffset, fieldOfViewAngle, viewDistance, hitColliders[i].transform, false, out angle)) != null)
             {
                 // This object is within sight. Set it to the objectFound GameObject if the angle is less than any of the other objects
                 if (angle < minAngle)
                 {
                     minAngle = angle;
                     objectFound = obj;
                 }
             }
         }
     }
     return objectFound;
 }

	void VerticalCollisions(ref Vector3 velocity, LayerMask cMask){
		float dirY 		= Mathf.Sign (velocity.y);																		        // direction of velocity in the y component
		float rayLength = Mathf.Abs(velocity.y) + skinWidth;															        // length of raycast ray, equal to velocity in the y component
		for (int i = 0; i < vertRayCount; i++) {
			Vector2 	 rayOrigin = (dirY == -1)?rayCastOrigins.botLeft:rayCastOrigins.topLeft;						        // checks direction of velocity in the y component and assigns an origin respectively 
			rayOrigin 	     	  += Vector2.right * (vertRaySpacing * i + velocity.x);									        // adds origin for each ray along boundry 
			RaycastHit2D hit 	   = Physics2D.Raycast(rayOrigin,Vector2.up * dirY,rayLength, cMask);			       		    // creates ray at each ray origin in the direction of velocity with the length of velocity while ignoring objects not in the layer mask collisionMask
			Debug.DrawRay(rayOrigin, Vector2.up * dirY * rayLength,Color.red);
			if (hit) {																									        // if ray collides with object in layer mask collisionMask
				velocity.y 	= (hit.distance - skinWidth) * dirY;												                // if hit assigns distance from boundry to object collided to velocity in the y component
				rayLength   = hit.distance;																	                    // assigns distance from boundry to object collided to rayLegth, as to not get confused if not all rays are colliding with same object distance
				if (collisionsInfo.climbingSlope){
					velocity.x = velocity.y / Mathf.Tan (collisionsInfo.slopeAngle * Mathf.Deg2Rad) * Mathf.Sign(velocity.x);   // more Trig!
				}
				collisionsInfo.below = dirY == -1;
				collisionsInfo.above = dirY == 1;
				if( timeStamp <= Time.time) {                                                                                   
					timeStamp = Time.time + jumpCoolDown;
				}
			}
		}
		if (collisionsInfo.climbingSlope){
			float directionX    = Mathf.Sign (velocity.x);
			rayLength           = Mathf.Abs (velocity.x) + skinWidth;
			Vector2 rayOrigin   = ((directionX == -1)?rayCastOrigins.botLeft:rayCastOrigins.botRight) + Vector2.up * velocity.y;
			RaycastHit2D hit    = Physics2D.Raycast(rayOrigin, Vector2.right * directionX, rayLength, cMask);
			if (hit) {
				float slopeAngle = Vector2.Angle (hit.normal, Vector2.up);
				if (slopeAngle  != collisionsInfo.slopeAngle){
					velocity.x   = (hit.distance - skinWidth) * directionX;
					collisionsInfo.slopeAngle = slopeAngle;
				}
			}			
		}
	}		

	public void setLayerMask(){
		#if UNITY_EDITOR
		if(!Application.isPlaying && Layer.value <= 0){
			Layer = 1<< LayerMask.NameToLayer("ShadowLayer");
		}
		#endif
	}

 void Start()
 {
     navAgent = GetComponent<NavMeshAgent> ();
     myTransform = transform;
     raycastLayer = 1 << LayerMask.NameToLayer ("Player");
     StartCoroutine (DoCheck ());
 }