Ejemplo n.º 1
0
 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;
     }
 }
Ejemplo n.º 2
0
    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]);
        }
    }
Ejemplo n.º 3
0
        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 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;
        }
Ejemplo n.º 5
0
 public void PushEntries(IEnumerable<WalletEntry> entries, BlockType? blockType)
 {
     foreach(var entry in entries)
     {
         PushEntry(entry, blockType);
     }
 }
Ejemplo n.º 6
0
 public GameObject SpawnBlock(BlockType type , Vector3 location)
 {
     var game = Instantiate(Resources.Load(BlockTyper(type))) as GameObject;
     game.transform.SetParent(pieces);
     game.transform.position = location;
     return game;
 }
Ejemplo n.º 7
0
	public void SetBlockAt(Vector3 position, BlockType block) {
		int x= Mathf.RoundToInt( position.x );
		int y= Mathf.RoundToInt( position.y );
		int z= Mathf.RoundToInt( position.z );
		
		SetBlockAt(x,y,z,block);
	}
Ejemplo n.º 8
0
 public BlockMatcher(BlockType type)
 {
     this.BlockType = type;
     _regex = new Regex(
         BlockMatcher.GetPattern(type),
         RegexOptions.Compiled | RegexOptions.Singleline);
 }
Ejemplo n.º 9
0
 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);
 }
Ejemplo n.º 10
0
 public Block(BlockType type, int x, int y)
     : this()
 {
     Position = new Point(x, y);
     Type = type;
     Rotate = 0;
 }
Ejemplo n.º 11
0
		//   * 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;
		}
Ejemplo n.º 12
0
    /// <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
    }
Ejemplo n.º 13
0
 public BlockRequestBase(TaskId taskId, string taskExecutionId, BlockType blockType, string blockExecutionId)
 {
     TaskId = taskId;
     TaskExecutionId = taskExecutionId;
     BlockExecutionId = blockExecutionId;
     BlockType = blockType;
 }
Ejemplo n.º 14
0
		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;

		}
Ejemplo n.º 15
0
    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;
    }
Ejemplo n.º 16
0
 public void ExportJson()
 {
     var blockType = new BlockType { Name = "Foo" };
     var result = blockType.ToJson();
     const string key = "\"Name\": \"Foo\"";
     Assert.NotEqual( result.IndexOf( key ), -1 );
 }
Ejemplo n.º 17
0
        /// <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;
        }
Ejemplo n.º 18
0
	void SelectDirtBlock()
	{
		_selectedBlockType = BlockType.Dirt;
		_buttonBlockDirt.ForcePress();
		_buttonBlockGrass.ForceRelease();
		_buttonBlockStone.ForceRelease();
	}
     public InvalidBlockTypeException(BlockType blockType)
         : base(string.Format(
   "The given block type \"{0}\" was unexpected in this context.", blockType
 ))
     {
         this.BlockType = blockType;
     }
Ejemplo n.º 20
0
 public BlockInfo(Vector2i position, BlockType type, float height, Vector3 normal)
 {
     Position = position;
     Type = type;
     Height = height;
     Normal = normal;
 }
Ejemplo n.º 21
0
 public void RemoveBlockFromGrid(int i, int j, BlockType blockType)
 {
     gridMap[i, j] = false;
     gridMap[i + blockType.GetWidth() - 1, j] = false;
     gridMap[i, j + blockType.GetHeight() - 1] = false;
     gridMap[i + blockType.GetWidth() - 1, j + blockType.GetHeight() - 1] = false;
 }
Ejemplo n.º 22
0
    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);
    }
Ejemplo n.º 23
0
	public WorldData(int x, int y, int z, int s, BlockType[,,] d) {
		worldX = x;
		worldY = y;
		worldZ = z;
		chunkSize = s;
		data = d;
	}
Ejemplo n.º 24
0
 public Block(int x, int y, BlockType type)
 {
     this.x = x;
     this.y = y;
     size = 10;
     this.type = type;
 }
Ejemplo n.º 25
0
 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>();
 }
Ejemplo n.º 26
0
        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;
        }
Ejemplo n.º 27
0
    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;
        }
    }
Ejemplo n.º 28
0
    public void BuildSideDown(int x, int y, int z, BlockType type)
    {
        vert0 = new Vector3(x + -0.5f, y + -0.5f, z + -0.5f);
        vertices.Add(vert0);
        verts++;
        v0 = verts - 1;

        vert1 = new Vector3(x + -0.5f, y + -0.5f, z + 0.5f);
        vertices.Add(vert1);
        verts++;
        v1 = verts - 1;

        vert2 = new Vector3(x + 0.5f, y + -0.5f, z + 0.5f);
        vertices.Add(vert2);
        verts++;
        v2 = verts - 1;

        vert3 = new Vector3(x + 0.5f, y + -0.5f, z + -0.5f);
        vertices.Add(vert3);
        verts++;
        v3 = verts - 1;

        triangles.Add(v1);
        triangles.Add(v0);
        triangles.Add(v3);

        triangles.Add(v1);
        triangles.Add(v3);
        triangles.Add(v2);

        AddUVRange(FaceUVs(Direction.down, type));
    }
