コード例 #1
0
 /// <summary>
 /// Pistää annetun Kirjainlaatan takaisin KirjainlaattaPussin valikoimaan
 /// </summary>
 /// <param name="laatta">Kirjainlaatta joka laitetaan takaisin KirjainlaattaPussiin</param>
 public void PutBack(Kirjainlaatta laatta)
 {
     kirjainlaatat.Add(laatta);
     LaattojaJaljella++;
     // sekoitetaan pussin sisältö jotta takaisin pistetyt kirjainlaatat eivät ole aina viimeisinä
     Shuffle();
 }
コード例 #2
0
        /// <summary>
        /// Käsittelijä Kirjainlaatan tekstivärin arvon muutoksille
        /// </summary>
        /// <param name="obj">Kirjainlaatta jossa muutos tapahtui</param>
        /// <param name="args">argumentit</param>
        private static void OnTextColorChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
        {
            Kirjainlaatta laatta = (Kirjainlaatta)obj;

            laatta.kirjainLabel.Foreground   = (SolidColorBrush)args.NewValue;
            laatta.pistearvoLabel.Foreground = (SolidColorBrush)args.NewValue;
        }
コード例 #3
0
 /// <summary>
 /// Kertoo sisältääkö KirjainlaattaHolder komponentti tietyn Kirjainlaatan
 /// </summary>
 /// <param name="k">Kirjainlaatta jota etsitään</param>
 /// <returns>Boolean arvon joka ilmaisee löydettiinkö määriteltyä Kirjainlaattaa vaiko ei</returns>
 public Boolean Contains(Kirjainlaatta k)
 {
     if (kirjainlaattaHolder.Children.Contains(k))
     {
         return(true);
     }
     return(false);
 }
コード例 #4
0
        /// <summary>
        /// Käsittelijä Kirjainlaatan tekstivärin arvon muutoksille
        /// </summary>
        /// <param name="obj">Kirjainlaatta jossa muutos tapahtui</param>
        /// <param name="args">argumentit</param>
        private static void OnActiveTextColorChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
        {
            Kirjainlaatta laatta = (Kirjainlaatta)obj;

            if (laatta.Aktiivinen)
            {
                laatta.TextColor = (SolidColorBrush)args.NewValue;
            }
        }
コード例 #5
0
 /// <summary>
 /// Lisää halutun Kirjainlaatan KirjainlaattaHolderiin ja päivittää LaattojaPaikalla
 /// dependency propertyn arvon.
 /// </summary>
 /// <param name="laatta">KirjainlaattaHolderiin lisättävä Kirjainlaatta</param>
 public void AddObjectToHolder(Kirjainlaatta laatta)
 {
     if (LaattojaPaikalla < MaxLukumaara)
     {
         kirjainlaattaHolder.Children.Add(laatta);
         laatta.Aktiivinen = true;
         LaattojaPaikalla++;
     }
 }
コード例 #6
0
        /// <summary>
        /// Käsittelijä epäaktiivisen Kirjainlaatan täyttövärin arvon muutoksille
        /// </summary>
        /// <param name="obj">Kirjainlaatta jossa muutos tapahtui</param>
        /// <param name="args">argumentit</param>
        private static void OnInactiveFillColorChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
        {
            Kirjainlaatta laatta = (Kirjainlaatta)obj;

            if (laatta.Aktiivinen)
            {
                return;
            }
            laatta.FillColor = (SolidColorBrush)args.NewValue;
        }
コード例 #7
0
 /// <summary>
 /// Poistaa halutun Kirjainlaatan KirjainlaattaHolderista ja päivittää LaattojaPaikalla
 /// dependency propertyn arvon.
 /// </summary>
 /// <param name="laatta"></param>
 public void RemoveObjectFromHolder(Kirjainlaatta laatta)
 {
     if (kirjainlaattaHolder.Children.Contains(laatta))
     {
         kirjainlaattaHolder.Children.Remove(laatta);
         if (LaattojaPaikalla > 0)
         {
             LaattojaPaikalla--;
         }
     }
 }
