Example #1
0
    public void DecideOwner(BlockProvider blockProvider, Owner owner)
    {
        blockProvider.DecideOwner(owner);
        var address = blockProvider.GetAddress();

        blocks[(int)address.y, (int)address.x] = owner;
    }
Example #2
0
        public void Configure()
        {
            config = new ConfigLoader <WorldConfig>(new[] { "Worlds" }).GetConfig(worldConfig);

            textureProvider = Voxelmetric.resources.GetTextureProvider(this);
            blockProvider   = Voxelmetric.resources.GetBlockProvider(this);

            renderMaterial.mainTexture = textureProvider.atlas;
        }
Example #3
0
        /// <summary>
        /// Draws the tile at zoom level <paramref name="zoomLevel"/> with the tile coordinate <paramref name="tileX"/>/<paramref name="tileZ"/>.
        /// </summary>
        /// <param name="zoomLevel">Zoom level of the tile, with 0 being the closest zoom available.</param>
        /// <param name="tileX">X-coordinate of the tile.</param>
        /// <param name="tileZ">Z-coordinate of the tile.</param>
        internal void DrawMap(int zoomLevel, int tileX, int tileZ)
        {
            // Closest zoom means at the moment 1px = 1 block
            if (zoomLevel == 0)
            {
                // Create a new bitmap
                int tileSizeX = Math.Min(TileSize, BlockProvider.DimensionX - tileX * TileSize);
                int tileSizeZ = Math.Min(TileSize, BlockProvider.DimensionZ - tileZ * TileSize);

                if (tileSizeX <= 0 || tileSizeZ <= 0)
                {
                    throw new ArgumentException("Tile is out of bounds");
                }

                // Create the bitmap
                using (var bmp = new Bitmap(TileSize, TileSize))
                {
                    for (int x = 0; x < tileSizeX; ++x)
                    {
                        for (int z = 0; z < tileSizeZ; ++z)
                        {
                            var tile = BlockProvider.GetTopBlock(x + tileX * TileSize, z + tileZ * TileSize);
                            bmp.SetPixel(x, z, TileRenderer.GetColor(tile));
                        }
                    }

                    TileRenderer.SaveBitmap(GetTileName(zoomLevel, tileX, tileZ), bmp);
                }
            }
            else
            {
                List <Image> bitmaps = new List <Image>();

                using (var bitmap = new Bitmap(TileSize, TileSize))
                    using (var graphics = Graphics.FromImage(bitmap))
                    {
                        for (int dx = 0; dx <= 1; ++dx)
                        {
                            for (int dz = 0; dz <= 1; ++dz)
                            {
                                var previousBitmap = TileRenderer.LoadBitmap(GetTileName(zoomLevel, tileX * 2 + dx, tileZ * 2 + dz));
                                if (previousBitmap != null)
                                {
                                    bitmaps.Add(previousBitmap);
                                    graphics.DrawImage(previousBitmap, 0, 0);
                                }
                            }
                        }

                        TileRenderer.SaveBitmap(GetTileName(zoomLevel, tileX, tileZ), bitmap);
                    }

                bitmaps.ForEach(i => i.Dispose());
            }
        }
Example #4
0
    public override void OnInit(BlockProvider blockProvider)
    {
        base.OnInit(blockProvider);

        air = BlockProvider.AirBlock;
        Block blk = blockProvider.GetBlock("dirt");

        dirt  = new BlockData(blk.Type, blk.Solid);
        blk   = blockProvider.GetBlock("grass");
        grass = new BlockData(blk.Type, blk.Solid);
    }
 public override void OnInit(BlockProvider blockProvider)
 {
     if (connectedMeshConfig.connectsToTypes == null)
     {
         connectedMeshConfig.connectsToTypes = new int[connectedMeshConfig.connectsToNames.Length];
         for (int i = 0; i < connectedMeshConfig.connectsToNames.Length; i++)
         {
             connectedMeshConfig.connectsToTypes[i] = blockProvider.GetType(connectedMeshConfig.connectsToNames[i]);
         }
     }
 }
Example #6
0
        public async Task <Block> GetLastBlock()
        {
            var blockhash = await BlockProvider.GetBestBlockHash();

            var block = await GetBlock(blockhash) ?? new Block
            {
                Hash = blockhash
            };

            return(block);
        }