Ejemplo n.º 29
0
 public MatchResult(Pattern pattern, int x, int y, BlockType type)
 {
     this.pattern = pattern;
     this.x = x;
     this.y = y;
     this.type = type;
 }
Ejemplo n.º 30
0
    protected virtual bool AddBlock(Vector3 pos, BlockType type)
    {
        World world = (World)FindObjectOfType(typeof(World));

        Chunk chunk = world.worldPointToClosestChunk(pos);
        return chunk.addBlockAtWorldPosition(pos, type);
    }
Ejemplo n.º 31
0
        //Each block of compressed data begins with 3 header bits
        // containing the following data:
        //    first bit       BFINAL
        //    next 2 bits     BTYPE
        // Note that the header bits do not necessarily begin on a byte
        // boundary, since a block does not necessarily occupy an integral
        // number of bytes.
        // BFINAL is set if and only if this is the last block of the data
        // set.
        // BTYPE specifies how the data are compressed, as follows:
        //    00 - no compression
        //    01 - compressed with fixed Huffman codes
        //    10 - compressed with dynamic Huffman codes
        //    11 - reserved (error)
        // The only difference between the two compressed cases is how the
        // Huffman codes for the literal/length and distance alphabets are
        // defined.
        //
        // This function returns true for success (end of block or output window is full,)
        // false if we are short of input
        //
        private bool Decode()
        {
            var eob    = false;
            var result = false;

            if (Finished())
            {
                return(true);
            }

            if (hasFormatReader)
            {
                if (state == InflaterState.ReadingHeader)
                {
                    if (!formatReader.ReadHeader(input))
                    {
                        return(false);
                    }
                    state = InflaterState.ReadingBFinal;
                }
                else if (state == InflaterState.StartReadingFooter || state == InflaterState.ReadingFooter)
                {
                    if (!formatReader.ReadFooter(input))
                    {
                        return(false);
                    }

                    state = InflaterState.VerifyingFooter;
                    return(true);
                }
            }

            if (state == InflaterState.ReadingBFinal)
            {
                // reading bfinal bit
                // Need 1 bit
                if (!input.EnsureBitsAvailable(1))
                {
                    return(false);
                }

                bfinal = input.GetBits(1);
                state  = InflaterState.ReadingBType;
            }

            if (state == InflaterState.ReadingBType)
            {
                // Need 2 bits
                if (!input.EnsureBitsAvailable(2))
                {
                    state = InflaterState.ReadingBType;
                    return(false);
                }

                blockType = (BlockType)input.GetBits(2);
                if (blockType == BlockType.Dynamic)
                {
                    state = InflaterState.ReadingNumLitCodes;
                }
                else if (blockType == BlockType.Static)
                {
                    literalLengthTree = HuffmanTree.StaticLiteralLengthTree;
                    distanceTree      = HuffmanTree.StaticDistanceTree;
                    state             = InflaterState.DecodeTop;
                }
                else if (blockType == BlockType.Uncompressed)
                {
                    state = InflaterState.UncompressedAligning;
                }
                else
                {
                    throw new InvalidDataException(SR.GetString(SR.UnknownBlockType));
                }
            }

            if (blockType == BlockType.Dynamic)
            {
                if (state < InflaterState.DecodeTop)
                {
                    result = DecodeDynamicBlockHeader();
                }
                else
                {
                    result = DecodeBlock(out eob);                  // this can returns true when output is full
                }
            }
            else if (blockType == BlockType.Static)
            {
                result = DecodeBlock(out eob);
            }
            else if (blockType == BlockType.Uncompressed)
            {
                result = DecodeUncompressedBlock(out eob);
            }
            else
            {
                throw new InvalidDataException(SR.GetString(SR.UnknownBlockType));
            }

            //
            // If we reached the end of the block and the block we were decoding had
            // bfinal=1 (final block)
            //
            if (eob && bfinal != 0)
            {
                if (hasFormatReader)
                {
                    state = InflaterState.StartReadingFooter;
                }
                else
                {
                    state = InflaterState.Done;
                }
            }
            return(result);
        }
