public MatchResult(Pattern pattern, int x, int y, BlockType type)
 {
     this.pattern = pattern;
     this.x = x;
     this.y = y;
     this.type = type;
 }

 public static void ReadBlock(Stream stream, out BlockType blockType, out byte[] data)
 {
     blockType = (BlockType)stream.ReadByte();
     var sizeBuffer = stream.ReadBytes(2);
     var size = (ushort)(sizeBuffer[0] | sizeBuffer[1] << 8);
     data = stream.ReadBytes(size - 2);
 }

    public bool CanPlaceBlock(BlockType type, int[] chunkCoord, int[] blockCoord)
    {
        // Check first to see if we are attempting one of the overlap blocks that techinically "belongs" to the next chunk over
        bool changed = false;
        if (blockCoord[0] == Settings.CHUNK_SIZE)   // x is actually in the next chunk
        {
          chunkCoord[0]++;
          blockCoord[0] = 0;
          changed = true;
        }
        if (blockCoord[1] == Settings.CHUNK_SIZE)
        {
          chunkCoord[1]++;
          blockCoord[1] = 0;
          changed = true;
        }
        if (blockCoord[2] == Settings.CHUNK_SIZE)
        {
          chunkCoord[2]++;
          blockCoord[2] = 0;
          changed = true;
        }

        if (changed)
          return CanPlaceBlock(type, chunkCoord, blockCoord);

        Chunk c;

        if (!allChunks.TryGetValue(Util.CoordsToString(chunkCoord), out c))
          return false;    // No chunk found

        return true;
    }

 public void ExportJson()
 {
     var blockType = new BlockType { Name = "Foo" };
     var result = blockType.ToJson();
     const string key = "\"Name\": \"Foo\"";
     Assert.NotEqual( result.IndexOf( key ), -1 );
 }

    /// <summary>
    /// Give the start position of the agent and a goal, provide the Maze and a container to handle the pathfinding. can give different containers implementing IContainer interface
    /// to have different search results
    /// </summary>
    /// <param name="pos">Start position</param>
    /// <param name="GoalNode">Goal position</param>
    /// <param name="Grid">The Maze Grid</param>
    /// <param name="frontier">Container to use (i.e. Stack, Queue, PriorityQueue)</param>
    /// <returns></returns>
    public List<BlockPosition> GraphSearch(Node pos, Node GoalNode, BlockType[,] Grid, datastructures.IContainer<Node> frontier)
    {
        frontier.Push(pos);
        List<Node> explored = new List<Node>();

        while (!frontier.isEmpty())
        {
            Node currentNode = frontier.Pop();

            if (isGoalState(currentNode, GoalNode)) //path found, return
                return currentNode.Path();

            else //still searching..
            {
                explored.Add(currentNode);

                foreach (Node n in getSuccesors(currentNode, Grid, PathFindSuccessor))
                {
                    if (!explored.Contains(n))
                        frontier.Push(n);
                }

            }

        }

        return null; //there are no more nodes, and the goal hasn't been reached. return null
    }

 public BlockInfo(Vector2i position, BlockType type, float height, Vector3 normal)
 {
     Position = position;
     Type = type;
     Height = height;
     Normal = normal;
 }

	void SelectDirtBlock()
	{
		_selectedBlockType = BlockType.Dirt;
		_buttonBlockDirt.ForcePress();
		_buttonBlockGrass.ForceRelease();
		_buttonBlockStone.ForceRelease();
	}

		//   * Convert a block to a different type of block as a copy.
		//   * 
		//   * @date 12.06.2011 23:33:50
		//   * @author Christian Scheiblich
		//   * @param blockType
		//   *          the type of block to convert to
		//   * @param block
		//   *          the pattern block keeping memory or not
		//   * @return a new block object as a copy for the the requested type
		//   * @throws BlockException
		//   *           if off sets or sizes are negative or out of bound
		public static Block convert(BlockType blockType, Block block)
		{
			Block newBlock = null;

			newBlock = create(blockType, block.getOffSetRow(), block.getOffSetCol(), block.getNoOfRows(), block.getNoOfCols());

			if(block.isMemAllocated())
			{
				newBlock.allocateMemory();

				double[][] matrix = block.get();

				for(int i = 0; i < block.getNoOfRows(); i++)
				{
					for(int j = 0; j < block.getNoOfCols(); j++)
					{
						double val = matrix[i][j];

						if(val != 0.0)
						{
							newBlock.set(i, j, val);
						}
					} // for
				} // for
			} // if

			return newBlock;
		}

        private Blox readBlock(BlockType type, string szName)
        {
            Blox blox = new Blox(szName, type);
            UseType useType;

            foreach (XmlNode node in m_xmlDocBlox.ChildNodes[1].ChildNodes) {
                if (node.Name == "indicator") {
                    blox.addIndicator(BloxReader.CreateIndicator(node));
                } else if(node.Name != "script"){
                    switch(node.Name) {
                        case "instrument_global":
                            useType = UseType.InstrumentGlobal;
                            break;
                        case "block_global":
                            useType = UseType.BlockGlobal;
                            break;
                        case "parameter":
                            useType = UseType.Parameter;
                            break;
                        default:
                            if (node.Name != "#comment") {
                                if (log.IsWarnEnabled) log.Warn("Variable Type not recognized. Skipping! (" + node.Name + ")");
                            }
                            continue;
                    }

                    blox.addVar(BloxReader.CreateVar(node, useType));
                }
            }

            return blox;
        }

        public static uint GetCost(BlockType blockType)
        {
            switch (blockType)
            {
                case BlockType.BankRed:
                case BlockType.BankBlue:
                case BlockType.BeaconRed:
                case BlockType.BeaconBlue:
                    return 50;

                case BlockType.SolidRed:
                case BlockType.SolidBlue:
                    return 10;

                case BlockType.TransRed:
                case BlockType.TransBlue:
                    return 25;

                case BlockType.Road:
                    return 10;
                case BlockType.Jump:
                    return 25;
                case BlockType.Ladder:
                    return 25;
                case BlockType.Shock:
                    return 50;
                case BlockType.Explosive:
                    return 100;
            }

            return 1000;
        }

		public static Block create(BlockType blockType, int offSetRow, int offSetCol, int noOfRows, int noOfCols)
		{
			Block block = null;

			switch(blockType)
			{
				case BlockType.Dummy :

					block = new BlockDummy(offSetRow, offSetCol, noOfRows, noOfCols);

					break;

				case BlockType.Full :

					block = new BlockFull(offSetRow, offSetCol, noOfRows, noOfCols);

					break;

				case BlockType.Index :

					block = new BlockIndex(offSetRow, offSetCol, noOfRows, noOfCols);

					break;

					default :

						throw new BlockError("BlockBuilder#create -- given BlockType is not defined");

			} // switch

			return block;

		}

 private void ChangeCurrentBlock(BlockType blk)
 {
     m_enumCurrentBlock = blk;
     switch (blk)
     {
         case BlockType.Blank:
             this.空白ToolStripMenuItem.CheckState = CheckState.Checked;
             this.机器人ToolStripMenuItem.CheckState = CheckState.Unchecked;
             this.墙ToolStripMenuItem.CheckState = CheckState.Unchecked;
             this.终止点ToolStripMenuItem.CheckState = CheckState.Unchecked;
             break;
         case BlockType.Wall:
             this.空白ToolStripMenuItem.CheckState = CheckState.Unchecked;
             this.机器人ToolStripMenuItem.CheckState = CheckState.Unchecked;
             this.墙ToolStripMenuItem.CheckState = CheckState.Checked;
             this.终止点ToolStripMenuItem.CheckState = CheckState.Unchecked;
             break;
         case BlockType.Robot:
             this.空白ToolStripMenuItem.CheckState = CheckState.Unchecked;
             this.机器人ToolStripMenuItem.CheckState = CheckState.Checked;
             this.墙ToolStripMenuItem.CheckState = CheckState.Unchecked;
             this.终止点ToolStripMenuItem.CheckState = CheckState.Unchecked;
             break;
         case BlockType.Goal:
             this.空白ToolStripMenuItem.CheckState = CheckState.Unchecked;
             this.机器人ToolStripMenuItem.CheckState = CheckState.Unchecked;
             this.墙ToolStripMenuItem.CheckState = CheckState.Unchecked;
             this.终止点ToolStripMenuItem.CheckState = CheckState.Checked;
             break;
         default:
             break;
     }
 }

    public void addFace(FACE face, int x, int y, int z, BlockType type)
    {
        //get the template vertices needed to draw this face
        Vector3[] vertices = BlockTemplate.vertices[(int)face];

        //get the uv mapping for this block/face combination
        Vector2[] uv = BlockTypes.getUV(type, face);
        //Vector2[] uv = BlockTemplate.uv;
        //store the original vertex index
        int origin = _vertices.Count;

        for (int i=0;i<vertices.Length; i++)
        {
            Vector3 vertex = Vector3.Scale(vertices[i] + new Vector3(x,y,z), Block.SIZE);

            //translate and scale the vertex to the position of this block
            _vertices.Add(vertex);
            _uvs.Add(uv[i]);
        }

        //get a template face
        int[] triangles = BlockTemplate.face;
        for (int i=0; i<triangles.Length; i++)
        {
            //translate this index to point to the vertices we just added
            _triangles.Add(origin + triangles[i]);
        }
    }

        public override bool HandleTileEdit(TSPlayer player, TileEditType editType, BlockType blockType, DPoint location, int objectStyle)
        {
            if (this.IsDisposed)
            return false;
              if (base.HandleTileEdit(player, editType, blockType, location, objectStyle))
            return true;

              if (editType == TileEditType.PlaceTile)
            return this.HandleTilePlace(player, blockType, location, objectStyle);
              if (editType == TileEditType.TileKill || editType == TileEditType.TileKillNoItem)
            return this.HandleTileDestruction(player, location);
              if (editType == TileEditType.PlaceWire || editType == TileEditType.PlaceWireBlue || editType == TileEditType.PlaceWireGreen)
            return this.HandleWirePlace(player, location);

              #if DEBUG || Testrun
              if (editType == TileEditType.DestroyWire) {
            player.SendMessage(location.ToString(), Color.Aqua);

            if (!TerrariaUtils.Tiles[location].active())
              return false;

            ObjectMeasureData measureData = TerrariaUtils.Tiles.MeasureObject(location);
            player.SendInfoMessage(string.Format(
              "X: {0}, Y: {1}, FrameX: {2}, FrameY: {3}, Origin X: {4}, Origin Y: {5}, Active State: {6}",
              location.X, location.Y, TerrariaUtils.Tiles[location].frameX, TerrariaUtils.Tiles[location].frameY,
              measureData.OriginTileLocation.X, measureData.OriginTileLocation.Y,
              TerrariaUtils.Tiles.ObjectHasActiveState(measureData)
            ));
              }
              #endif

              return false;
        }

    static string ApplyScaleAndCritical(string pattern, Stat stat, BlockType type, float effectFactor, int criticalBuffId)
    {
        float ciriticalFactor = 0;

        if (stat != null)
        {
            if (type == BlockType.Attack1 || type == BlockType.Attack2)
            {
                bool isCritical = RandomTool.IsIn(stat.Get(HeroStatType.criticalHitChance));
                if (isCritical)
                {
                    int parenOpen;
                    int parenclose;
                    SearchParenIndexs(pattern, "PhysicalAttack", out parenOpen, out parenclose);

                    pattern = pattern.Insert(parenclose, "; param=critical");
                    if (criticalBuffId > 0)
                    {
                        pattern = string.Format("Sequence({0}; Action(Contact; Buff; {1}) )", pattern, criticalBuffId);
                    }
                    ciriticalFactor = stat.Get(HeroStatType.criticalHitDamageFactor);
                }
            }
        }
        return string.Format(pattern, 1 + effectFactor + ciriticalFactor);
    }

 public Blox(string i_szName, BlockType i_stBlockType)
 {
     m_szName = i_szName;
     m_stBlockType = i_stBlockType;
     m_arBlockVars = new List<BlockVar>();
     m_arIndicators = new List<Indicator>();
 }

        /// <summary>
        /// Handles the Click event of the btnSave control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
        protected void btnSave_Click( object sender, EventArgs e )
        {
            BlockType blockType;
            BlockTypeService blockTypeService = new BlockTypeService();

            int blockTypeId = int.Parse( hfBlockTypeId.Value );

            if ( blockTypeId == 0 )
            {
                blockType = new BlockType();
                blockTypeService.Add( blockType, CurrentPersonId );
            }
            else
            {
                BlockTypeCache.Flush( blockTypeId );
                blockType = blockTypeService.Get( blockTypeId );
            }

            blockType.Name = tbName.Text;
            blockType.Path = tbPath.Text;
            blockType.Description = tbDescription.Text;

            if ( !blockType.IsValid )
            {
                // Controls will render the error messages
                return;
            }

            blockTypeService.Save( blockType, CurrentPersonId );

            BindGrid();

            pnlDetails.Visible = false;
            pnlList.Visible = true;
        }

    protected virtual bool AddBlock(Vector3 pos, BlockType type)
    {
        World world = (World)FindObjectOfType(typeof(World));

        Chunk chunk = world.worldPointToClosestChunk(pos);
        return chunk.addBlockAtWorldPosition(pos, type);
    }

     public InvalidBlockTypeException(BlockType blockType)
         : base(string.Format(
   "The given block type \"{0}\" was unexpected in this context.", blockType
 ))
     {
         this.BlockType = blockType;
     }

    static BlockEntity2 GetBlock(BlockType blockType, int subClassCode)
    {
        var blockTable = TableLoader.GetTable<BlockEntity2>();
        var subClassEntity = TableLoader.GetTable<SubClassEntity>().Get(subClassCode);

        switch (blockType)
        {
            case BlockType.Item:
            case BlockType.Gather:
            case BlockType.WildCard:
                return blockTable.Values.Single(x => x.blockType == blockType);

            case BlockType.Attack1:
                return blockTable.Get(subClassEntity.attackBlock1);
            case BlockType.Attack2:
                return blockTable.Get(subClassEntity.attackBlock2);
            case BlockType.Ability:
                return blockTable.Get(subClassEntity.abilityBlock);
            case BlockType.Defend:
                return blockTable.Get(subClassEntity.defendBlock);

            default:
                Assert.Fail();
                return null;
        }
    }