Example #7
0
    void Start()
    {
        UIManager     = GetComponent <UIManager>();
        BlockProvider = GetComponent <BlockProvider>();

        InitializeStage();

        // ライフが変化した時のUI処理
        this.Life
        .TakeWhile(life => life >= 0)
        .Subscribe(life => this.UIManager.UpdateLife(life));
    }
Example #8
0
    /// <summary>
    /// ブロック配置の初期化
    /// </summary>
    private void InitializeStage()
    {
        var blocks = new List <Block>();

        // 開始位置とブロックのサイズ
        var startPosX = -160;
        var startPosY = -80;
        var width     = 70;
        var height    = 20;

        // ブロックを生成
        // 各ブロックのポジションは開始位置からブロックサイズ分右下にずらす
        for (int i = 0; i < row; i++)
        {
            var posY = startPosY - height * i;
            for (int j = 0; j < column; j++)
            {
                var posX     = startPosX + width * j;
                var position = new Vector2(posX, posY);
                if (row % 2 == 0)
                {
                    var color = Color.gray;
                }
                else
                {
                    var color = Color.red;
                }
                var block = BlockProvider.Create(this.BlocksArea.GetComponent <RectTransform>(), position, Color.gray);
                blocks.Add(block);

                // ブロックがこわれたとき
                block.OnBroken.Subscribe(
                    score => {
                    this.ScoreManager.UpdateScore(score);
                    // ブロック全部壊したらクリア
                    if (this.ScoreManager.Score == block.Score * row * column)
                    {
                        GameClear();
                    }
                }).AddTo(block);
            }
        }

        // ゲームオーバ処理
        this.Ground.OnTriggerEnter2DAsObservable()
        .Subscribe(
            collider => {
            Destroy(collider.gameObject);
            GameOver();
        }
            );
    }
Example #9
0
        public static void GetFirstTransaction(BlockProvider blockProvider, out Block block, out Transaction tx, out IDictionary <UInt256, Transaction> txLookup)
        {
            txLookup = new Dictionary <UInt256, Transaction>();

            // prior outputs for first transaction
            GetTransaction(blockProvider, 9, 0, out block, out tx);
            txLookup.Add(tx.Hash, tx);

            // first transaction
            // do this last so its output is what is returned
            GetTransaction(blockProvider, 170, 1, out block, out tx);
            txLookup.Add(tx.Hash, tx);
        }
Example #10
0
    public override void OnInit(BlockProvider blockProvider)
    {
        base.OnInit(blockProvider);

        if (meshConfig.connectsToTypes == null)
        {
            meshConfig.connectsToTypes = new int[meshConfig.connectsToNames.Length];
            for (int i = 0; i < meshConfig.connectsToNames.Length; i++)
            {
                meshConfig.connectsToTypes[i] = blockProvider.GetType(meshConfig.connectsToNames[i]);
            }
        }
    }
        public BlockProvider GetBlockProvider(World world)
        {
            //Check for the folder in the dictionary and if it doesn't exist create it
            BlockProvider blockProvider;

            if (BlockProviders.TryGetValue(world.config.blockFolder, out blockProvider))
            {
                return(blockProvider);
            }

            blockProvider = BlockProvider.Create(world.config.blockFolder, world);
            BlockProviders.Add(world.config.blockFolder, blockProvider);
            return(blockProvider);
        }
Example #12
0
    void Start()
    {
        int width_step = 4;
        int count      = 0;
        int length     = BlockProvider.BLOCKS.Count;

        foreach (KeyValuePair <string, char[, ]> blueprint in BlockProvider.BLOCKS)
        {
            Block block = BlockProvider.Create(blueprint);
            block.color                   = m_color;
            block.transform.parent        = this.transform;
            block.transform.localPosition = new Vector3((count - length / 2) * width_step, 0, 0);
            count++;
        }
    }
Example #13
0
        private void BeginDigging(Coordinates3D target)
        {
            // TODO: Adjust digging time to compensate for latency
            var block = Game.Client.World.GetBlockId(target);

            Game.TargetBlock  = target;
            Game.StartDigging = DateTime.UtcNow;
            Game.EndDigging   = Game.StartDigging.AddMilliseconds(
                BlockProvider.GetHarvestTime(block,
                                             Game.Client.Inventory.Hotbar[Game.Client.HotBarSelection].Id, out _));
            Game.Client.QueuePacket(new PlayerDiggingPacket(
                                        PlayerDiggingPacket.Action.StartDigging,
                                        Game.TargetBlock.X, (sbyte)Game.TargetBlock.Y, Game.TargetBlock.Z,
                                        Game.HighlightedBlockFace));
            NextAnimation = DateTime.UtcNow.AddSeconds(0.25);
        }
