Exemplo n.º 1
0
        /// <summary>
        /// Käy kentän kaikki merkit läpi ja kutsuu <c>SetTileMethod</c>-metodilla annettuja
        /// aliohjelmia kunkin merkin kohdalla.
        /// </summary>
        /// <remarks>
        /// Aliohjelmassa voi esimerkiksi luoda olion ruudun kohdalle.
        /// </remarks>
        /// <param name="tileWidth">Yhden ruudun leveys.</param>
        /// <param name="tileHeight">Yhden ruudun korkeus.</param>
        public void Execute(double tileWidth, double tileHeight)
        {
            Game game   = Game.Instance;
            int  width  = tiles.GetLength(1);
            int  height = tiles.GetLength(0);

            game.Level.Width  = width * tileWidth;
            game.Level.Height = height * tileHeight;

            foreach (var m in optimized)
            {
                m.Invoke(tileWidth, tileHeight);
            }

            for (int y = height - 1; y >= 0; y--)
            {
                for (int x = 0; x < width; x++)
                {
                    TileMethod method = GetMethodForSymbol(tiles[y, x]);

                    if (method != null)
                    {
                        double realX = game.Level.Left + (x * tileWidth) + (tileWidth / 2);
                        double realY = game.Level.Top - (y * tileHeight) - (tileHeight / 2);
                        method(new Vector(realX, realY), tileWidth, tileHeight);
                    }
                }
            }
        }
Exemplo n.º 2
0
        /// <summary>
        /// Optimoi annetut ruudut niin, että useammat vierekkäiset oliot yhdistetään
        /// isommiksi olioiksi. Älä käytä esim. kerättäville esineille.
        /// </summary>
        /// <param name="sym">Optimoitava symboli</param>
        public void Optimize(TileType sym)
        {
            TileMethod method = GetMethodForSymbol(sym);

            if (method == null)
            {
                throw new ArgumentException("Symbol " + sym + " not added, cannot optimize.");
            }

            for (int row = 0; row < RowCount; row++)
            {
                for (int col = 0; col < ColumnCount; col++)
                {
                    int w, h;
                    GetGreatestMatchingRectangle(sym, row, col, out w, out h);

                    if (w > 0 && h > 0)
                    {
                        TileMethod newMethod = delegate(Vector oldPos, double oldWidth, double oldHeight)
                        {
                            Vector oldAdjust = new Vector(-oldWidth, oldHeight);
                            Vector newAdjust = new Vector(oldWidth * w, -oldHeight * h);
                            Vector newPos    = oldPos + (oldAdjust + newAdjust) / 2;
                            method(newPos, oldWidth * w, oldHeight * h);
                        };
                        optimized.Add(new TileMethodCall(newMethod, row, col));
                        SetArea(row, col, w, h, Null);
                        col += w;
                    }
                }
            }
        }
Exemplo n.º 3
0
 /// <summary>
 /// Määrittää, että tietyn ruutukentän symbolin (<c>tileSymbol</c>) kohdalla
 /// kutsutaan aliohjelmaa <c>f</c>. Huom! Käytä tämän aliohjelman kanssa metodia
 /// Execute.
 /// </summary>
 /// <typeparam name="T1">Parametrin tyyppi</typeparam>
 /// <param name="tileSymbol">Merkki</param>
 /// <param name="f">Aliohjelma muotoa void LuoOlio(Vector paikka, double leveys, double korkeus)</param>
 /// <param name="p1">Parametri</param>
 public void SetTileMethod <T1>(TileType tileSymbol, TileMethod <T1> f, T1 p1)
 {
     legend[tileSymbol] = delegate(Vector p, double w, double h) { f(p, w, h, p1); };
 }
Exemplo n.º 4
0
 /// <summary>
 /// Määrittää, että tietyn ruutukentän symbolin (<c>tileSymbol</c>) kohdalla
 /// kutsutaan aliohjelmaa <c>f</c>. Huom! Käytä tämän aliohjelman kanssa metodia
 /// Execute.
 /// </summary>
 /// <param name="tileSymbol">Merkki</param>
 /// <param name="f">Aliohjelma muotoa void LuoOlio(Vector paikka, double leveys, double korkeus)</param>
 public void SetTileMethod(TileType tileSymbol, TileMethod f)
 {
     legend[tileSymbol] = f;
 }
Exemplo n.º 5
0
 /// <summary>
 /// Muuttaa luontialiohjelman tekemän olion kokoa tietyllä kertoimilla.
 /// </summary>
 /// <param name="m">Luontialiohjelma</param>
 /// <param name="widthMultiplier">Kerroin alkuperäiselle leveydelle</param>
 /// <param name="heightMultiplier">Kerroin alkuperäiselle korkeudelle</param>
 /// <returns></returns>
 public static TileMethod ChangeSizeMultiplier(TileMethod m, double widthMultiplier, double heightMultiplier)
 {
     return(new TileMethod(delegate(Vector p, double w, double h) { m(p, w * widthMultiplier, h * heightMultiplier); }));
 }
Exemplo n.º 6
0
 /// <summary>
 /// Muuttaa luontialiohjelman tekemän olion kokoa.
 /// </summary>
 /// <param name="m">Luontialiohjelma</param>
 /// <param name="newWidth">Uusi leveys oliolle</param>
 /// <param name="newHeight">Uusi korkeus oliolle</param>
 /// <returns></returns>
 public static TileMethod ChangeSize(TileMethod m, double newWidth, double newHeight)
 {
     return(new TileMethod(delegate(Vector p, double w, double h) { m(p, newWidth, newHeight); }));
 }
Exemplo n.º 7
0
 public TileMethodCall(TileMethod m, int row, int col)
 {
     this.method = m;
     this.row    = row;
     this.col    = col;
 }
