コード例 #1
0
 // Constructor
 public LevelsSolidTiles(Solidity solids, Delegate update)
 {
     this.solids = solids;
     this.update = update;
     InitializeComponent();
     RefreshPhysicalTile();
     SearchSolidTile = new SearchSolidTile(this, solidityTiles);
 }
コード例 #2
0
 public SolidityVisitor()
 {
     Solidity = new Solidity
     {
         Contracts = new List <Solidity.Contract>(),
         Imports   = new List <string>()
     };
 }
コード例 #3
0
ファイル: Tile.cs プロジェクト: Skippeh/Pokemon-RPG
 /// <summary>
 /// 
 /// </summary>
 /// <param name="id">The type of this tile.</param>
 /// <param name="solidityType"></param>
 /// <param name="textureSourceRectangle">The appropriate source rectangle to use. see <c>SourceRects</c>.</param>
 /// <param name="drawColor"></param>
 public Tile(TileId id, Solidity solidityType, Rectangle textureSourceRectangle, Color drawColor, TileSide tileSide)
 {
     this.Id = id;
     this.SolidityType = solidityType;
     this.SourceRectangle = textureSourceRectangle;
     this.DrawColor = drawColor;
     this.Side = tileSide;
 }
コード例 #4
0
        private async void OnPurchaseButton(object sender, EventArgs args)
        {
            await Task.Run(() =>
            {
                Solidity.PurchaseCard(Solidity.MyAddress, Solidity.MyPrivateKey);
            });

            await DisplayAlert("Gratz", "Bought! Refresh to see.", "Yay!");
        }
コード例 #5
0
        public void HealNotWorksOnDeathObject()
        {
            var deathSolidity  = new Solidity(_MAX_HEALTH, _DEFENCE, 0, 0);
            var expectedHealth = 0;

            deathSolidity.Heal(10);

            Assert.AreEqual(expectedHealth, deathSolidity.CurrentHealth);
        }
コード例 #6
0
        public void HealWorksOnAliveObject()
        {
            var health         = 10;
            var aliveSolidity  = new Solidity(_MAX_HEALTH, _DEFENCE, 0, health);
            var healPoints     = 30;
            var expectedHealth = healPoints + health;

            aliveSolidity.Heal(healPoints);

            Assert.AreEqual(expectedHealth, aliveSolidity.CurrentHealth);
        }
コード例 #7
0
        public TileData(string _name, Solidity _solidity, int _id, ContentManager content, TileBehaviour _behaviour = null, Category _category = Category.NONE)
        {
            name = _name;
            id   = _id;

            if (File.Exists("Content/Tiles/" + name + ".xnb"))
            {
                texture = content.Load <Texture2D>("Tiles/" + _name);
            }

            solidity = _solidity;

            behaviour = _behaviour;

            category = _category;
        }
コード例 #8
0
        private async void HandleSend(object sender, string address)
        {
            SendPopup.AddressEvent -= HandleSend;
            if (Solidity.MyAddress.Equals(address, StringComparison.CurrentCultureIgnoreCase))
            {
                await DisplayAlert("Bad address", "You can't send to yourself!", "OK");

                await PopupNavigation.Instance.RemovePageAsync(popup);

                return;
            }
            await Task.Run(() =>
            {
                Device.BeginInvokeOnMainThread(() =>
                {
                    popup.SendButton.IsVisible = false;
                });
                Solidity.ApproveForMe(Card.Token);
                Solidity.SafeTransferFromMe(address, Card.Token);
            });

            await PopupNavigation.Instance.RemovePageAsync(popup);
        }
コード例 #9
0
 /// <summary>
 /// Returns true if the given direction's face is solid
 /// </summary>
 /// <param name="dir">The direction to check</param>
 /// <returns></returns>
 public bool IsSolid(OrdinalDirections dir)
 {
     return(Solidity.GetBoolForDir(dir));
 }
