public void OnTouchGate(Creature creature, Prop gate)
	{
		if (gate.State != "closed")
			return;

		var canOpen = creature.Keywords.Has("g1_36") || creature.Titles.IsUsable(BreakerTitle);
		var saturday = (ErinnTime.Now.Month == ErinnMonth.Samhain || IsEnabled("AllWeekBreaker"));

		if (!canOpen)
		{
			Send.Notice(creature, Localization.Get("You are unable to open the gate."));
		}
		else if (!saturday)
		{
			Send.Notice(creature, Localization.Get("The gate can only be opened on Samhain."));
		}
		else
		{
			creature.Titles.Enable(BreakerTitle);

			gate.SetState("open");

			var portal = gate.Region.GetProp(a => a.Info.Id == GatePortalPropId);
			portal.Extensions.Add(new ConfirmationPropExtension("portal(45360425219915779)", L("Would you like to go to the world across the Sealed door?")));
		}
	}

 /// <summary>
 /// Release the current prop.
 /// </summary>
 /// <returns>A reference to the released prop.</returns>
 public Prop Release()
 {
     Prop temp = this.CurrentProp;
     this.CurrentProp = null;
     this.current = null;
     return temp;
 }

 public bool collidesWithProp(Prop prop,Rectangle rect)
 {
     if(prop.hitBox.Intersects(rect)){
         return true;
     }
     return false;
 }

        void FixedUpdate()
        {
            fixedUpdateCalled = true;

            if (currentProp == lastProp) return;

            // Dropping current prop
            if (currentProp == null) {
                puppetMaster.RemoveMuscleRecursive(lastProp.muscle, true);
                lastProp.Drop();
            }

            // Picking up to an empty slot
            if (lastProp == null) {
                AttachProp(currentProp);
            }

            // Switching props
            if (lastProp != null && currentProp != null) {
                puppetMaster.RemoveMuscleRecursive(lastProp.muscle, true);
                AttachProp(currentProp);
            }

            lastProp = currentProp;
        }

        //---------------------------------------------------------------------
        public override void defAllProp(Dictionary<string, string> map_param)
        {
            EffectMgr = new EffectMgr();

            mPropIsBot = defProp<bool>(map_param, "IsBot", false);
            mPropAccountId = defProp<string>(map_param, "AccountId", "");
            mPropAccountName = defProp<string>(map_param, "AccountName", "");
            mPropActorId = defProp<ulong>(map_param, "ActorId", 0);
            mPropNickName = defProp<string>(map_param, "NickName", "");
            mPropIcon = defProp<string>(map_param, "Icon", "");
            mPropIpAddress = defProp<string>(map_param, "IpAddress", "");
            mPropGender = defProp<bool>(map_param, "Gender", false);
            mPropIndividualSignature = defProp<string>(map_param, "IndividualSignature", "这家伙很懒，什么也没留下！");
            mPropLevel = defProp<int>(map_param, "Level", 1);
            mPropExperience = defProp<int>(map_param, "Experience", 0);
            PropGold = defProp<int>(map_param, "Gold", 100);
            mPropProfileSkinTableId = defProp<int>(map_param, "ProfileSkinTableId", 1);
            mPropIsVIP = defProp<bool>(map_param, "IsVIP", false);
            mPropVIPDataTime = defProp<DateTime>(map_param, "VIPDataTime", DateTime.Now);
            mPropVIPPoint = defProp<int>(map_param, "VIPPoint", 0);
            mPropGameTotal = defProp<int>(map_param, "GameTotal", 0);
            mPropGameWin = defProp<int>(map_param, "GameWin", 0);
            mPropJoinDateTime = defProp<DateTime>(map_param, "JoinDataTime", DateTime.Now);
            mPropLastOnlineDateTime = defProp<DateTime>(map_param, "LastOnlineDateTime", DateTime.Now);
            mPropIsAFK = defProp<bool>(map_param, "IsAFK", false);
        }

    private Prop CreatePropInfo(FileInfo file)
    {
        string[] cfgData = File.ReadAllLines(file.FullName);

        if (cfgData == null || cfgData.Length == 0)
        {
            Debug.Log("Config data for prop '" + file.Directory.Name + "' is null or has zero length");
            return null;
        }

        Prop newProp = new Prop(file.DirectoryName, file.Directory.Name);

        foreach (string cfgLine in cfgData)
        {
            string cfg = cfgLine.Trim(charTrim).ToLower();

            if (cfg.StartsWith("proxy"))
            {
                Proxy newProxy = CreateProxyInfo(file.Directory.Name, cfg);

                if (newProxy != null)
                    newProp.proxies.Add(newProxy);
            }
        }

        if (newProp.proxies.Count == 0)
        {
            Debug.Log("Config data for prop '" + file.Directory.Name + "' contains no usable proxies and is therefore invalid");
            return null;
        }

        return newProp;
    }

        public Prop<string> mPropPrefab; // Prefab

        #endregion Fields

        #region Methods

        //---------------------------------------------------------------------
        public override void defAllProp(Dictionary<string, string> map_param)
        {
            mPropPlayerTableId = defProp<int>(map_param, "PlayerTableId", 1);
            mPropNickName = defProp<string>(map_param, "NickName", "");
            mPropIcon = defProp<string>(map_param, "Icon", "");
            mPropPrefab = defProp<string>(map_param, "Prefab", "");
            mPropLevel = defProp<int>(map_param, "Level", 1);
        }

        public static Prop CreateWoodWall()
        {
            Prop woodWall = new Prop("wood_wall_bmp");
            woodWall.Passable = false;
            woodWall.Durability = 50;

            return woodWall;
        }

        public void PropMatches_TakesSizeIntoAccount()
        {
            var prop1 = new Prop { ColumnName = "Col", SqlDbType = SqlDbType.VarChar, Size = "100" };
            var prop2 = new Prop { ColumnName = "Col", SqlDbType = SqlDbType.VarChar, Size = "101" };

            var matches = prop1.Matches(prop2);

            Assert.IsFalse(matches);
        }

        public static DestroyPropEvent CreateDestroyPropEvent(Prop nProp)
        {
            DestroyPropEvent dEvent = new DestroyPropEvent(nProp);

            dEvent.CreateTime = Game.TurnsPassed;
            dEvent.ActivateTime = Game.TurnsPassed + 0;

            return dEvent;
        }

    public override bool Check(Creature creature, Prop prop)
    {
        return false;

        // Wand
        if (creature.RightHand != null && creature.RightHand.Info.Id >= 40038 && creature.RightHand.Info.Id <= 40041)
            return true;

        return false;
    }

        public static AttackPropEvent CreateAttackPropEvent(Creature nAtt, Prop nDef)
        {
            AttackPropEvent aEvent = new AttackPropEvent(nAtt, nDef);

            aEvent.CreateTime = Game.TurnsPassed;
            aEvent.ActivateTime = Game.TurnsPassed + 1;

            nAtt.State = Creature.EntityState.BUSY;

            return aEvent;
        }

    /// <summary>
    /// Attach the given prop. If a prop already exists, it is replaced.
    /// </summary>
    public void Attach(Prop prop)
    {
        this.CurrentProp = prop;
        this.current = this.transform;

        foreach (PropAttachment attachment in this.Attachments)
        {
            if (prop.PropType == attachment.PropType)
                this.current = attachment.SnapPoint;
        }
    }

	public override void OnPropEvent(Puzzle puzzle, Prop prop)
	{
		var chest = prop as Chest;
		if (chest != null && chest.Name == "KeyChest" && !puzzle.Get("ChestOpen"))
		{
			puzzle.Set("ChestOpen", true);

			var chestPlace = puzzle.GetPlace("ChestPlace");
			chestPlace.CloseAllDoors();
			chestPlace.SpawnSingleMob("SingleMob1");
		}
	}

        private void AttachProp(Prop prop)
        {
            prop.transform.position = transform.position;
            prop.transform.rotation = transform.rotation;

            prop.PickUp(this);
            puppetMaster.AddMuscle(prop.muscle, prop.transform, connectTo, transform, prop.muscleProps);

            if (prop.additionalPin != null && prop.additionalPinTarget != null) {
                puppetMaster.AddMuscle(prop.additionalPin, prop.additionalPinTarget, prop.muscle.GetComponent<Rigidbody>(), prop.transform, new Muscle.Props(prop.additionalPinWeight, 0f, 0f, 0f, false, Muscle.Group.Prop));
            }
        }

        public Prop<int> PropGold; // 金币

        #endregion Fields

        #region Methods

        //---------------------------------------------------------------------
        public override void defAllProp(Dictionary<string, string> map_param)
        {
            PropActorIdInDesktop = defProp<byte>(map_param, "PropActorIdInDesktop", 0, false);
            mPropActorId = defProp<ulong>(map_param, "ActorId", 0, false);
            mPropIsBot = defProp<bool>(map_param, "IsBot", false);
            mPropNickName = defProp<string>(map_param, "NickName", "");
            mPropIcon = defProp<string>(map_param, "Icon", "");
            mPropIpAddress = defProp<string>(map_param, "IpAddress", "");
            PropGold = defProp<int>(map_param, "Gold", 0);
            mPropCurrentGiftEtGuid = defProp<string>(map_param, "CurrentGiftEtGuid", "");
            mPropWaitWhileTime = defProp<float>(map_param, "WaitWhileTime", 60f);
        }

	public override void OnPropEvent(Puzzle puzzle, Prop prop)
	{
		var Switch = prop as Switch;
		if (Switch == null)
			return;

		if (puzzle.Get("activated"))
			return;

		var lockedPlace = puzzle.GetPlace("LockedPlace");
		lockedPlace.Open();

		puzzle.Set("activated", true);
	}

	private void SpawnGate(Dungeon dungeon)
	{
		var region = dungeon.Regions.Last();
		var endLocation = dungeon.GetEndRoomCenter();
		var direction = MabiMath.DirectionToRadian(0, -1);

		var gate = new Prop(GatePropId, endLocation.RegionId, endLocation.X, endLocation.Y, direction);
		gate.Info.Color2 = 0xffffffff;
		gate.Behavior = OnTouchGate;
		region.AddProp(gate);

		var portal = new Prop(GatePortalPropId, endLocation.RegionId, endLocation.X, endLocation.Y, direction);
		portal.Behavior = OnTouchPortal;
		region.AddProp(portal);
	}

	private void OnOrbHit(Creature creature, Prop prop)
	{
		if (prop.State == "off")
		{
			var hits = prop.Vars.Temp.Get("orbHit", 0) + 1;
			prop.Vars.Temp["orbHit"] = hits;

			if (hits == OrbHits)
			{
				Send.Notice(creature, L("You broke the seal and received the Black Orb Fragment!\nCollect all four to receive the Black Orb."));

				prop.SetState("on");
				new Item(FragmentId).Drop(prop.Region, prop.GetPosition(), 50);
			}
		}
	}

	public override void OnPropEvent(Puzzle puzzle, Prop prop)
	{
		var chest = prop as LockedChest;
		if (chest == null || puzzle.Get(chest.Name + "Open") || !chest.IsOpen)
			return;

		puzzle.Set(chest.Name + "Open", true);

		if (puzzle.Get(chest.Name + "Monster"))
		{
			var place = puzzle.GetPlace("Place");
			place.CloseAllDoors();
			place.SpawnSingleMob(chest.Name + "Mob", "Mob" + puzzle.Get("MonsterI"));
			puzzle.Set("MonsterI", puzzle.Get("MonsterI") + 1);
		}
	}