Example #14
0
        public void Configure()
        {
            config = new ConfigLoader <WorldConfig>(new[] { "Worlds" }).GetConfig(worldConfig);
            VerifyConfig();

            textureProvider = Voxelmetric.resources.GetTextureProvider(this);
            blockProvider   = Voxelmetric.resources.GetBlockProvider(this);

            textureProvider.Init(config);
            blockProvider.Init(config.blockFolder, this);

            foreach (var renderMaterial in renderMaterials)
            {
                renderMaterial.mainTexture = textureProvider.atlas;
            }
        }
Example #15
0
        static void Main(string[] args)
        {
            var provider = new BlockProvider();

            Task.Run(() =>
            {
                provider.Start();
            });

            while (Console.ReadLine() != "x")
            {
                Thread.Sleep(1000);
            }

            provider.Stop();
            Console.WriteLine("Stopped.");
            Thread.Sleep(1500);
        }
Example #16
0
        public Simulator(ChainType chainType)
        {
            // initialize kernel
            this.kernel = new StandardKernel();

            // add logging module
            this.kernel.Load(new ConsoleLoggingModule());

            // log startup
            this.logger = LogManager.GetCurrentClassLogger();
            this.logger.Info($"Starting up: {DateTime.Now}");

            this.random        = new Random();
            this.blockProvider = TestBlockProvider.CreateForRules(chainType);

            // add storage module
            this.kernel.Load(new MemoryStorageModule());

            // add rules module
            this.kernel.Load(new RulesModule(chainType));

            // by default, don't run scripts in unit tests
            var rules = this.kernel.Get <ICoreRules>();

            rules.IgnoreScripts = true;

            // initialize the blockchain daemon
            this.kernel.Bind <CoreDaemon>().ToSelf().InSingletonScope();
            this.coreDaemon  = this.kernel.Get <CoreDaemon>();
            this.coreStorage = this.coreDaemon.CoreStorage;

            // start the blockchain daemon
            this.coreDaemon.Start();

            // wait for initial work
            this.coreDaemon.WaitForUpdate();

            // verify initial state
            Assert.AreEqual(0, this.coreDaemon.TargetChainHeight);
            Assert.AreEqual(rules.ChainParams.GenesisBlock.Hash, this.coreDaemon.TargetChain.LastBlock.Hash);
            Assert.AreEqual(rules.ChainParams.GenesisBlock.Hash, this.coreDaemon.CurrentChain.LastBlock.Hash);
        }
Example #17
0
        public Simulator(ChainType chainType)
        {
            // initialize kernel
            this.kernel = new StandardKernel();

            // add logging module
            this.kernel.Load(new ConsoleLoggingModule());

            // log startup
            this.logger = LogManager.GetCurrentClassLogger();
            this.logger.Info($"Starting up: {DateTime.Now}");

            this.random = new Random();
            this.blockProvider = TestBlockProvider.CreateForRules(chainType);

            // add storage module
            this.kernel.Load(new MemoryStorageModule());

            // add rules module
            this.kernel.Load(new RulesModule(chainType));

            // by default, don't run scripts in unit tests
            var rules = this.kernel.Get<ICoreRules>();
            rules.IgnoreScripts = true;

            // initialize the blockchain daemon
            this.kernel.Bind<CoreDaemon>().ToSelf().InSingletonScope();
            this.coreDaemon = this.kernel.Get<CoreDaemon>();
            this.coreStorage = this.coreDaemon.CoreStorage;

            // start the blockchain daemon
            this.coreDaemon.Start();

            // wait for initial work
            this.coreDaemon.WaitForUpdate();

            // verify initial state
            Assert.AreEqual(0, this.coreDaemon.TargetChainHeight);
            Assert.AreEqual(rules.ChainParams.GenesisBlock.Hash, this.coreDaemon.TargetChain.LastBlock.Hash);
            Assert.AreEqual(rules.ChainParams.GenesisBlock.Hash, this.coreDaemon.CurrentChain.LastBlock.Hash);
        }