Ejemplo n.º 32
0
        //Each block of compressed data begins with 3 header bits
        // containing the following data: 
        //    first bit       BFINAL
        //    next 2 bits     BTYPE
        // Note that the header bits do not necessarily begin on a byte
        // boundary, since a block does not necessarily occupy an integral 
        // number of bytes.
        // BFINAL is set if and only if this is the last block of the data 
        // set. 
        // BTYPE specifies how the data are compressed, as follows:
        //    00 - no compression 
        //    01 - compressed with fixed Huffman codes
        //    10 - compressed with dynamic Huffman codes
        //    11 - reserved (error)
        // The only difference between the two compressed cases is how the 
        // Huffman codes for the literal/length and distance alphabets are
        // defined. 
        // 
        // This function returns true for success (end of block or output window is full,)
        // false if we are short of input 
        //
        private bool Decode()
        {
            bool eob = false;
            bool result = false;

            if (Finished())
            {
                return true;
            }

            if (_usingGzip)
            {
                if (_state == InflaterState.ReadingGZIPHeader)
                {
                    if (!_gZipDecoder.ReadGzipHeader())
                    {
                        return false;
                    }
                    _state = InflaterState.ReadingBFinal;
                }
                else if (_state == InflaterState.StartReadingGZIPFooter || _state == InflaterState.ReadingGZIPFooter)
                {
                    if (!_gZipDecoder.ReadGzipFooter())
                        return false;

                    _state = InflaterState.VerifyingGZIPFooter;
                    return true;
                }
            }

            if (_state == InflaterState.ReadingBFinal)
            {
                // reading bfinal bit
                // Need 1 bit 
                if (!_input.EnsureBitsAvailable(1))
                    return false;

                _bfinal = _input.GetBits(1);
                _state = InflaterState.ReadingBType;
            }

            if (_state == InflaterState.ReadingBType)
            {
                // Need 2 bits 
                if (!_input.EnsureBitsAvailable(2))
                {
                    _state = InflaterState.ReadingBType;
                    return false;
                }

                blockType = (BlockType) _input.GetBits(2);
                if (blockType == BlockType.Dynamic)
                {
                    _state = InflaterState.ReadingNumLitCodes;
                }
                else if (blockType == BlockType.Static)
                {
                    _literalLengthTree = HuffmanTree.StaticLiteralLengthTree;
                    _distanceTree = HuffmanTree.StaticDistanceTree;
                    _state = InflaterState.DecodeTop;
                }
                else if (blockType == BlockType.Uncompressed)
                {
                    _state = InflaterState.UncompressedAligning;
                }
                else
                {
                    throw new InvalidDataException("SR.UnknownBlockType");
                }
            }

            if (blockType == BlockType.Dynamic)
            {
                if (_state < InflaterState.DecodeTop)
                {
                    // we are reading the header 
                    result = DecodeDynamicBlockHeader();
                }
                else
                {
                    result = DecodeBlock(out eob); // this can returns true when output is full 
                }
            }
            else if (blockType == BlockType.Static)
            {
                result = DecodeBlock(out eob);
            }
            else if (blockType == BlockType.Uncompressed)
            {
                result = DecodeUncompressedBlock(out eob);
            }
            else
            {
                throw new InvalidDataException("SR.UnknownBlockType");
            }

            //
            // If we reached the end of the block and the block we were decoding had 
            // bfinal=1 (final block)
            //
            if (eob && (_bfinal != 0))
            {
                if (_usingGzip)
                    _state = InflaterState.StartReadingGZIPFooter;
                else
                    _state = InflaterState.Done;
            }
            return result;
        }
Ejemplo n.º 33
0
        void SerializeIntoBuffer(object?metadata, IReadOnlyList <object>?events, out int startOffset,
                                 out IDescriptorSerializerContext serializerContext, out BlockType blockType,
                                 out int lenWithoutEndPadding, out ByteBuffer block)
        {
            startOffset = (int)EndBufferLen + HeaderSize;
            var writer = new SpanWriter();

            writer.WriteBlock(_zeroes.AsSpan(0, startOffset));
            serializerContext = Mapping;
            if (metadata != null)
            {
                serializerContext = serializerContext.StoreNewDescriptors(metadata);
            }
            if (events != null)
            {
                foreach (var o in events)
                {
                    serializerContext = serializerContext.StoreNewDescriptors(o);
                }
                if (events.Count == 0)
                {
                    events = null;
                }
            }
            serializerContext.FinishNewDescriptors(ref writer);
            blockType = BlockType.FirstBlock;
            if (serializerContext.SomeTypeStored)
            {
                blockType |= BlockType.HasTypeDeclaration;
            }
            if (metadata != null)
            {
                serializerContext.StoreObject(ref writer, metadata);
                blockType |= BlockType.HasMetadata;
            }
            if (events != null)
            {
                if (events.Count == 1)
                {
                    serializerContext.StoreObject(ref writer, events[0]);
                    blockType |= BlockType.HasOneEvent;
                }
                else
                {
                    writer.WriteVUInt32((uint)events.Count);
                    foreach (var o in events)
                    {
                        serializerContext.StoreObject(ref writer, o);
                    }
                    blockType |= BlockType.HasMoreEvents;
                }
            }
            lenWithoutEndPadding = (int)writer.GetCurrentPosition();
            writer.WriteBlock(_zeroes.AsSpan(0, (int)(SectorSize - 1)));
            block = writer.GetByteBufferAndReset();
            if (CompressionStrategy.ShouldTryToCompress(lenWithoutEndPadding - startOffset))
            {
                var compressedBlock = new ReadOnlySpan <byte>(block.Buffer, startOffset, lenWithoutEndPadding - startOffset);
                if (CompressionStrategy.Compress(ref compressedBlock))
                {
                    blockType |= BlockType.Compressed;
                    compressedBlock.CopyTo(new Span <byte>(block.Buffer, startOffset, compressedBlock.Length));
                    lenWithoutEndPadding = startOffset + compressedBlock.Length;
                    new Span <byte>(block.Buffer, lenWithoutEndPadding, (int)SectorSize - 1).Clear();
                }
            }
        }