コード例 #8
0
        /// <summary>
        /// Sekoittaa Kirjainlaatat sattumanvaraiseen järjestykseen käyttäen
        /// yksinkertaista toteutusta Fisher-Yates sekoitusalgoritmista.
        /// </summary>
        private void Shuffle()
        {
            Random random = new Random();

            for (int i = kirjainlaatat.Count; i > 1; i--)
            {
                int           j    = random.Next(i);
                Kirjainlaatta temp = kirjainlaatat[j];
                kirjainlaatat[j]     = kirjainlaatat[i - 1];
                kirjainlaatat[i - 1] = temp;
            }
        }
コード例 #9
0
ファイル: Pelilauta.xaml.cs プロジェクト: saviit/Wordinator
 /// <summary>
 /// Palauttaa listan kaikista tämän kierroksen aikana (Aktiivinen == true)
 /// pelilaudalle lisätyistä kirjainlaatoista
 /// </summary>
 /// <returns>lista pelilaudalla olevista aktiivisista kirjainlaatoista</returns>
 public List <Kirjainlaatta> GetAktiivisetLaudalleLisatyt()
 {
     laudalleLisatyt.Clear();
     foreach (PelilautaRuutu ruutu in canvas.Children)
     {
         Kirjainlaatta laatta = ruutu.GetKirjainlaatta();
         if (ruutu.RuutuSisaltaaLaatan && laatta.Aktiivinen == true)
         {
             laudalleLisatyt.Add(laatta);
         }
     }
     return(laudalleLisatyt);
 }
コード例 #10
0
ファイル: Pelilauta.xaml.cs プロジェクト: saviit/Wordinator
        /// <summary>
        /// Palauttaa listan kaikista pelilaudalle lisätyistä kirjainlaatoista
        /// </summary>
        /// <returns>lista pelilaudalla olevista kirjainlaatoista</returns>
        public List <Kirjainlaatta> GetLaudalleLisatyt()
        {
            List <Kirjainlaatta> kaikkiLisatyt = new List <Kirjainlaatta>();

            foreach (PelilautaRuutu ruutu in canvas.Children)
            {
                Kirjainlaatta laatta = ruutu.GetKirjainlaatta();
                if (ruutu.RuutuSisaltaaLaatan && laatta != null)
                {
                    kaikkiLisatyt.Add(laatta);
                }
            }
            return(kaikkiLisatyt);
        }
コード例 #11
0
        /// <summary>
        /// Käsittelijä Kirjainlaatan Aktiivinen-propertyn arvon muutoksille. Vaihdetaan Kirjainlaatan taustaväriä
        /// sen mukaan, mikä Kirjainlaatan 'status' on.
        /// </summary>
        /// <param name="obj">Objekti jossa propertyn arvon muutos tapahtui</param>
        /// <param name="args">Muutostapahtuman argumentit</param>
        private static void OnAktiivinenChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
        {
            Kirjainlaatta laatta = obj as Kirjainlaatta;

            if (args.NewValue.Equals(false))
            {
                laatta.FillColor   = laatta.InactiveFillColor;
                laatta.BorderColor = laatta.InactiveBorderColor;
            }
            //else
            //{
            //    laatta.FillColor = laatta.ActiveFillColor;
            //    laatta.BorderColor = laatta.ActiveBorderColor;
            //}
        }
コード例 #12
0
 /// <summary>
 /// Alustaa kirjainlaatat peliin
 /// </summary>
 /// <param name="colors">värit jotka laatalle annetaan</param>
 private void LuoKirjainLaatat(List <SolidColorBrush> colors)
 {
     foreach (KirjainlaattaSaannot saanto in kirjaimet)
     {
         for (int i = 0; i < saanto.GetLkm(); i++)
         {
             Kirjainlaatta laatta = new Kirjainlaatta(saanto.GetKirjain(), saanto.GetPistearvo());
             laatta.Aktiivinen          = true;
             laatta.FillColor           = colors[0];
             laatta.BorderColor         = colors[1];
             laatta.InactiveFillColor   = colors[2];
             laatta.InactiveBorderColor = colors[3];
             kirjainlaatat.Add(laatta);
         }
     }
 }