Example #18
0
 public virtual void OnInit(BlockProvider blockProvider)
 {
 }
Example #19
0
    public override void OnInit(BlockProvider blockProvider)
    {
        base.OnInit(blockProvider);

        textures = ((CubeBlockConfig)Config).textures;
    }
Example #20
0
    public override void OnInit(BlockProvider blockProvider)
    {
        base.OnInit(blockProvider);

        Custom = true;
    }
Example #21
0
 public void DecideBlock(BlockProvider blockProvider)
 {
     blockManager.DecideOwner(blockProvider, onwer);
 }
Example #22
0
    public BlockProvider InstantiateBlock()
    {
        BlockProvider newBlock = Instantiate(basicBlockProvider) as BlockProvider;

        return(newBlock);
    }
Example #23
0
        public static void HandlePlayerDiggingPacket(IPacket _packet, IRemoteClient _client, IMultiplayerServer server)
        {
            var   packet     = (PlayerDiggingPacket)_packet;
            var   client     = (RemoteClient)_client;
            var   world      = _client.World;
            var   position   = new Coordinates3D(packet.X, packet.Y, packet.Z);
            var   descriptor = world.GetBlockData(position);
            var   provider   = server.BlockRepository.GetBlockProvider(descriptor.ID);
            short damage;
            int   time;

            switch (packet.PlayerAction)
            {
            case PlayerDiggingPacket.Action.DropItem:
                // Throwing item
                if (client.SelectedItem.Empty)
                {
                    break;
                }
                var spawned = client.SelectedItem;
                spawned.Count = 1;
                var inventory = client.SelectedItem;
                inventory.Count--;
                var item = new ItemEntity(client.Entity.Position + new Vector3(0, PlayerEntity.Height, 0), spawned);
                item.Velocity = MathHelper.FowardVector(client.Entity.Yaw) * 0.3;
                client.Inventory[client.SelectedSlot] = inventory;
                server.GetEntityManagerForWorld(client.World).SpawnEntity(item);
                break;

            case PlayerDiggingPacket.Action.StartDigging:
                foreach (var nearbyClient in server.Clients)     // TODO: Send this repeatedly during the course of the digging
                {
                    var c = (RemoteClient)nearbyClient;
                    if (c.KnownEntities.Contains(client.Entity))
                    {
                        c.QueuePacket(new AnimationPacket(client.Entity.EntityID, AnimationPacket.PlayerAnimation.SwingArm));
                    }
                }
                if (provider == null)
                {
                    server.SendMessage(ChatColor.Red + "WARNING: block provider for ID {0} is null (player digging)", descriptor.ID);
                }
                else
                {
                    provider.BlockLeftClicked(descriptor, packet.Face, world, client);
                }

                // "But why on Earth does this behavior change if you use shears on leaves?"
                // "This is poor seperation of concerns"
                // "Let me do a git blame and flame whoever wrote the next line"
                // To answer all of those questions, here:
                // Minecraft sends a player digging packet when the player starts and stops digging a block (two packets)
                // However, it only sends ONE packet if the block would be mined immediately - which usually is only the case
                // for blocks that have a hardness equal to zero.
                // The exception to this rule is shears on leaves. Leaves normally have a hardness of 0.2, but when you mine them
                // using shears the client only sends the start digging packet and expects them to be mined immediately.
                // So if you want to blame anyone, send flames to Notch for the stupid idea of not sending "stop digging" packets
                // for hardness == 0 blocks.

                time = BlockProvider.GetHarvestTime(descriptor.ID, client.SelectedItem.ID, out damage);
                if (time <= 20)
                {
                    provider.BlockMined(descriptor, packet.Face, world, client);
                    break;
                }
                client.ExpectedDigComplete = DateTime.UtcNow.AddMilliseconds(time);
                break;

            case PlayerDiggingPacket.Action.StopDigging:
                foreach (var nearbyClient in server.Clients)
                {
                    var c = (RemoteClient)nearbyClient;
                    if (c.KnownEntities.Contains(client.Entity))
                    {
                        c.QueuePacket(new AnimationPacket(client.Entity.EntityID, AnimationPacket.PlayerAnimation.None));
                    }
                }
                if (provider != null && descriptor.ID != 0)
                {
                    time = BlockProvider.GetHarvestTime(descriptor.ID, client.SelectedItem.ID, out damage);
                    if (time <= 20)
                    {
                        break;     // Already handled earlier
                    }
                    var diff = (DateTime.UtcNow - client.ExpectedDigComplete).TotalMilliseconds;
                    if (diff > -100)     // Allow a small tolerance
                    {
                        provider.BlockMined(descriptor, packet.Face, world, client);
                        // Damage the item
                        if (damage != 0)
                        {
                            var tool = server.ItemRepository.GetItemProvider(client.SelectedItem.ID) as ToolItem;
                            if (tool != null && tool.Uses != -1)
                            {
                                var slot = client.SelectedItem;
                                slot.Metadata += damage;
                                if (slot.Metadata >= tool.Uses)
                                {
                                    slot.Count = 0;     // Destroy item
                                }
                                client.Inventory[client.SelectedSlot] = slot;
                            }
                        }
                    }
                }
                break;
            }
        }