Ejemplo n.º 34
0
 protected virtual void SingleSpanBlockTest(string document, BlockType blockType, SpanKind spanType, params RazorError[] expectedError)
 {
     SingleSpanBlockTest(document, document, blockType, spanType, expectedError);
 }
Ejemplo n.º 35
0
 /// <summary>
 /// Creates a new <see cref="BlockType"/> instance.
 /// </summary>
 private protected BlockTypeInstruction()
 {
     this.Type = BlockType.Empty;
 }
Ejemplo n.º 36
0
 public OreEntry(int minimumDepth, int howOftenGenerateBits, int oresPerXBlocks, BlockType type, bool isFluid = false)
 {
     MinimumDepth   = minimumDepth;
     ChanceOfSpawn  = howOftenGenerateBits;
     OresPerXBlocks = oresPerXBlocks;
     Type           = type;
     IsFluid        = isFluid;
 }
Ejemplo n.º 37
0
 public void FromId_IdTooLarge_ThrowsOutOfRangeException(int id)
 {
     Assert.That(() => BlockType.FromId((ushort)id), Throws.InstanceOf <ArgumentOutOfRangeException>());
 }
Ejemplo n.º 38
0
 /// <summary>
 /// Create instance of the asynchronous queue (blocking collection version).
 /// </summary>
 /// <param name="name">Name of the asynchronous queue</param>
 /// <param name="blockType">Type of the blocking strategy</param>
 /// <param name="blockLimit">Blocking buffer limit</param>
 public AsyncQueueBlocking(string name, BlockType blockType = BlockType.Error, int blockLimit = 1000000)
 {
     Name       = name;
     BlockType  = blockType;
     BlockLimit = blockLimit;
 }
