Esempio n. 1
0
    public ClientVC(NetworkReader nr)
        : base(new Vec2i(0,0), 0)
    {
        this.data = new VesselTile[VesselChunk.DATA_COUNT];

        index.x = nr.ReadInt32();
        index.y = nr.ReadInt32();

        version = nr.ReadUInt32();
        tileCount = nr.ReadInt32();

        for (int i = 0; i < tileCount; i++) {
            //read in vessel tile
            Vec2i tileI;

            tileI.x = nr.ReadInt32();
            tileI.y = nr.ReadInt32();
            FloorType floor0 = (FloorType)nr.ReadByte();
            FloorType floor1 = (FloorType)nr.ReadByte();
            WallTypeMask wallMask = (WallTypeMask)nr.ReadByte();
            bool wallNode = nr.ReadBoolean();

            VesselTile tile = new VesselTile(wallMask, wallNode, floor0, floor1, (uint)VesselTile.FLAGS.NONE);

            SetTile(tileI, tile);
        }
    }
Esempio n. 2
0
    public void Reset(Vec2i pos)
    {
        this.pos = pos;

        l2Tile = vessel.TryGetTile(new Vec2i(pos.x-2,pos.y));
        lTile = vessel.TryGetTile(new Vec2i(pos.x-1,pos.y));
        blTile = vessel.TryGetTile(new Vec2i(pos.x-1,pos.y-1));
        bTile = vessel.TryGetTile(new Vec2i(pos.x,pos.y-1));
        b2Tile = vessel.TryGetTile(new Vec2i(pos.x,pos.y-2));
        brTile = vessel.TryGetTile(new Vec2i(pos.x+1,pos.y-1));
        b2rTile = vessel.TryGetTile(new Vec2i(pos.x+1,pos.y-2));
        br2Tile = vessel.TryGetTile(new Vec2i(pos.x+2,pos.y-1));
        tile = vessel.TryGetTile(new Vec2i(pos.x, pos.y));
        rTile = vessel.TryGetTile(new Vec2i(pos.x+1, pos.y));
        r2Tile = vessel.TryGetTile(new Vec2i(pos.x+2, pos.y));
    }
Esempio n. 3
0
    public void MoveRight()
    {
        VesselTile nextR2Tile = vessel.TryGetTile(new Vec2i(pos.x+3, pos.y));
        VesselTile nextBR2Tile = vessel.TryGetTile(new Vec2i(pos.x+3,pos.y-1));
        VesselTile nextB2RTile = vessel.TryGetTile(new Vec2i(pos.x+2,pos.y-2));

        blTile = bTile;
        bTile = brTile;
        brTile = br2Tile;
        br2Tile = nextBR2Tile;

        b2Tile = b2rTile;
        b2rTile = nextB2RTile;

        l2Tile = lTile;
        lTile = tile;
        tile = rTile;
        rTile = r2Tile;
        r2Tile = nextR2Tile;

        pos.x += 1;
    }
Esempio n. 4
0
    public void SetTile(Vec2i index, VesselTile val)
    {
        Vec2i index2 = index;
        Vec2i chunkI = TileToChunkI(index);
        ServerVC vc = (ServerVC)chunks.TryGet(chunkI);

        if (vc == null) {
            vc = CreateChunk(chunkI);
        }

        try {
            index -= vc.OriginTileIndex();
            vc.SetTile(index, val);

            AddModifiedChunk(vc);
        } catch (System.Exception ex) {
            Debug.Log("Failed to set tile at " + index2.ToString() + "/" + index.ToString() + " at chunk " + chunkI.ToString());
        }
    }
Esempio n. 5
0
    public void BuildWall(Vec2i index, int count, WallType type)
    {
        VesselTile tile;

        for (int i = 0; i < count; i++) {

            if (IsWallLegal(index, type)) {

                tile = TryGetTile(index);
                if (tile == null) {
                    tile = new VesselTile();
                    SetTile(index, tile);
                }

                tile.wallMask |= (byte)(1 << ((byte)type - 1));
                tile.wallNode = true;

                index += wallOffsets[(byte)type];

                tile = TryGetTile(index);
                if (tile == null) {
                    tile = new VesselTile();
                    SetTile(index, tile);
                }
                tile.wallNode = true;
            } else {
                index += wallOffsets[(byte)type];
            }
        }
    }
Esempio n. 6
0
    public void SetTile(Vec2i offset, VesselTile val)
    {
        int index = offset.x + (offset.y * SIZE);
        VesselTile org = data[index];

        if (org == null) {
            if (val != null) {
                tileCount++;
            }
        } else {
            if (val == null) {
                tileCount--;
            }
        }

        data[index] = val;
    }