コード例 #13
0
        /// <summary>
        /// Käsittelijä KirjainlaattaHolderin Drop-eventille. Kaivetaan Kirjainlaatta
        /// raahausdatasta ja lisätään se holderiin, samalla poistetaan Kirjainlaatta sen edellisestä
        /// sijainnista.
        /// </summary>
        /// <param name="sender">objekti joka laukaisi tapahtuman</param>
        /// <param name="e">argumentit</param>
        private void kirjainlaattaHolder_Drop(object sender, DragEventArgs e)
        {
            Kirjainlaatta laatta = e.Data.GetData(typeof(Kirjainlaatta)) as Kirjainlaatta;
            StackPanel    parent = laatta.Parent as StackPanel;

            //KirjainlaattaHolderin sisällä ei ole järkeä drag&dropata
            if (parent.Parent.GetType().Equals(typeof(KirjainlaattaHolder)))
            {
                return;
            }
            parent.Children.Remove(laatta);
            // Jos laatta oli alunperin tyhjä laatta (pistearvo == 0),
            // poistetaan sen sisältämä Kirjain, jottei sitä sekoiteta muihin
            //Kirjainlaattoihin
            if (laatta.Pistearvo == 0)
            {
                laatta.Kirjain = "";
            }
            AddObjectToHolder(laatta);
        }
コード例 #14
0
        /// <summary>
        /// Käsittelijä Pelilaudan ruutujen Drop-tapahtumille
        /// </summary>
        /// <param name="sender">PelilautaRuutu joka laukaisi tapahtuman</param>
        /// <param name="e">Raahaustapahtuman argumentit, käytännössä data (pelilaudalle pudotettava
        ///  Kirjainlaatta) jota kuljetettiin</param>
        void PelilautaRuutu_Drop(object sender, DragEventArgs e)
        {
            this.border.BorderBrush = originalBorderColor;
            Kirjainlaatta laatta = e.Data.GetData(typeof(Kirjainlaatta)) as Kirjainlaatta;

            StackPanel parent = laatta.Parent as StackPanel;

            if (((PelilautaRuutu)sender).RuutuSisaltaaLaatan != true)
            {
                if (parent.Parent is KirjainlaattaHolder)
                {
                    (parent.Parent as KirjainlaattaHolder).RemoveObjectFromHolder(laatta);
                }
                else
                {
                    parent.Children.Remove(laatta);
                }
                laatta.PositionX = this.PositionX;
                laatta.PositionY = this.PositionY;
                //this.KirjainlaattaContainer = laatta;
                this.RuutuSisaltaaLaatan = true;
                this.kirjainlaattaContainer.Children.Add(laatta);

                // Jos lisätty laatta on 'wildcard' laatta eli tyhjä laatta
                // aiheutetaan routed event jolla kerrotaan pääohjelmalle
                // että käyttäjältä pitää kysyä mitä kirjainta tyhjällä laatalla
                // halutaan esittää
                if (laatta.Pistearvo == 0)
                {
                    RaiseLisattiinTyhjaLaattaEvent();
                }
            }
            else
            {
                // Jos ruudussa on jo Kirjainlaatta, sen ruudun päälle ei voi raahata
                e.Effects = DragDropEffects.None;
            }
            laatta    = null;
            e.Handled = true;
        }
コード例 #15
0
        /// <summary>
        /// Käsittelijä Kirjainlaatan Kirjain-propertyn arvon muutoksille.
        /// </summary>
        /// <param name="obj">Objekti jossa propertyn arvon muutos tapahtui</param>
        /// <param name="args">Muutostapahtuman argumentit</param>
        private static void OnKirjainChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
        {
            Kirjainlaatta laatta = obj as Kirjainlaatta;

            laatta.kirjainLabel.Content = args.NewValue.ToString();
        }
コード例 #16
0
ファイル: Pelilauta.xaml.cs プロジェクト: saviit/Wordinator
        /// <summary>
        /// Poistaa tietyn Kirjainlaatan Pelilaudalta
        /// </summary>
        /// <param name="k">Kirjainlaatta joka halutaan poistaa</param>
        public void RemoveKirjainlaatta(Kirjainlaatta k)
        {
            PelilautaRuutu r = GetChildAt(k.PositionX, k.PositionY);

            r.RemoveKirjainlaatta();
        }
コード例 #17
0
        /// <summary>
        /// Käsittelijä Kirjainlaatan reunusvärin arvon muutoksille
        /// </summary>
        /// <param name="obj">Kirjainlaatta jossa muutos tapahtui</param>
        /// <param name="args">argumentit</param>
        private static void OnBorderColorChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
        {
            Kirjainlaatta laatta = (Kirjainlaatta)obj;

            laatta.border.BorderBrush = (SolidColorBrush)args.NewValue;
        }