コード例 #10
0
 /// <inheritdoc cref="Arc(Nvg, float, float, float, float, float, Winding)"/><br/>
 public static void Arc(this Nvg nvg, float cx, float cy, float r, float a0, float a1, Solidity solidity)
 => Arc(nvg, new Vector2D <float>(cx, cy), r, a0, a1, (Winding)solidity);
コード例 #11
0
 /// <inheritdoc cref="Arc(Nvg, Vector2D{float}, float, float, float, Winding)"/><br/>
 public static void Arc(this Nvg nvg, Vector2D <float> c, float r, float a0, float a1, Solidity solidity)
 => Arc(nvg, c, r, a0, a1, (Winding)solidity);
コード例 #12
0
 /// <inheritdoc cref="PathWinding(Nvg, Winding)"/><br/>
 public static void PathWinding(this Nvg nvg, Solidity sol)
 => PathWinding(nvg, (Winding)sol);
コード例 #13
0
ファイル: MainGame.cs プロジェクト: littlebeast/Outpost
        //possible efficiency increaser: create a combined get+change block function

        /// <summary>
        /// NOT FULLY IMPLEMENTED: Does not use the x/z size.  Or the direction, for that matter.
        /// ALSO, does not wrap outside of the chunk.
        /// </summary>
        /// <param name="chunkBase">The chunk containing the entity</param>
        /// <param name="posInChunk">The entity's position in the chunk</param>
        /// <param name="direction">The direction the entity is facing, for bounding-box purposes</param>
        /// <param name="size">The size of the entity</param>
        /// <returns></returns>
        public Solidity[][][] detectCollision(IntVector3 chunkBase, Vector3 posInChunk, Vector3 direction, IntVector3 size)
        {
            IntVector3 mappedChunk = chunkBase - mapOffset;

            if (posInChunk.X < 0)
            {
                posInChunk.X += 16;
                mappedChunk = mappedChunk + new IntVector3(-1, 0, 0);
            }
            if (posInChunk.X > 16)
            {
                posInChunk.X -= 16;
                mappedChunk = mappedChunk + new IntVector3(1, 0, 0);
            }
            if (posInChunk.Y < 0)
            {
                posInChunk.Y += 16;
                mappedChunk = mappedChunk + new IntVector3(0, -1, 0);
            }
            if (posInChunk.Y > 16)
            {
                posInChunk.Y -= 16;
                mappedChunk = mappedChunk + new IntVector3( 0, 1,0);
            }
            if (posInChunk.Z < 0)
            {
                posInChunk.Z += 16;
                mappedChunk = mappedChunk + new IntVector3(0, 0, -1);
            }
            if (posInChunk.Z < 0)
            {
                posInChunk.Z += 16;
                mappedChunk = mappedChunk + new IntVector3(0, 0, 1);
            }

            Chunk chunk = map.get(mappedChunk);
            Solidity[][][] collidingWith = new Solidity[1][][];
            for (int i = 0; i < collidingWith.Length; i++)
            {
                collidingWith[i] = new Solidity[size.Y + 1][];
                for (int j = 0; j < collidingWith[i].Length; j++)
                {
                    collidingWith[i][j] = new Solidity[1];
                }
            }
            //well that is a mess, but I can't really think of a better way to actually pass the dimensions...

            for (int y = 0; y < size.Y + 1; y++)
            {
                if (posInChunk.Y + y > 15)
                {
                    collidingWith[0][y][0] = Solidity.vacuum;
                    //Chunk temp = map.get(mappedChunk + new IntVector3(0,1,0));
                    //collidingWith[0][y][0] = temp.getBlock((int)Math.Floor(posInChunk.X), (int)Math.Floor(posInChunk.Y) + y - 16, (int)Math.Floor(posInChunk.Z));
                }
                else
                {
                    Block got = chunk.getBlock((int)Math.Floor(posInChunk.X), (int)Math.Floor(posInChunk.Y) + y, (int)Math.Floor(posInChunk.Z));
                    if (got == null)
                        collidingWith[0][y][0] = Solidity.vacuum;
                    else
                        collidingWith[0][y][0] = got.solidity;
                }
            }

            return collidingWith;
        }