Ejemplo n.º 39
0
    void Update()
    {
        //Asking TimeManger if we are at end of trial...
        if (_timer.EndTrial == true)
        {
            _currentTaskState = TaskState.EndTrial;
        }

        //asking TimeManager if we are at end of a block...
        if (_trialType == TrialType.Both)
        {
            if (_timer.SwitchBlock == true)
            {
                if (CurrentBlockType == BlockType.Baseline)
                {
                    CurrentBlockType  = BlockType.Reversal;
                    _currentTaskState = TaskState.StartBlock;
                }
                else if (CurrentBlockType == BlockType.Reversal)
                {
                    CurrentBlockType  = BlockType.Baseline;
                    _currentTaskState = TaskState.StartBlock;
                }
            }
        }


        // MAIN STATE MACHINE
        switch (_currentTaskState)
        {
        case TaskState.WaitForTrigger:

            if (!Hourglass.activeInHierarchy)
            {
                Hourglass.SetActive(true);
            }

            break;

        case TaskState.StartTrial:

            ClearFeedback();
            _logger.Init();

            switch (_trialType)
            {
            case TrialType.Both:
                CurrentBlockType = BlockType.Baseline;
                break;

            case TrialType.Baseline:
                CurrentBlockType = BlockType.Baseline;
                break;

            case TrialType.Reversal:
                CurrentBlockType = BlockType.Reversal;
                break;
            }

            _currentTaskState = TaskState.StartBlock;

            break;

        case TaskState.StartBlock:

            switch (CurrentBlockType)
            {
            case BlockType.Baseline:
                StartBaseline();
                _blockLengthLimit = _baselineBlockLength;
                break;

            case BlockType.Reversal:
                StartReversal();
                _blockLengthLimit = _reversalBlockLength;
                break;
            }

            //start the block timer here, check end in Timer script
            BlockTimerStart   = DateTime.Now;
            _currentTaskState = TaskState.StartIteration;

            break;

        case TaskState.StartIteration:

            if (CurrentBlockType == BlockType.Baseline)
            {
                ClearFeedback();
                StartBaseline();
            }

            if (CurrentBlockType == BlockType.Reversal)
            {
                ClearFeedback();
                StartReversal();
            }


            _previousChoices = new List <ItemChoice>();

            if (CurrentBlockType == BlockType.Baseline || _previousCorrectChoice == ItemChoice.None)
            {
                SetCorrectAnswerRandomly();
            }
            else
            {
                SetCorrectAnswerToPrevious();
            }

            if (CurrentBlockType == BlockType.Baseline)
            {
                DisplayHint();
            }

            _iterationStartTime = Time.time;                     //start time of the iteration
            _currentTaskState   = TaskState.ProcessChoice;

            break;


        case TaskState.ProcessChoice:

            // Filter out no choice or repeated choices
            if (_currentChoice != ItemChoice.None && !_previousChoices.Contains(_currentChoice))
            {
                _previousChoices.Add(_currentChoice);

                if (_previousCorrectChoice == ItemChoice.None)
                {
                }

                if (CurrentBlockType == BlockType.Reversal && _interReversalIterationCount > _interReversalIterationNumber)                        // **RANDOMIZED # OF ITERATIONS BETWEEN REVERSAL BLOCKS**
                {
                    SetCorrectAnswerBasedOnChoiceProb(_currentChoice);
                    _reversalFlag = 1;     //marks occurance of reversals
                }

                if (_currentChoice == _correctChoice)
                {
                    UpdateDisplayForChoice(_currentChoice, ChoiceResult.Correct);

                    if (CurrentBlockType == BlockType.Reversal)
                    {
                        _attemptCount++;                                 //tally for total number of responses
                        _correctAttemptCount++;                          //tally for totaly number of CORRECT responses
                    }

                    if (CurrentBlockType == BlockType.Baseline)
                    {
                        _baselineAttemptCount++;
                        baselineCorrectAttemptCount++;
                    }
                    _iterationEndTime = Time.time;
                    _currentTaskState = TaskState.ReinforceIteration;
                }

                else
                {
                    UpdateDisplayForChoice(_currentChoice, ChoiceResult.Incorrect);

                    if (CurrentBlockType == BlockType.Reversal)
                    {
                        _attemptCount++;                                 //tally for total number of responses
                        _incorrectAttemptCount++;                        //tally for totaly number of INCORRECT responses

                        if (_reversalFlag == 1)
                        {
                            _incorrectAttemptOnReversalCount++;                                     // tally for the number of INCORRECT responses in a REVERSAL condition
                        }
                    }

                    if (CurrentBlockType == BlockType.Baseline)
                    {
                        _baselineAttemptCount++;
                        baselineIncorrectAttemptCount++;
                    }

                    _currentTaskState = TaskState.ProcessChoice;
                }

                _currentChoice = ItemChoice.None;
            }
            break;

        case TaskState.ReinforceIteration:

            var tmpTime = Time.time;
            _currentTaskState = tmpTime - _iterationEndTime >= 1.5 ? TaskState.EndIteration : TaskState.ReinforceIteration;                     //FIX THIS : MAKE THE DELAY CONFIGURABLE

            break;

        case TaskState.EndIteration:

            //blockTimerEnd = DateTime.Now;
            _currentTrialLength = Time.timeSinceLevelLoad - ScannerDelay;

            _previousCorrectChoice = _correctChoice;
            _interReversalIterationCount++;

            _logger.LogRaw(_reversalIterationCount + " , " + _attemptCount + " , " + _correctAttemptCount + " , " + _incorrectAttemptCount + " , " + _incorrectAttemptOnReversalCount + " , " + _responseTime +
                           " , " + _reversalCount + " , " + _reversalResponseTime + " , " + baselineIterationCount + " , " + baselineResponseTime + " , " + _baselineAttemptCount + " , " + baselineCorrectAttemptCount + " , "
                           + baselineIncorrectAttemptCount);

            if (CurrentBlockType == BlockType.Reversal)
            {
                _reversalIterationCount++;                                    //tally of the number of iterations presented
                _responseTime      = _iterationEndTime - _iterationStartTime; //calculating time in between CORRECT responses (response time)
                _totalResponseTime = _totalResponseTime + _responseTime;      //total response time compiler. compiles the time it takes to get the correct answer (the time taken to complete iteration) --> used to calculate average

                if (_reversalFlag == 1)                                       // checking if reversal has occured and pulling that time frame from _responseTime
                {
                    _interReversalIterationNumber = Random.Range(4, 7);
                    _reversalResponseTime         = _responseTime;
                    _totalReversalResponseTime    = _totalReversalResponseTime + _reversalResponseTime; //compiling total response time in reversal situation
                    _reversalCount++;                                                                   //compiles number of reversals as they occur
                    _reversalFlag = 0;                                                                  //resets reversal marker
                }
            }

            if (CurrentBlockType == BlockType.Baseline)                     //baseline block metrics
            {
                baselineIterationCount++;
                baselineResponseTime       = _iterationEndTime - _iterationStartTime;
                _totalBaselineResponseTime = _totalBaselineResponseTime + baselineResponseTime;
            }

            if (_trialType != TrialType.Both)
            {
                _currentTaskState = TaskState.StartIteration;
            }

            //if (_trialType == TrialType.All && ((blockTimerEnd - blockTimerStart).Seconds > blockLengthLimit))
            //{
            //	_currentTaskState = TaskState.EndBlock;
            //}

            else
            {
                _currentTaskState = TaskState.StartIteration;
            }

            //            if (_trialLength > _trialLengthLimit) //**SET THIS TO A GIVEN TIME PERIOD (9 MIN WAS DISCUSSED - 540 sec)**
            //{
            //	_currentTaskState = TaskState.EndTrial;
            //}

            break;

        case TaskState.EndBlock:

            if (CurrentBlockType == BlockType.Baseline)
            {
                CurrentBlockType = BlockType.Reversal;
            }

            else if (CurrentBlockType == BlockType.Reversal)
            {
                CurrentBlockType = BlockType.Baseline;
            }

            _currentTaskState = TaskState.StartBlock;
            break;

        case TaskState.EndTrial:

            _averageResponseTime         = _totalResponseTime / _reversalIterationCount;                                                                                                                                                                                                                                                 // average response time to get correct answer over course of the whole trial
            _averageReversalResponseTime = _totalReversalResponseTime / _reversalCount;                                                                                                                                                                                                                                                  // average response time to reversal condition
            averageBaselineResponseTime  = _totalBaselineResponseTime / baselineIterationCount;                                                                                                                                                                                                                                          // baseline block metrics

            _logger.LogReversalSummary("ReversalIterationCount , trialDuration , averageResponseTime , reversalCount , averageReversalResponseTime" + Environment.NewLine + _reversalIterationCount + " , " + _timer.CurrentTrialLength + " , " + _averageResponseTime + " , " + _reversalCount + " , " + _averageReversalResponseTime); // summery metrics for whole trial
            _logger.LogBaselineSummary("BaselineIterationCount , trialDuration , baselineCorrectCount , baselineIncorrectCount , averageBaselineResponseTime" + Environment.NewLine + baselineIterationCount + " , " + _timer.CurrentTrialLength + " , " + baselineCorrectAttemptCount + " , " + baselineIncorrectAttemptCount + " , " + averageBaselineResponseTime);
            _logger.Term();

            SceneManager.LoadScene("GameEndScreen_Stimulation");

            break;
        }
    }