コード例 #18
0
        /// <summary>
        /// Käsittelijä Kirjainlaatan täyttövärin arvon muutoksille
        /// </summary>
        /// <param name="obj">Kirjainlaatta jossa muutos tapahtui</param>
        /// <param name="args">argumentit</param>
        private static void OnFillColorChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
        {
            Kirjainlaatta laatta = (Kirjainlaatta)obj;

            laatta.containerGrid.Background = (SolidColorBrush)args.NewValue;
        }
コード例 #19
0
ファイル: Pelilauta.xaml.cs プロジェクト: saviit/Wordinator
        /// <summary>
        /// Hakee Kirjainlaatat (ensimmäisen lisätyn laatan määräämästä sarakkeesta), jotka
        /// muodostavat sanan pelaajan tällä kierroksella lisäämien Kirjainlaattojen kanssa
        /// ja tarkistaa että niiden muodostama sana löytyy hyväksyttyjen
        /// sanojen listalta.
        /// </summary>
        /// <returns>Listan Kirjainlaatoista jotka muodostavat sanan</returns>
        private List <List <Kirjainlaatta> > HaePisteSarakeLaatat()
        {
            List <List <Kirjainlaatta> > pisteytettavatSanat = new List <List <Kirjainlaatta> >();
            List <Kirjainlaatta>         laatat = new List <Kirjainlaatta>();

            bool keskimmainenRuutuPeitossa = false;
            int  vanhojaLaattojaSanassa = 0;
            int  ensimmainen = laudalleLisatyt[0].PositionY, viimeinen = laudalleLisatyt[0].PositionY;

            // Etsitään sanan aloitus- ja lopetuspisteet
            for (int i = 1; i < laudalleLisatyt.Count; i++)
            {
                if (laudalleLisatyt[i].PositionY < ensimmainen)
                {
                    ensimmainen = laudalleLisatyt[i].PositionY;
                }
                if (laudalleLisatyt[i].PositionY > viimeinen)
                {
                    viimeinen = laudalleLisatyt[i].PositionY;
                }
            }

            // Lisätään kaikki Kirjainlaatat alku-ja loppupisteiden välistä
            // tarkistettavien listaan.
            for (int i = ensimmainen; i <= viimeinen; i++)
            {
                PelilautaRuutu ruutu = GetChildAt(laudalleLisatyt[0].PositionX, i);
                if (ruutu.RuutuSisaltaaLaatan)
                {
                    Kirjainlaatta k = ruutu.GetKirjainlaatta();
                    laatat.Add(k);
                }
                else
                {
                    RaiseLaattojenSijoitteluVirheEvent();
                    return(null);
                }
            }

            //Tarkistetaan onko lisättyjen laattojen ala/yläpuolella laattoja
            //ja lisätään ne tarkistettavaksi
            List <Kirjainlaatta> viereiset = new List <Kirjainlaatta>();

            viereiset.AddRange(laatat);

            int            eka = viereiset[0].PositionY, vika = viereiset[viereiset.Count - 1].PositionY;
            int            rivi = viereiset[0].PositionX;
            PelilautaRuutu r; // = GetChildAt(rivi, eka - 1);

            // ylhäällä olevat
            while ((r = GetChildAt(rivi, eka - 1)) != null && r.RuutuSisaltaaLaatan != false)
            {
                eka = r.PositionY;
                viereiset.Insert(0, r.GetKirjainlaatta());
                //r = GetChildAt(rivi, eka - 1);
            }
            //alhaalla olevat
            //r = GetChildAt(rivi, vika + 1);
            while ((r = GetChildAt(rivi, vika + 1)) != null && r.RuutuSisaltaaLaatan != false)
            {
                vika = r.PositionY;
                viereiset.Add(r.GetKirjainlaatta());
                //r = GetChildAt(rivi, vika + 1);
            }

            // Tarkistetaan sanan sijoittelu
            foreach (Kirjainlaatta k in viereiset)
            {
                PelilautaRuutu ruutu = GetChildAt(k.PositionX, k.PositionY);
                if (KierrosNumero == 0 && ruutu.PistekerroinTyyppi == 5)
                {
                    keskimmainenRuutuPeitossa = true;
                }
                if (k.Aktiivinen == false && KierrosNumero > 0)
                {
                    vanhojaLaattojaSanassa++;
                }
            }
            // Tarkistetaan että ensimmäinen lisätty sana peittää
            // pelilaudan keskimmäisen ruuden (aloitusruutu)
            if (KierrosNumero == 0 && !keskimmainenRuutuPeitossa)
            {
                RaiseEnsimmainenSanaEiAloitusruudussaVirheEvent();
                return(null);
            }
            // Tarkistetaan että lisätty sana on 'kiinni' jossakin
            // aikaisemmin lisätyssä sanassa
            if (laudalleLisatyt.Count > 1 && !onkoLisatytSamallaRivilla(laudalleLisatyt))
            {
                if (KierrosNumero > 0 && !(vanhojaLaattojaSanassa > 0))
                {
                    RaiseSanaEiKiinniAikaisemmassaVirheEvent();
                    return(null);
                }
            }

            String kokosana = "";

            foreach (Kirjainlaatta kirjain in viereiset)
            {
                kokosana += kirjain.Kirjain;
            }
            if (EtsiSanalistasta(kokosana))
            {
                pisteytettavatSanat.Add(viereiset);
            }
            else
            {
                // ilmoitetaan käyttäjälle virheestä
                RaiseSanaaEiLoytynytEvent(kokosana);
                // palautetaan null-lista, jotta ei anneta pisteitä virheellisistä sijoituksista
                return(null);
            }

            //Tarkistetaan muodostaako jokin syötetyn sanan Kirjainlaatoista
            //'lisäsanoja' vasemmalla/oikealla olevien laattojen kanssa
            List <Kirjainlaatta> lisasana = new List <Kirjainlaatta>();

            foreach (Kirjainlaatta laatta in laatat)
            {
                lisasana.Clear();
                int sarake = laatta.PositionY;
                eka  = laatta.PositionX;
                vika = laatta.PositionX;
                //r = GetChildAt(eka - 1, sarake);
                //Jos vasemmalle tai oikealla laattoja, lisätään tämä laatta listaan
                if ((r = GetChildAt(eka - 1, sarake)) != null && r.RuutuSisaltaaLaatan ||
                    (GetChildAt(vika + 1, sarake)) != null && GetChildAt(vika + 1, sarake).RuutuSisaltaaLaatan)
                {
                    lisasana.Add(laatta);
                }
                else
                {
                    // siirry seuraavan laatan kohdalle
                    continue;
                }

                // vasemmalla olevat
                while ((r = GetChildAt(eka - 1, sarake)) != null && r.RuutuSisaltaaLaatan != false)
                {
                    eka = r.PositionX;
                    lisasana.Insert(0, r.GetKirjainlaatta());
                    //r = GetChildAt(eka - 1, sarake);
                }

                // oikealla olevat
                //r = GetChildAt(vika + 1, sarake);
                while ((r = GetChildAt(vika + 1, sarake)) != null && r.RuutuSisaltaaLaatan != false)
                {
                    vika = r.PositionX;
                    lisasana.Add(r.GetKirjainlaatta());
                    //r = GetChildAt(vika + 1, sarake);
                }

                // tarkistetaan muodostuiko hyväksyttyvä sana
                String uusisana = "";
                foreach (Kirjainlaatta kirjain in lisasana)
                {
                    uusisana += kirjain.Kirjain;
                }
                if (EtsiSanalistasta(uusisana))
                {
                    pisteytettavatSanat.Add(lisasana);
                }
                else
                {
                    // ilmoitetaan käyttäjälle virheestä; jos joku 'lisäsanoista'
                    // on virheellinen, kirjainlaatat eivät voi olla tässä muodostelmassa
                    // vaikka 'pääsana' olisi oikein
                    RaiseSanaaEiLoytynytEvent(uusisana);
                    // palautetaan null-lista, jotta ei anneta pisteitä virheellisistä sijoituksista
                    return(null);
                }
            }
            return(pisteytettavatSanat);
        }
コード例 #20
0
        /// <summary>
        /// Käsittelijä Kirjainlaatan Pistearvo-propertyn arvon muutoksille.
        /// </summary>
        /// <param name="obj">Objekti jossa propertyn arvon muutos tapahtui</param>
        /// <param name="args">Muutostapahtuman argumentit</param>
        private static void OnPistearvoChanged(DependencyObject obj, DependencyPropertyChangedEventArgs args)
        {
            Kirjainlaatta laatta = obj as Kirjainlaatta;

            laatta.pistearvoLabel.Content = args.NewValue;
        }