コード例 #1
0
    void ChangeElement(int index, int newType)
    {
        var p = powders[index];

        PowderSystemUtils.SchdeduleRemovePowder(ref toDeleteEntities, index);
        PowderGame.Spawn(ref cmdBuffer, p.coord.x, p.coord.y, newType);
    }
コード例 #2
0
 public void Execute()
 {
     if (PowderTypes.values[type].IsGenerator())
     {
         if (!isPainting)
         {
             for (var x = coord.x - PowderGame.brushSize; x <= coord.x + PowderGame.brushSize; ++x)
             {
                 if (!PowderSystemUtils.IsOccupied(ref hashMap, x, coord.y))
                 {
                     PowderGame.Spawn(ref cmdBuffer, x, coord.y, type);
                 }
             }
         }
     }
     else
     {
         var size = 0;
         for (var y = coord.y - PowderGame.brushSize; y <= coord.y + PowderGame.brushSize; ++y)
         {
             for (var x = coord.x - size; x <= coord.x + size; ++x)
             {
                 if (!PowderSystemUtils.IsOccupied(ref hashMap, x, y))
                 {
                     PowderGame.Spawn(ref cmdBuffer, x, y, type);
                 }
             }
             size += y < coord.y ? 1 : -1;
         }
     }
 }
コード例 #3
0
 public int TopRight()
 {
     if (topRight == -2)
     {
         topRight = PowderSystemUtils.GetPowderIndex(ref positions, p.coord.x + 1, p.coord.y + 1);
     }
     return(topRight);
 }
コード例 #4
0
 public int Top()
 {
     if (top == -2)
     {
         top = PowderSystemUtils.GetPowderIndex(ref positions, p.coord.x, p.coord.y + 1);
     }
     return(top);
 }
コード例 #5
0
 public int BottomRight()
 {
     if (bottomRight == -2)
     {
         bottomRight = PowderSystemUtils.GetPowderIndex(ref positions, p.coord.x + 1, p.coord.y - 1);
     }
     return(bottomRight);
 }
コード例 #6
0
 public int Bottom()
 {
     if (bottom == -2)
     {
         bottom = PowderSystemUtils.GetPowderIndex(ref positions, p.coord.x, p.coord.y - 1);
     }
     return(bottom);
 }
コード例 #7
0
 public int Right()
 {
     if (right == -2)
     {
         right = PowderSystemUtils.GetPowderIndex(ref positions, p.coord.x + 1, p.coord.y);
     }
     return(right);
 }
コード例 #8
0
 public int Left()
 {
     if (left == -2)
     {
         left = PowderSystemUtils.GetPowderIndex(ref positions, p.coord.x - 1, p.coord.y);
     }
     return(left);
 }
コード例 #9
0
 void Lava(ref Powder p, ref Neighbors n)
 {
     if (!n.BottomEmpty() &&
         powders[n.Bottom()].type != PowderTypes.Fire &&
         powders[n.Bottom()].type != PowderTypes.Lava &&
         powders[n.Bottom()].type != PowderTypes.Stone
         )
     {
         PowderSystemUtils.SchdeduleRemovePowder(ref toDeleteEntities, n.Bottom());
     }
 }
コード例 #10
0
 void AcidTouch(int index)
 {
     if (powders[index].type != PowderTypes.Acid &&
         powders[index].type != PowderTypes.Fire &&
         powders[index].type != PowderTypes.Water &&
         powders[index].type != PowderTypes.Glass &&
         powders[index].type != PowderTypes.Lava
         )
     {
         PowderSystemUtils.SchdeduleRemovePowder(ref toDeleteEntities, index);
     }
 }
コード例 #11
0
 void Water(ref Powder p, ref Neighbors n)
 {
     if (!n.BottomEmpty())
     {
         if (powders[n.Bottom()].type == PowderTypes.Fire || powders[n.Bottom()].type == PowderTypes.Steam)
         {
             PowderSystemUtils.SchdeduleRemovePowder(ref toDeleteEntities, n.Bottom());
         }
         else if (powders[n.Bottom()].type == PowderTypes.Lava)
         {
             ChangeElement(n.index, PowderTypes.Steam);
         }
     }
 }
コード例 #12
0
    Powder Simulate(Powder p, int index)
    {
        if (p.life == 0 || p.coord.x < 0 || p.coord.x > PowderGame.width || p.coord.y < 0 || p.coord.y > PowderGame.height)
        {
            PowderSystemUtils.SchdeduleRemovePowder(ref toDeleteEntities, index);
            return(p);
        }

        if (p.life != -1)
        {
            p.life--;
        }

        var n = new Neighbors(ref hashMap, p, index);

        SimulateState(ref p, ref n);

        switch (p.type)
        {
        case PowderTypes.Acid:
            Acid(ref p, ref n);
            break;

        case PowderTypes.Fire:
            Fire(ref p, ref n);
            break;

        case PowderTypes.Steam:
            Steam(ref p, ref n);
            break;

        case PowderTypes.Water:
            Water(ref p, ref n);
            break;

        case PowderTypes.Lava:
            Lava(ref p, ref n);
            break;

        default:
            if (PowderTypes.values[p.type].IsGenerator())
            {
                Generate(ref p, ref n);
            }
            break;
        }
        return(p);
    }