Ejemplo n.º 40
0
 private protected BlockTypeInstruction(BlockType type)
 {
     this.Type = type;
 }
Ejemplo n.º 41
0
 /**
  * Considers center tile to have given type. Used for checking during building.
  */
 public NeighbourPositionStream filterByAccessibilityWithFutureTile(BlockType type)
 {
     stream = stream.Where(position => passageMap.tileIsAccessibleFromNeighbour(center, position, type));
     return(this);
 }
Ejemplo n.º 42
0
 /// <summary>
 /// Restores the health of the block and removes the cracks by redrawing the chunk.
 /// </summary>
 public void Reset()
 {
     health        = BlockType.NOCRACK;
     currentHealth = blockHealthMax[(int)blockType];
     owner.Redraw();
 }
Ejemplo n.º 43
0
 internal Block(BlockType type, IEnumerable <SyntaxTreeNode> contents, IBlockCodeGenerator generator)
 {
     Type          = type;
     CodeGenerator = generator;
     Children      = contents;
 }
Ejemplo n.º 44
0
 /// <summary>
 /// Creates a new <see cref="If"/> of the provided type.
 /// </summary>
 /// <param name="type">Becomes the block's <see cref="BlockTypeInstruction.Type"/>.</param>
 public If(BlockType type)
     : base(type)
 {
 }
Ejemplo n.º 45
0
 public void SetBT(BlockType nbt)
 {
     bt = nbt;
 }
Ejemplo n.º 46
0
 public PrimitiveBlock(int nx, int ny, BlockType nbt, Sprite nspr) : this(nx, ny, nbt)
 {
     spr = nspr;
 }
Ejemplo n.º 47
0
 public PrimitiveBlock(int nx, int ny, BlockType nbt, Sprite nspr, bool nflipX, bool nFlipY) : this(nx, ny, nbt, nspr)
 {
     flipX = nflipX;
     flipY = nFlipY;
 }
Ejemplo n.º 48
0
 public MarkupBlock(BlockType blockType, IBlockCodeGenerator codeGenerator, IEnumerable <SyntaxTreeNode> children)
     : base(blockType, children, codeGenerator)
 {
 }
