public void OnDrop(PointerEventData eventData)
{
Debug.Log("OnDrop! " + eventData);
StapelContainer ziel = GetComponent <StapelContainer>();
SpielprinzipPatience spielprinzip = FindObjectOfType <SpielprinzipPatience>();
//spielprinzip.LegeKarteAuf(ziel);
Karte karte = eventData.pointerDrag.GetComponent <Karte>();
if (karte != null) //es wurde eine (vorschau)karte gezogen
{
spielprinzip.LegeKarteAuf(ziel);
return; //ondrop abbrechen
}
StapelContainer spalte = eventData.pointerDrag.GetComponent <StapelContainer>();
if (spalte != null) //es wurde eine andere spalte/container gezogen
{
if (spielprinzip.LegeKarteAuf(ziel, spalte.ObersteKarte())) //wurde abgelegt
{
spalte.EntferneObersteKarte();
}
}
}
public void LegeKarteAuf(StapelContainer container)
{
if (vorschauKarte.aktuelleBeschreibung() == null) //keine Karte aufgedeckt oder übrig
{
return;
}
Kartenbeschreibung alteKarte = container.ObersteKarte();
Kartenbeschreibung neueKarte = vorschauKarte.aktuelleBeschreibung();
if (WertPasst(alteKarte, neueKarte) && FarbePasst(alteKarte, neueKarte))
{
Debug.Log("Lege die Karte auf " + container);
Kartenstapel stapel = GetComponent <Kartenstapel>(); //Verweis auf Kartenstapelscript
stapel.kartenContainer = container.gameObject; //dem Stapel sagen, wo erzeugeKarteInSzene die Karte unterordnen soll
Karte karteInSzene = stapel.erzeugeKarteInSzene(); //GameObject zum Zeichnen der Karte in der Szene anlegen
karteInSzene.setzeBeschreibung(vorschauKarte.aktuelleBeschreibung(), false); //Kartenwert und Darstellung verbinden & sofort aufdecken
vorschauKarte.setzeBeschreibung(null, false);
KlickAufStapel();
container.KartenAnordnen();
if (stapel.istLeer() && vorschauKarte.aktuelleBeschreibung() == null) //alle karten abgelegt
{
dialogGewonnen.SetActive(true);
}
}
else //passt nicht
{
dialogFehler.SetActive(true);
}
}
private void wennKarteUmgedrehtWurde(Karte umgedrehteKarte)
{
Debug.Log("Spielprinzip weiß: Karte " + umgedrehteKarte + " wurde umgedreht.");
if (!umgedrehteKarte.KarteSchonUmgedreht())
{
return;
}
if (letzteKarte != null) //dies ist die zweite Karte
{
if (letzteKarte.hatSelbenWert(umgedrehteKarte)) //paar gefunden
{
Debug.Log("Die beiden Karten sind gleich. " + letzteKarte + " " + umgedrehteKarte);
Destroy(letzteKarte.gameObject);
Destroy(umgedrehteKarte.gameObject);
}
else
{
Debug.Log("Die beiden Karten sind unterschiedlich: " + letzteKarte + " " + umgedrehteKarte);
umgedrehteKarte.Umdrehen();
letzteKarte.Umdrehen();
}
letzteKarte = null;
}
else //dies ist die erste Karte
{
letzteKarte = umgedrehteKarte;
}
}
public void ErweiterungStarten(Kartenstapel stapel)
{
if (testModus)
{
LegeAlle(1, stapel, 0);
LegeAlle(2, stapel, 1);
LegeAlle(13, stapel, 2);
LegeAlle(14, stapel, 3);
}
else
{
//Spalten mit einer Auswahl zufälliger Karten befüllen
for (int i = 0; i < spalten.Count; i++)
{
for (int bereitsErzeugt = 0; bereitsErzeugt <= i; bereitsErzeugt++)
{
Kartenbeschreibung k = stapel.hebeObersteKarteAb();
stapel.kartenContainer = spalten[i].gameObject;
Karte karteInSzene = stapel.erzeugeKarteInSzene();
karteInSzene.setzeBeschreibung(k, false);
if (bereitsErzeugt < i)
{
karteInSzene.TauscheKartenbild(); //für alle außer letzter Karte
}
spalten[i].KartenAnordnen();
}
}
}
}
public void UcitajSveKarte()
{
using (SqlConnection conn = new SqlConnection())
{
Karte.Clear();
conn.ConnectionString = CONNECTION_STRING;
conn.Open();
SqlCommand command = conn.CreateCommand();
command.CommandText = @"SELECT * FROM Karte WHERE aktivan=1";
SqlDataAdapter daKarte = new SqlDataAdapter();
DataSet dsKarte = new DataSet();
daKarte.SelectCommand = command;
daKarte.Fill(dsKarte, "Karte");
foreach (DataRow row in dsKarte.Tables["Karte"].Rows)
{
Karta karta = new Karta();
karta.Id = (int)row["Id"];
karta.BrojLeta = (int)row["BrojLeta"];
karta.BrojSedista = (string)row["BrojSedista"];
karta.NazivPutnika = (string)row["NazivPutnika"];
karta.KlasaSedista = (klasaenum)Enum.Parse(typeof(klasaenum), row["KlasaSedista"].ToString());
karta.Kapija = (int)row["Kapija"];
karta.Cena = (double)Convert.ToDouble(row["Cena"]);
karta.Aktivna = (bool)row["Aktivan"];
Karte.Add(karta);
}
}
}
public bool Passt(Karte karte)
{
return((karte.aktuelleBeschreibung().Farbe == offeneKarte.aktuelleBeschreibung().Farbe)
||
(karte.aktuelleBeschreibung().Wert == offeneKarte.aktuelleBeschreibung().Wert)
);
}
public void LegeAb(Karte handstapelkarteInSzene)
{
stapel.legeKarteZurueck(offeneKarte.aktuelleBeschreibung());
stapel.mischeStapel();
offeneKarte.setzeBeschreibung(handstapelkarteInSzene.aktuelleBeschreibung(), false);
Destroy(handstapelkarteInSzene.gameObject); //Typischer Fehler: .gameObject vergessen
}
/// <summary>
/// Funktion des Weiter-Buttons im Ungleiches-Paar-Dialog.
/// </summary>
public void ButtonKlickPaarVerwerfen()
{
ersteKarte.Umdrehen();
zweiteKarte.Umdrehen();
dialogUngleichesPaar.SetActive(false);
ersteKarte = null;
zweiteKarte = null;
}
/// <summary>
/// Funktion des Weiter-Buttons im Paar-Gefunden-Dialog.
/// </summary>
public void ButtonKlickPaarSammeln()
{
Destroy(ersteKarte.gameObject);
Destroy(zweiteKarte.gameObject);
dialogGleichesPaar.SetActive(false);
ersteKarte = null;
zweiteKarte = null;
}
/// <summary>
/// Legt Karte auf Hand
/// </summary>
/// <param name="item">Karte die auf die Hand kommt</param>
public void AddHandkarte(Karte item)
{
if (item.id >= 19)
{
spieler.increaseGuthaben((item as CreditsKarte).Credits);
}
handKarten.Add(item);
checkFlags();
}
public void RemoveHandkarte(Karte item)
{
if (item.id >= 19)
{
spieler.decreaseGuthaben((item as CreditsKarte).Credits);
}
handKarten.Remove(item);
checkFlags();
}
public void UcitajKarte()
{
Karte.Clear();
foreach (Karta av in KartaDAO.vratiKarte())
{
this.Karte.Add(av);
}
}
/// <summary>
/// Zieht zufällige Karte aus Spielerhand
/// </summary>
/// <returns>Zufällige Handkarte des Spielers</returns>
public Karte RandomHandkarte()
{
Random rng = new Random();
int anzahl = GetHandkartenAnzahl();
int index = rng.Next(anzahl);
Karte ret = handKarten[index];
RemoveHandkarte(handKarten[index]);
return(ret);
}
public Karte Ziehen()
{
Karte temp = stapel.First();
stapel.RemoveAt(0);
if (!stapel.Any())
{
Nachfüllen();
}
return(temp);
}
private void LegeAlle(int mitDerFarbe, Kartenstapel ausDemStapel, int inDieSpalteIndex)
{
for (int wert = 14; wert >= 2; wert--)
{
Kartenbeschreibung k = ausDemStapel.hebeKarteAb(wert, mitDerFarbe);
ausDemStapel.kartenContainer = spalten[inDieSpalteIndex].gameObject;
Karte karteInSzene = ausDemStapel.erzeugeKarteInSzene();
karteInSzene.setzeBeschreibung(k, false);
}
spalten[inDieSpalteIndex].KartenAnordnen();
}
private void GibKarten(int anzahl, GameObject handstapel)
{
for (int i = 0; i < anzahl; i++)
{
Kartenbeschreibung karteAusStapel = stapel.hebeObersteKarteAb();
stapel.kartenContainer = handstapel;
Karte karteInSzene = stapel.erzeugeKarteInSzene();
karteInSzene.setzeBeschreibung(karteAusStapel, true);
karteInSzene.Umdrehen();
karteInSzene.GetComponent <Button>().onClick.AddListener(KlickAufHandStapelKarte);
}
}
public void KarteKlauen(Spieler taeter, Spieler opfer)
{
if (!opfer.hand.isEmpty)
{
Karte temp = opfer.hand.RandomHandkarte();
taeter.hand.AddHandkarte(temp);
_hub.KarteIDEntfernen(opfer, temp);
_hub.KarteIdHinzu(taeter, temp);
_hub.ZeigeNachricht(taeter, "Du hast Spieler " + opfer.ID + " " + temp.titel + " geklaut");
_hub.ZeigeNachricht(opfer, "Dir wurde von Spieler " + taeter.ID + " " + temp.titel + " geklaut");
}
}
private void DplSpielfeld_Loaded(object sender, RoutedEventArgs e)
{
Spiel.InitSpieler(100, this);
Karte.InitKarten();
Uri cardback = new Uri("../../Memes/cardback.png", UriKind.Relative);
// Eine zufällige Karte als Startkarte nehmen
int index = new Random().Next(Karte.möglicheKarten.Count);
imgDeckZiehen.Tag = Karte.möglicheKarten[index];
}
public void verarbeiteEinbrecherAntwort(bool b, int idSpielerWeg, int idSpielerHinzu)
{
if (b)
{
KarteKlauen(GetSpieleraById(idSpielerHinzu), GetSpieleraById(idSpielerWeg));
Karte k = GetSpieleraById(idSpielerHinzu).hand.getKarteById(1);
GetSpieleraById(idSpielerHinzu).hand.RemoveHandkarte(k);
_hub.KarteIDEntfernen(GetSpieleraById(idSpielerHinzu), k);
deck.Ablegen(k);
}
FlottenStart();
}
/// <summary>
/// Sammelt die Karten, die auf der karteUnterMaus liegen (inkl. der Karte selbst)
/// in der Liste ziehendeKarten.
/// </summary>
/// <param name="karteUnterMaus"></param>
/// <returns>Ist dies ein gültiger Zug?</returns>
public bool SammleKartenAb(Karte karteUnterMaus)
{
for (int i = karteUnterMaus.transform.GetSiblingIndex(); i < transform.childCount; i++)
{
Karte k = transform.GetChild(i).GetComponent <Karte>();
if (!k.KarteSchonUmgedreht())
{
return(false);
}
ziehendeKarten.Add(k);
}
return(true);
}
private Karte mkKarte(OleDbDataReader dr)
{
Karte ka = new Karte();
int i = 0;
ka.ID = dr.GetInt32(i++);
ka.set = dr.GetString(i++);
ka.nummer = dr.GetInt32(i++);
ka.bild = dr.GetString(i++);
return(ka);
}
public void apendMove(IMove move)
{
if (Karte.Last().Broj == "A")
{
Karte.AddRange(move.Karte);
if (move.Karte.Last().Broj == "J")
{
NovaBoja = move.NovaBoja;
}
}
return;
}
private void wennKarteUmgedrehtWurde(Karte umgedrehteKarte)
{
Debug.Log("Spielprinzip weiß: Karte " + umgedrehteKarte + " wurde umgedreht.");
if (!umgedrehteKarte.KarteSchonUmgedreht())
{
return; //verhindern, dass das umdrehen sofort wieder das zurück Umdrehen auslöst
}
if (ersteKarte != null) //dies ist die zweite Karte
{
zweiteKarte = umgedrehteKarte;
if (ersteKarte.hatSelbenWert(umgedrehteKarte)) //paar gefunden
{
Debug.Log("Die beiden Karten sind gleich. " + ersteKarte + " " + umgedrehteKarte);
verbleibendeZuege = 5;
hilfetext.text = "Finde alle Paare! Noch " + verbleibendeZuege + " Versuche.";
Kartenstapel stapel = GetComponent <Kartenstapel>();
if (stapel.kartenContainer.transform.childCount <= 2) //das waren die letzten beiden Karten -> gewonnen
{
dialogGewonnen.SetActive(true);
}
else //es sind noch mehrere Karten auf dem Brett -> nur diese beiden wegräumen, dann weiter spielen
{
dialogGleichesPaar.SetActive(true);
StartCoroutine(dialogAutomatischAusblenden());
}
}
else //unterschiedliche karten
{
Debug.Log("Die beiden Karten sind unterschiedlich: " + ersteKarte + " " + umgedrehteKarte);
verbleibendeZuege = verbleibendeZuege - 1;
hilfetext.text = "Finde alle Paare! Noch " + verbleibendeZuege + " Versuche.";
if (verbleibendeZuege == 0)
{
dialogGameOver.SetActive(true);
}
else
{
dialogUngleichesPaar.SetActive(true);
StartCoroutine(dialogAutomatischAusblenden());
}
}
}
else //dies ist die erste Karte
{
ersteKarte = umgedrehteKarte;
}
}
public void Shuffle()
{
Random rng = new Random();
int n = stapel.Count;
while (n > 1)
{
n--;
int k = rng.Next(n + 1);
Karte value = stapel[k];
stapel[k] = stapel[n];
stapel[n] = value;
}
}
private void KlickAufHandStapelKarte()
{
Karte karteInSzene = EventSystem.current.currentSelectedGameObject.GetComponent <Karte>();
Debug.Log("Handstapelkarte angeklickt: " + karteInSzene.aktuelleBeschreibung());
if (Passt(karteInSzene))
{
LegeAb(karteInSzene);
}
else
{
Debug.Log("Die Karte " + karteInSzene + " passt NICHT auf " + offeneKarte);
}
}
public void LegeAb(Karte handstapelkarteInSzene)
{
stapel.legeKarteZurueck(offeneKarte.aktuelleBeschreibung());
stapel.mischeStapel();
offeneKarte.setzeBeschreibung(handstapelkarteInSzene.aktuelleBeschreibung(), false);
Destroy(handstapelkarteInSzene.gameObject); //Typischer Fehler: .gameObject vergessen
if (handstapelkarteInSzene.transform.parent.childCount == 1)
{
gewonnenDialog.SetActive(true);
textGewonnen.text = WerIstDran().anzeigename + " hat gewonnen.";
}
}
/// <summary>
/// Spielphase II
/// Versprechungen Machen
/// Imperator hat Karten und Spieler gewählt
/// Infos werden vom ClientProxyHub aufgenommen und von JuntaHubMehtode verarbeitet(Versprechen Verarbeiten) nimmt spielerID und KartenID an
/// Spielverwaltung wandelt SpielerID in Spieler und KartenID in Karte um
/// VersprechungMachen wird aufgerufen und dadurch dem Spieler das Karten[] übergeben + dem Imperator die Karten abgezogen.
/// Nach VersprechungenMachen wird EinbrecherKarteSpielen abgefragt
/// Versprechungen werden direkt verteilt wenn kein ImperatorKampf vorhanden ist.(Wenn niemand den Imperator angreift)
/// Versprechungen werden nach der Kampfphase verteilt, wenn der Imperator überlebt.
/// </summary>
/// <param name="idSpieler"></param>
/// <param name="idKarten"></param>
public void VersprechungMachen(Dictionary <int, int> versprechung) //1.key = karte, 2.value = spieler
{
foreach (KeyValuePair <int, int> pair in versprechung)
{
Karte temp = imperator.hand.getKarteById(pair.Key);
if (pair.Value != ImperatorID)
{
imperator.hand.RemoveHandkarte(temp);
_hub.KarteIDEntfernen(imperator, temp);
GetSpieleraById(pair.Value).versprechungen.Add(temp);
_hub.VersprechenHinzu(pair.Value, pair.Key, temp.titel, temp.text);
}
}
EinbrecherKarteSpielen();
}
private void ImgSpielerFeld_Angreifen_Click(object sender, MouseButtonEventArgs e)
{
Image img = sender as Image;
// Wenn das Bild keine zugewiesene Karte besitzt -> abbruch
if (img.Tag is null)
{
return;
}
Karte karte = img.Tag as Karte;
if (Spiel.angriffsKlick)
{
Spiel.angriffsKarte = karte;
}
else
{
Karte angegriffeneKarte = karte;
angegriffeneKarte.leben -= Spiel.angriffsKarte.angriff;
// Leben gleich updaten
ImgSpielerFeld_MouseEnter(img, null);
if (angegriffeneKarte.leben < 1)
{
imgDeckTot.Source = new BitmapImage(angegriffeneKarte.dateiPfad);
img.Source = new BitmapImage(Spiel.cardback);
img.Tag = null;
// angegriffeneKarte.leben ist schon negativ, deshalb +=; 1 + (-1) = 0
Spiel.spieler[Spiel.aktuellerSpieler].leben += angegriffeneKarte.leben;
// TODO:
if (Spiel.aktuellerSpieler == 0)
{
}
else if (Spiel.aktuellerSpieler == 1)
{
}
// Leben auf nix stellen
ImgSpielerFeld_MouseLeave(img, null);
}
}
Spiel.angriffsKlick = !Spiel.angriffsKlick;
}
// Start is called before the first frame update
void Start()
{
Kartenstapel stapel = GetComponent <Kartenstapel>();
verdoppleKartenIn(stapel);
while (!stapel.istLeer())
{
Kartenbeschreibung gezogeneKarte = stapel.hebeZufaelligeKarteAb();
Karte k = stapel.erzeugeKarteInSzene();
k.setzeBeschreibung(gezogeneKarte, true);
k.nachUmdrehenBenachrichten = wennKarteUmgedrehtWurde;
}
GetComponent <Image>().enabled = false; //gameObject.SetActive(false);
}
private void ImgSpielerFeld_MouseEnter(object sender, MouseEventArgs e)
{
Image img = sender as Image;
// Wenn das Bild keine zugewiesene Karte hat -> abbrechen
if (img.Tag is null)
{
return;
}
Karte karte = img.Tag as Karte;
lblS1KarteName.Content = (img.Tag as Karte).name;
lblS1KartInfoLeben.Content = $"Leben: {karte.leben}";
lblS1KartInfoAngriff.Content = $"Angriff: {karte.angriff}";
}