Example #24
0
    public override void OnInit(BlockProvider blockProvider)
    {
        base.OnInit(blockProvider);

        colors = ((ColoredBlockConfig)Config).colors;
    }
Example #25
0
 public static void GetTransaction(BlockProvider blockProvider, int blockIndex, int txIndex, out Block block, out Transaction tx)
 {
     block = blockProvider.GetBlock(blockIndex);
     tx    = block.Transactions[txIndex];
 }
Example #26
0
        protected override void Init()
        {
            base.Init();

            if (_articleProvider == null)
                _articleProvider = new ArticleProvider();
            if (_localizationProvider == null)
                _localizationProvider = new LocalizationProvider();
            if (_layoutProvider == null)
                _layoutProvider = new LayoutProvider();
            if (_pageProvider == null)
                _pageProvider = new PageProvider();
            if (_blockProvider == null)
                _blockProvider = new BlockProvider();

            if (IsEdit)
            {
                Title = "Edit Article | " + CoreSettings.CurrentSite.Name;
                ltlTitle.Text = "Edit Article";
            }
            else
            {
                Title = "New Article | " + CoreSettings.CurrentSite.Name;
                ltlTitle.Text = "New Article";
            }
            FillLanguages();
            FillPages();
            FillLayouts();
        }
Example #27
0
 protected override void Init()
 {
     base.Init();
     if (_blockProvider == null)
         _blockProvider = new BlockProvider();
     if (_pageProvider == null)
         _pageProvider = new PageProvider();
     if (_pageNBlockProvider == null)
         _pageNBlockProvider = new PageNBlockProvider();
 }
Example #28
0
        protected override void Init()
        {
            base.Init();

            if (_layoutProvider == null)
                _layoutProvider = new LayoutProvider();
            if (_layoutWebPartZoneProvider == null)
                _layoutWebPartZoneProvider = new LayoutWebPartZoneProvider();
            if (_webPartProvider == null)
                _webPartProvider = new WebPartProvider();
            if (_blockProvider == null)
                _blockProvider = new BlockProvider();
            if (_layoutNBlockProvider == null)
                _layoutNBlockProvider = new LayoutNBlockProvider();
            if (_localizationProvider == null)
                _localizationProvider = new LocalizationProvider();

            if (IsEdit)
            {
                Title = "Edit Block | " + CoreSettings.CurrentSite.Name;
                ltlTitle.Text = "Edit Block";
            }
            else
            {
                Title = "New Block | " + CoreSettings.CurrentSite.Name;
                ltlTitle.Text = "New Block";
            }
            FillLanguages();
        }
 public async Task <Block> GetLastBlock()
 {
     return(await BlockProvider.GetLastBlock());
 }
Example #30
0
 public void TestInitialize()
 {
     provider = new FileSystemBlockProvider();
     //provider = new BlockExplorerProvider();
     logger = new ScriptLogger();
 }
Example #31
0
 public override void OnInit(BlockProvider blockProvider)
 {
     dirt  = new BlockData(blockProvider.GetBlock("dirt").type);
     air   = new BlockData(blockProvider.GetBlock("air").type);
     grass = new BlockData(blockProvider.GetBlock("grass").type);
 }
 public async Task <Block> GetBlock(string id)
 {
     return(await BlockProvider.GetBlock(id));
 }