Ejemplo n.º 49
0
 public Block(int x, int y, int z, BlockType blockType) : this(x, y, z)
 {
     BlockID = blockType;
 }
Ejemplo n.º 50
0
 internal WorldPortalBlock(BlockType type, int bid, string target, int spawn) : base(type, bid)
 {
     Target = target;
     Spawn  = spawn;
 }
Ejemplo n.º 51
0
        private List <Point> GetCellPossess(Point ind, BlockType type)
        {
            List <Point> datas = new List <Point>();

            switch (type)
            {
            case BlockType.Square:
                datas.Add(new Point(0, 0)); datas.Add(new Point(1, 1)); datas.Add(new Point(1, 0)); datas.Add(new Point(0, 1)); break;

            case BlockType.Line:
                if (targetDirect == 0 || targetDirect == 2)
                {
                    datas.Add(new Point(0, 0));
                    datas.Add(new Point(-1, 0));
                    datas.Add(new Point(1, 0));
                    datas.Add(new Point(2, 0));
                }
                else
                {
                    datas.Add(new Point(0, 0));
                    datas.Add(new Point(0, -1));
                    datas.Add(new Point(0, 1));
                    datas.Add(new Point(0, 2));
                }
                break;

            case BlockType.T:
                if (targetDirect == 0)
                {
                    datas.Add(new Point(0, 0));
                    datas.Add(new Point(0, -1));
                    datas.Add(new Point(1, 0));
                    datas.Add(new Point(-1, 0));
                }
                else if (targetDirect == 1)
                {
                    datas.Add(new Point(0, 0));
                    datas.Add(new Point(0, -1));
                    datas.Add(new Point(1, 0));
                    datas.Add(new Point(0, 1));
                }
                else if (targetDirect == 2)
                {
                    datas.Add(new Point(0, 0));
                    datas.Add(new Point(0, 1));
                    datas.Add(new Point(1, 0));
                    datas.Add(new Point(-1, 0));
                }
                else if (targetDirect == 3)
                {
                    datas.Add(new Point(0, 0));
                    datas.Add(new Point(0, -1));
                    datas.Add(new Point(-1, 0));
                    datas.Add(new Point(0, 1));
                }
                break;

            case BlockType.Z:
                if (targetDirect == 0 || targetDirect == 2)
                {
                    datas.Add(new Point(0, 0));
                    datas.Add(new Point(0, -1));
                    datas.Add(new Point(-1, -1));
                    datas.Add(new Point(1, 0));
                }
                else
                {
                    datas.Add(new Point(0, 0));
                    datas.Add(new Point(0, 1));
                    datas.Add(new Point(1, 0));
                    datas.Add(new Point(1, -1));
                }
                break;

            case BlockType.CZ:
                if (targetDirect == 0 || targetDirect == 2)
                {
                    datas.Add(new Point(0, 0));
                    datas.Add(new Point(0, -1));
                    datas.Add(new Point(1, -1));
                    datas.Add(new Point(-1, 0));
                }
                else
                {
                    datas.Add(new Point(0, 0));
                    datas.Add(new Point(0, -1));
                    datas.Add(new Point(1, 0));
                    datas.Add(new Point(1, 1));
                }
                break;

            case BlockType.L:
                if (targetDirect == 0)
                {
                    datas.Add(new Point(0, 0));
                    datas.Add(new Point(1, 0));
                    datas.Add(new Point(-1, 0));
                    datas.Add(new Point(-1, 1));
                }
                else if (targetDirect == 1)
                {
                    datas.Add(new Point(0, 0));
                    datas.Add(new Point(0, -1));
                    datas.Add(new Point(0, 1));
                    datas.Add(new Point(-1, -1));
                }
                else if (targetDirect == 2)
                {
                    datas.Add(new Point(0, 0));
                    datas.Add(new Point(1, 0));
                    datas.Add(new Point(-1, 0));
                    datas.Add(new Point(1, -1));
                }
                else if (targetDirect == 3)
                {
                    datas.Add(new Point(0, 0));
                    datas.Add(new Point(0, -1));
                    datas.Add(new Point(0, 1));
                    datas.Add(new Point(1, 1));
                }
                break;

            case BlockType.CL:
                if (targetDirect == 0)
                {
                    datas.Add(new Point(0, 0));
                    datas.Add(new Point(1, 0));
                    datas.Add(new Point(-1, 0));
                    datas.Add(new Point(-1, -1));
                }
                else if (targetDirect == 1)
                {
                    datas.Add(new Point(0, 0));
                    datas.Add(new Point(0, -1));
                    datas.Add(new Point(0, 1));
                    datas.Add(new Point(1, -1));
                }
                else if (targetDirect == 2)
                {
                    datas.Add(new Point(0, 0));
                    datas.Add(new Point(1, 0));
                    datas.Add(new Point(-1, 0));
                    datas.Add(new Point(1, 1));
                }
                else if (targetDirect == 3)
                {
                    datas.Add(new Point(0, 0));
                    datas.Add(new Point(0, -1));
                    datas.Add(new Point(0, 1));
                    datas.Add(new Point(-1, 1));
                }
                break;
            }

            for (int i = 0; i < datas.Count; i++)
            {
                datas[i] = new Point(datas[i].X + ind.X, datas[i].Y + ind.Y);
            }
            return(datas);
        }