コード例 #14
0
        public void BuildChunk(TileChunk chunk, bool isLayerOne)
        {
            if (isLayerOne)
            {
                if (chunk.HeightBlocks1.Truthy())
                    return;
                var hb1 = chunk.HeightBlocks1 = new Solidity[128][];
                var ab1 = chunk.AngleMap1 = new int[8][];
                for (var _1 = 0; _1 < 128; _1++)
                {
                    hb1[_1] = new Solidity[128];
                }
                for (var _1 = 0; _1 < 8; _1++)
                {
                    ab1[_1] = new int[8];
                }

                for (var _y = 0; _y < 8; _y++)
                {
                    for (var _x = 0; _x < 8; _x++)
                    {
                        var tp = chunk.TilePieces[_x][_y];

                        ab1[_x][_y] = tp.GetLayer1Angles();

                        if (!(ab1[_x][_y] == 0 || ab1[_x][_y] == 255 || ab1[_x][_y] == 1))
                        {
                            if (tp.XFlip)
                            {
                                if (tp.YFlip)
                                {
                                    ab1[_x][_y] = 192 - ab1[_x][_y] + 192;

                                    ab1[_x][_y] = 128 - ab1[_x][_y] + 128;
                                }
                                else
                                    ab1[_x][_y] = 128 - ab1[_x][_y] + 128;
                            }
                            else
                            {
                                if (tp.YFlip)
                                    ab1[_x][_y] = 192 - ab1[_x][_y] + 192;
                                else
                                    ab1[_x][_y] = (ab1[_x][_y]);
                            }
                        }

                        var __x = 0;
                        var __y = 0;

                        HeightMap heightMask = tp.GetLayer1HeightMaps();
                        int[] heightMaskItems = null;
                        if (heightMask == null) continue;
                        Solidity mj;
                        if (heightMask.Full != null)
                        {
                            mj = !heightMask.Full.Value ? 0 : tp.Solid1;
                            for (__y = 0; __y < 16; __y++)
                            {
                                for (__x = 0; __x < 16; __x++)
                                {
                                    hb1[(_x * 16 + __x)][(_y * 16 + __y)] = mj;
                                }
                            }
                        }
                        else
                            heightMaskItems = heightMask.Items;

                        for (__y = 0; __y < 16; __y++)
                        {
                            for (__x = 0; __x < 16; __x++)
                            {
                                var jx = 0;
                                var jy = 0;
                                if (tp.XFlip)
                                {
                                    if (tp.YFlip)
                                    {
                                        jx = 15 - __x;
                                        jy = 15 - __y;
                                    }
                                    else
                                    {
                                        jx = 15 - __x;
                                        jy = __y;
                                    }
                                }
                                else
                                {
                                    if (tp.YFlip)
                                    {
                                        jx = __x;
                                        jy = 15 - __y;
                                    }
                                    else
                                    {
                                        jx = __x;
                                        jy = __y;
                                    }
                                }

                                if (heightMask.Full == null)
                                {
                                    switch (tp.Solid1)
                                    {
                                        case 0:
                                            hb1[(_x * 16 + jx)][(_y * 16 + jy)] = 0;
                                            break;
                                        case (Solidity)1:
                                        case (Solidity)2:
                                        case (Solidity)3:
                                            hb1[(_x * 16 + jx)][(_y * 16 + jy)] = HeightMap.ItemsGood(heightMaskItems, __x, __y) ? tp.Solid1 : 0;
                                            break;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                if (chunk.HeightBlocks2.Truthy())
                    return;

                var hb2 = chunk.HeightBlocks2 = new Solidity[128][];
                var ab2 = chunk.AngleMap2 = new int[8][];
                for (var _1 = 0; _1 < 128; _1++)
                {
                    hb2[_1] = new Solidity[128];
                }
                for (var _1 = 0; _1 < 8; _1++)
                {
                    ab2[_1] = new int[8];
                }

                for (var _y = 0; _y < 8; _y++)
                {
                    for (var _x = 0; _x < 8; _x++)
                    {
                        var tp = chunk.TilePieces[_x][_y];

                        ab2[_x][_y] = tp.GetLayer2Angles();

                        if (!(ab2[_x][_y] == 0 || ab2[_x][_y] == 255 || ab2[_x][_y] == 1))
                        {
                            if (tp.XFlip)
                            {
                                if (tp.YFlip)
                                {
                                    ab2[_x][_y] = 192 - ab2[_x][_y] + 192;

                                    ab2[_x][_y] = 128 - ab2[_x][_y] + 128;
                                }
                                else
                                    ab2[_x][_y] = 128 - ab2[_x][_y] + 128;
                            }
                            else
                            {
                                if (tp.YFlip)
                                    ab2[_x][_y] = 192 - ab2[_x][_y] + 192;
                                else
                                    ab2[_x][_y] = (ab2[_x][_y]);
                            }
                        }

                        int __x;
                        int __y;
                        var hd2 = tp.GetLayer2HeightMaps();
                        if (hd2 == null) continue;
                        Solidity mj;

                        int[] hd2Items = null;

                        if (hd2.Full != null)
                        {
                            mj = hd2.Full == false ? 0 : tp.Solid2;
                            for (__y = 0; __y < 16; __y++)
                            {
                                for (__x = 0; __x < 16; __x++)
                                {
                                    hb2[(_x * 16 + __x)][(_y * 16 + __y)] = mj;
                                }
                            }
                        }
                        else
                            hd2Items = hd2.Items;

                        for (__y = 0; __y < 16; __y++)
                        {
                            for (__x = 0; __x < 16; __x++)
                            {
                                var jx = 0;
                                var jy = 0;
                                if (tp.XFlip)
                                {
                                    if (tp.YFlip)
                                    {
                                        jx = 15 - __x;
                                        jy = 15 - __y;
                                    }
                                    else
                                    {
                                        jx = 15 - __x;
                                        jy = __y;
                                    }
                                }
                                else
                                {
                                    if (tp.YFlip)
                                    {
                                        jx = __x;
                                        jy = 15 - __y;
                                    }
                                    else
                                    {
                                        jx = __x;
                                        jy = __y;
                                    }
                                }

                                if (hd2.Full == null)
                                {
                                    switch (tp.Solid2)
                                    {
                                        case (Solidity)0:
                                            hb2[(_x * 16 + jx)][(_y * 16 + jy)] = Solidity.NotSolid;
                                            break;
                                        case (Solidity)1:
                                        case (Solidity)2:
                                        case (Solidity)3:
                                            hb2[(_x * 16 + jx)][(_y * 16 + jy)] = HeightMap.ItemsGood(hd2Items, __x, __y) ? tp.Solid2 : 0;
                                            break;
                                    }
                                }

                                //imap[(x * 128 + _x * 16 + __x) + (y * 128 + _y * 16 + __y) * (SonicManager.Instance.SonicLevel.LevelWidth)] = tp.heightMask.angle;
                            }
                        }
                    }
                }
            }
        }
コード例 #15
0
        public void ObjectWithZeroHealthIsNotAlive()
        {
            var deadSolidity = new Solidity(_MAX_HEALTH, _DEFENCE, 0, 0);

            Assert.False(deadSolidity.IsAlive());
        }
コード例 #16
0
        public void ObjectWithNotZeroHealthIsAlive()
        {
            var aliveSolidity = new Solidity(_MAX_HEALTH, _DEFENCE, 0, 1);

            Assert.True(aliveSolidity.IsAlive());
        }
コード例 #17
0
 public void Setup()
 {
     _testSolidity = new Solidity(_MAX_HEALTH, _DEFENCE);
 }