Exemplo n.º 8
0
 /// <summary>
 /// Määrittää, että tietyn ruutukentän symbolin (<c>tileSymbol</c>) kohdalla
 /// kutsutaan aliohjelmaa <c>f</c>. Huom! Käytä tämän aliohjelman kanssa metodia
 /// Execute.
 /// </summary>
 /// <typeparam name="T1">Ensimmäisen parametrin tyyppi</typeparam>
 /// <typeparam name="T2">Toisen parametrin tyyppi</typeparam>
 /// <typeparam name="T3">Kolmannen parametrin tyyppi</typeparam>
 /// <param name="tileSymbol">Merkki</param>
 /// <param name="f">Aliohjelma muotoa void LuoOlio(Vector paikka, double leveys, double korkeus)</param>
 /// <param name="p1">Ensimmäinen parametri</param>
 /// <param name="p2">Toinen parametri</param>
 /// <param name="p3">Kolmas parametri</param>
 public void SetTileMethod <T1, T2, T3>(TileType tileSymbol, TileMethod <T1, T2, T3> f, T1 p1, T2 p2, T3 p3)
 {
     legend[tileSymbol] = delegate(Vector p, double w, double h) { f(p, w, h, p1, p2, p3); };
 }
Exemplo n.º 9
0
 /// <summary>
 /// Määrittää, että tietyn ruutukentän merkin (<c>tileSymbol</c>) kohdalla
 /// kutsutaan aliohjelmaa <c>f</c>. Huom! Käytä tämän aliohjelman kanssa metodia
 /// <c>Execute</c> eikä <c>Insert</c>.
 /// </summary>
 public void SetTileMethod(char tileSymbol, TileMethod f, object arguments = null)
 {
     legend[tileSymbol] = f;
     args[tileSymbol] = arguments;
 }
Exemplo n.º 10
0
 /// <summary>
 /// Määrittää, että tietyn ruutukentän symbolin (<c>tileSymbol</c>) kohdalla
 /// kutsutaan aliohjelmaa <c>f</c>. Huom! Käytä tämän aliohjelman kanssa metodia
 /// Execute.
 /// </summary>
 /// <typeparam name="T1">Ensimmäisen parametrin tyyppi</typeparam>
 /// <typeparam name="T2">Toisen parametrin tyyppi</typeparam>
 /// <typeparam name="T3">Kolmannen parametrin tyyppi</typeparam>
 /// <typeparam name="T4">Neljännen parametrin tyyppi</typeparam>
 /// <typeparam name="T5">Viidennen parametrin tyyppi</typeparam>
 /// <typeparam name="T6">Kuudennen parametrin tyyppi</typeparam>
 /// <param name="tileSymbol">Merkki</param>
 /// <param name="f">Aliohjelma muotoa void LuoOlio(Vector paikka, double leveys, double korkeus)</param>
 /// <param name="p1">Ensimmäinen parametri</param>
 /// <param name="p2">Toinen parametri</param>
 /// <param name="p3">Kolmas parametri</param>
 /// <param name="p4">Neljäs parametri</param>
 /// <param name="p5">Viides parametri</param>
 /// <param name="p6">Kuudes parametri</param>
 public void SetTileMethod <T1, T2, T3, T4, T5, T6>(TileType tileSymbol, TileMethod <T1, T2, T3, T4, T5, T6> f, T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6)
 {
     legend[tileSymbol] = delegate(Vector p, double w, double h)
     { f(p, w, h, p1, p2, p3, p4, p5, p6); };
 }
Exemplo n.º 11
0
 /// <summary>
 /// Määrittää, että tietyn ruutukentän symbolin (<c>tileSymbol</c>) kohdalla
 /// kutsutaan aliohjelmaa <c>f</c>. Huom! Käytä tämän aliohjelman kanssa metodia
 /// Execute.
 /// </summary>
 /// <param name="hexCode">Heksakoodi värille</param>
 /// <param name="method">Aliohjelma</param>
 /// <param name="p1">Parametri</param>
 public void SetTileMethod <T1>(string hexCode, TileMethod <T1> method, T1 p1)
 {
     SetTileMethod(Color.FromHexCode(hexCode), method, p1);
 }
Exemplo n.º 12
0
 /// <summary>
 /// Määrittää, että tietyn ruutukentän symbolin (<c>tileSymbol</c>) kohdalla
 /// kutsutaan aliohjelmaa <c>f</c>. Huom! Käytä tämän aliohjelman kanssa metodia
 /// Execute.
 /// </summary>
 /// <param name="hexCode">Heksakoodi värille</param>
 /// <param name="method">Aliohjelma</param>
 public void SetTileMethod(string hexCode, TileMethod method)
 {
     SetTileMethod(Color.FromHexCode(hexCode), method);
 }
Exemplo n.º 13
0
 /// <summary>
 /// Määrittää, että tietyn ruutukentän symbolin (<c>tileSymbol</c>) kohdalla
 /// kutsutaan aliohjelmaa <c>f</c>. Huom! Käytä tämän aliohjelman kanssa metodia
 /// Execute.
 /// </summary>
 /// <param name="hexCode">Heksakoodi värille</param>
 /// <param name="method">Aliohjelma</param>
 /// <param name="p1">Parametri</param>
 /// <param name="p2">Parametri</param>
 /// <param name="p3">Parametri</param>
 public void SetTileMethod <T1, T2, T3>(string hexCode, TileMethod <T1, T2, T3> method, T1 p1, T2 p2, T3 p3)
 {
     SetTileMethod(Color.FromHexCode(hexCode), method, p1, p2, p3);
 }