Ejemplo n.º 52
0
 public override string ToString()
 {
     return(BlockType.ToString() + "  " + this.ConditionExpression);
 }
Ejemplo n.º 53
0
 public static bool IsType(int bid, BlockType type) => (GetBlockType(bid) & type) == type;
Ejemplo n.º 54
0
        void ReadVideoChunk(BitStream bs)
        {
            int current_block_x = 0, current_block_y = 0;
            int block_rez_x = (int)PaddedWidth / 4;
            int block_rez_y = (int)PaddedHeight / 4;

            Console.WriteLine("reading video chunk");
            bs.DebugFirst();

            while (true)
            {
                ushort type_descriptor = 0;
                if (type_Tree != null)
                {
                    type_descriptor = (ushort)type_Tree.Decode(bs);
                }
                BlockType type         = (BlockType)(type_descriptor & 0x3);
                uint      chain_length = block_chain_size_table [(type_descriptor & 0xfc) >> 2];

                Console.WriteLine("rendering {0} blocks of type {1}", chain_length, type);

                for (int i = 0; i < chain_length; i++)
                {
                    switch (type)
                    {
                    case BlockType.Mono:
                        ushort pixel = (ushort)mclr_Tree.Decode(bs);
                        byte   color1 = (byte)((pixel >> 8) & 0xff);
                        byte   color0 = (byte)(pixel & 0xff);
                        ushort map = (ushort)mmap_Tree.Decode(bs);
                        int    mask = 1;
                        int    bx, by;
                        bx = current_block_x * 4;
                        by = current_block_y * 4;
                        for (int bi = 0; bi < 16;)
                        {
                            if ((map & mask) == 0)
                            {
                                frameData[by * PaddedWidth + bx] = color0;
                            }
                            else
                            {
                                frameData[by * PaddedWidth + bx] = color1;
                            }
                            mask <<= 1;
                            bx++;
                            bi++;
                            if ((bi % 4) == 0)
                            {
                                bx = current_block_x * 4;
                                by++;
                            }
                        }
                        break;

                    case BlockType.Full:
                        break;

                    case BlockType.Void:
                        break;

                    case BlockType.Solid:
                        break;
                    }
                    current_block_x++;
                    if (current_block_x == block_rez_x)
                    {
                        current_block_x = 0;
                        current_block_y++;
                        if (current_block_y == block_rez_y)
                        {
                            return;
                        }
                    }
                }
            }
        }
Ejemplo n.º 55
0
 protected virtual void SingleSpanBlockTest(string document, string spanContent, BlockType blockType, SpanKind spanType, params RazorError[] expectedErrors)
 {
     SingleSpanBlockTest(document, spanContent, blockType, spanType, AcceptedCharacters.Any, expectedErrors ?? new RazorError[0]);
 }
Ejemplo n.º 56
0
 internal LabelBlock(BlockType type, int bid, string text, string color, int wrap) : base(type, bid)
 {
     Text  = text;
     Color = color;
     Wrap  = wrap;
 }
Ejemplo n.º 57
0
        protected virtual void SingleSpanBlockTest(string document, string spanContent, BlockType blockType, SpanKind spanType, AcceptedCharacters acceptedCharacters, params RazorError[] expectedErrors)
        {
            var builder = new BlockBuilder();

            builder.Type = blockType;
            ParseBlockTest(
                document,
                ConfigureAndAddSpanToBlock(
                    builder,
                    Factory.Span(spanType, spanContent, spanType == SpanKind.Markup)
                    .Accepts(acceptedCharacters)),
                expectedErrors ?? new RazorError[0]);
        }
Ejemplo n.º 58
0
 protected virtual void SingleSpanBlockTest(string document, string spanContent, BlockType blockType, SpanKind spanType, AcceptedCharacters acceptedCharacters = AcceptedCharacters.Any)
 {
     SingleSpanBlockTest(document, spanContent, blockType, spanType, acceptedCharacters, expectedErrors: null);
 }
Ejemplo n.º 59
0
 internal Block(BlockType type)
 {
     blockType = type;
 }
Ejemplo n.º 60
0
 internal SignBlock(BlockType type, int bid, string text, int morph) : base(type, bid, morph)
 {
     Text = text;
 }