private void Listen_for_TCP_Pakete()
{
while (broadcast_status)
{
Netzwerkkommunikation.Start_TCP_Listener();
}
}
//--------Computergegner Runtime-------------//
private void Computergegener_Runtime(Spieler CP_spieler)
{
while (true)
{
while (CP_spieler.status)
{
System.Threading.Thread.Sleep(500);
Würfel.Dispatcher.Invoke(new Click_Event(Würfel_Click));
System.Threading.Thread.Sleep(500);
foreach (Figur figur in CP_spieler.eigene_Figuren)
{
if (figur.mögliche_Position != null)
{
figur.Set_Figureposition(figur.mögliche_Position);
Netzwerkkommunikation.Sende_TCP_Nachricht_an_alle_Spieler("Spielfigur Update," + Statische_Methoden.Konvertiere_FARBE_zu_string(figur.farbe) + "," + figur.id + "," + figur.aktuelle_Position.position.X + "," + figur.aktuelle_Position.position.Y);
Figur_wurde_bewegt();
break;
}
}
foreach (Figur figur in CP_spieler.eigene_Figuren)
{
figur.mögliche_Position = null;
}
}
System.Threading.Thread.Sleep(1000);
}
}
private void Sart_TCP_Listener()
{
while (UDP_thread_status)
{
Netzwerkkommunikation.Start_TCP_Listener();
}
}
private void btn_beitreten_Click(object sender, RoutedEventArgs e)
{
if (Spieler_name.Text == "" || Spieler_name.Text == "Gib einen Spielernamen ein" || Spieler_name.Text.Length > 20)
{
MessageBox.Show("Gegen sie einen gültigen Namen ein!", "Fehler", MessageBoxButton.OK);
Spieler_name.Focus();
return;
}
if (Spieler_name.Text.Contains(","))
{
MessageBox.Show("Der Spielername darf kein \",\"enthalten", "Fehler", MessageBoxButton.OK);
Spieler_name.Focus();
return;
}
if (ausgewählten_Host.freie_plätze > 0)
{
string message = "Clientanfrage," + Spieler_name.Text + "," + Statische_Variablen.eigene_IPAddresse.ToString() + "," + ausgewählte_Farbe;
Netzwerkkommunikation.Send_TCP_Packet(message, ausgewählten_Host.host_ip);
//Warten auf zusage
Netzwerkkommunikation.Start_TCP_Listener();
if (Statische_Variablen.anfragen_result == true)
{
Task tcp_listener = Task.Factory.StartNew(Sart_TCP_Listener);
btn_beitreten.IsEnabled = false;
Spieler_name.IsEnabled = false;
RB_blau.IsEnabled = false;
RB_gelb.IsEnabled = false;
RB_gruen.IsEnabled = false;
RB_blau.IsEnabled = false;
btn_Abbrechen.IsEnabled = true;
Hosts.IsEnabled = false;
}
}
}
public static void Sende_UDP()
{
while (UDP_Threadstatus)
{
Netzwerkkommunikation.Send_UDP_BC_Packet(Generiere_UDP_Nachricht());
Thread.Sleep(1000);
}
}
private void Send_Broadcast()
{
while (broadcast_status)
{
Netzwerkkommunikation.Send_UDP_BC_Packet(broadcast_string);
Thread.Sleep(1000);// Ein mal in der Sekunde wird ein Broadcast gesendet;
}
}
//Spielrecht -------------------------------------------------------------------------------------------------------
public static void Gebe_Spielrecht_weiter()
{
string name = Ermittle_nächsten_Spieler(aktiver_Spieler.farbe).name;
Netzwerkkommunikation.Sende_TCP_Nachricht_an_alle_Spieler("Mitspieler;Spielrecht;" + name);
if (Ermittle_nächsten_Spieler(aktiver_Spieler.farbe).ip.Address == Netzwerkkommunikation.Eigene_IP_Adresse().Address)
{
Analysiere_Nachricht(new string[] { "Spielrecht_update", name });
}
}
private static string Generiere_UDP_Nachricht()
{
return("Client" + ";" +
"Spielangebot" + ";" +
Netzwerkkommunikation.Eigene_IP_Adresse() + ";" +
"Spielname" + ";" +
Spieler_Rot + ";" +
Spieler_Gelb + ";" +
Spieler_Grün + ";" +
Spieler_Blau);
}
//Senden / Empfangen -----------------------------------------------------------------------------------------------
public static void Warte_auf_Spieler()
{
while (UDP_Threadstatus)
{
if (Prüfe_Startfähigkeit())
{
UDP_Threadstatus = false;
Starte_Spiel();
break;
}
Netzwerkkommunikation.Start_TCP_Listener();
}
}
public Spielwiese(Frame root_Frame)
{
InitializeComponent();
aktive_Seite = AKTIVE_SEITE.SPIELWIESE;
this.root_Frame = root_Frame;
this.TCP_listener_status = true;
lokaler_spieler = Ermittele_lokalen_Spieler();
Würfel = Btn_Wuerfel;
active_chat = Chat_rot;
Initialisiere_alle_Felder(Grid_Spielwiese); // Hier werden alle Felder anhand der UIElement Control elemente erzeugt.
Initialisiere_Spiel(); // Hier werden die Spielfiguren der Spieler erzeugt.
foreach (Spieler spieler in alle_Spieler)
{
if (spieler.status)
{
TB_aktiver_Spieler.Text = spieler.name;
aktiver_spieler = spieler;
}
switch (spieler.farbe)
{
case FARBE.ROT: L_Spielername_rot.Content = spieler.name; break;
case FARBE.GELB: L_Spielername_gelb.Content = spieler.name; break;
case FARBE.GRUEN: L_Spielername_gruen.Content = spieler.name; break;
case FARBE.BLAU: L_Spielername_blau.Content = spieler.name; break;
}
foreach (Figur figur in spieler.eigene_Figuren)
{
Grid_Spielwiese.Children.Add(figur.bild); //Hier wird jede figur der oberfläche hinzugefügt
}
spieler.nächster_Spieler = Ermittele_nächsten_Spieler(spieler.farbe);
}
if (lokaler_spieler.status == true)
{
Netzwerkkommunikation.Anlaysiere_IP_Paket("Spielrecht," + lokaler_spieler.name);
}
Task TCPListener = Task.Factory.StartNew(Listen_for_TCP_Pakete);
foreach (Spieler spieler in alle_Spieler)
{
if (spieler.spieler_art == SPIELER_ART.COMPUTERGEGNER)
{
Task.Factory.StartNew((Computergegener) => Computergegener_Runtime(spieler), spieler);
}
}
}
private void btn_Aufgeben_Click(object sender, RoutedEventArgs e)
{
this.TCP_listener_status = false;
root_Frame.Content = new Startseite(root_Frame);
Netzwerkkommunikation.Sende_TCP_Nachricht_an_alle_Spieler("Client_abbruch," + lokaler_spieler.name);
spiel_felder.Clear();
ziel_felder.Clear();
start_felder.Clear();
spieler_rot.Clear();
spieler_gelb.Clear();
spieler_gruen.Clear();
spieler_blau.Clear();
alle_Spieler.Clear();
}
public Spiel_erstellen(Frame root_Frame)
{
this.ausgewählte_farbe = FARBE.LEER;
this.root_Frame = root_Frame;
InitializeComponent();
this.comboBox_rot.SelectedIndex = 1;
Spielerstellenlabel.Add(L_Name_Spieler_rot);
Spielerstellenlabel.Add(L_Name_Spieler_gelb);
Spielerstellenlabel.Add(L_Name_Spieler_gruen);
Spielerstellenlabel.Add(L_Name_Spieler_blau);
aktive_Seite = AKTIVE_SEITE.SPIEL_ERSTELLEN;
Netzwerkkommunikation.Iinitialisiere_BC_IP_Addressen();
Netzwerkkommunikation.Iinitialisiere_IP_Addressen();
}
private void btn_Abbrechen_Click(object sender, RoutedEventArgs e)
{
if (ausgewählten_Host != null)
{
Netzwerkkommunikation.Send_TCP_Packet("Clientabsage," + Statische_Variablen.eigene_IPAddresse.ToString(), ausgewählten_Host.host_ip);
}
btn_Abbrechen.IsEnabled = false;
btn_beitreten.IsEnabled = true;
Spieler_name.IsEnabled = true;
RB_blau.IsEnabled = true;
RB_gelb.IsEnabled = true;
RB_gruen.IsEnabled = true;
RB_blau.IsEnabled = true;
Hosts.IsEnabled = true;
}
public void Text_in_Chat_senden(string spielername)
{
active_chat.Text += "\n" + spielername + ": " + Chat_eingabe.Text;
if (aktiver_chat_spieler != null)
{
Netzwerkkommunikation.Send_TCP_Packet("Chatinformationen," + Chat_eingabe.Text, aktiver_chat_spieler.ip);
}
else
{
Netzwerkkommunikation.Sende_TCP_Nachricht_an_alle_Spieler("Chatinformationen," + Chat_eingabe.Text);
}
active_chat.ScrollToEnd();
Chat_eingabe.Text = "";
Chat_eingabe.Focus();
}
private void BTN_Starten_Click(object sender, RoutedEventArgs e)
{
// Sobald man Starten drückt wird die getroffene Auswahl Überprüft. Bei einer gültigen Auswahl werden zwei neue
// Threads gestartet. Der eine Sendet eine UDP-Nachricht für potentielle Spieler(Clients) und der Andere horcht auf die
// Leitung um Client-Anfragen zu verarbeiten. Dabei ist der Button disabled. Wenn das Spiel gestartet wird, wird der
// Button erneut getriggert um das Spiel zu starten.
if (BTN_Starten.IsEnabled)
{
if (S_erstellen.Prüfe_auswahl())
{
BTN_Starten.IsEnabled = false;
CB_Blau.IsEnabled = false;
CB_Gelb.IsEnabled = false;
CB_Rot.IsEnabled = false;
CB_Grün.IsEnabled = false;
S_erstellen.Spieler_Rot = CB_Rot.Text;
S_erstellen.Spieler_Gelb = CB_Gelb.Text;
S_erstellen.Spieler_Grün = CB_Grün.Text;
S_erstellen.Spieler_Blau = CB_Blau.Text;
S_erstellen.UDP_Threadstatus = true;
Task.Factory.StartNew(S_erstellen.Warte_auf_Spieler);
Task.Factory.StartNew(S_erstellen.Sende_UDP);
}
else
{
MessageBox.Show("Es müssen mindestens 2 Spieler gegeneinander antreten", "Fehler - ungültige Auswahl", MessageBoxButton.OK);
}
}
else
{
string startnachricht = S_erstellen.Generiere_Startnachricht();
Netzwerkkommunikation.Sende_TCP_Nachricht_an_alle_Spieler(startnachricht);
Statische_Variablen.aktuelle_Seite = "Spielfeld";
Klassen.SeitenFunktionen.Spielfeld.aktiver_Spieler = Klassen.SeitenFunktionen.Spielfeld.alle_Mitspieler
[new Random().Next(0, Klassen.SeitenFunktionen.Spielfeld.alle_Mitspieler.Count)];
Statische_Variablen.rootFrame.Content = new Spielfeld();
Klassen.SeitenFunktionen.Spielfeld.Gebe_Spielrecht_weiter();
Klassen.SeitenFunktionen.Spielfeld.spielstatus = true;
foreach (Spieler spieler in Klassen.SeitenFunktionen.Spielfeld.alle_Mitspieler)
{
if (spieler.spieler_art == Statische_Variablen.SPIELER_ART.CP_GEGNER)
{
Task.Factory.StartNew(spieler.Computergegner_Runtime);
}
}
}
}
private void btn_abbrechen_Click(object sender, RoutedEventArgs e)
{
if (MessageBox.Show("Achtung!", "Wollen sie wirklich abbrechen ?!", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
{
broadcast_status = false;
Spielerstellenlabel.Clear();
alle_Spieler.Clear();
known_IP_S.Clear();
alle_Hosts.Clear();
for (int i = 0; i < 10; i++)
{
Netzwerkkommunikation.Send_UDP_BC_Packet("Hostinformationen," + eigene_IPAddresse.ToString() + ",absage,,,,,,");
}
root_Frame.Content = new Startseite(root_Frame);
}
}
//Würfeln ----------------------------------------------------------------------------------------------------------
public static void Würfeln()
{
Aktiviere_Deaktiviere_Würfel(false);
versuche--;
würfelzahl = new Random().Next(1, 7);
Zeige_Zahl(würfelzahl);
if (würfelzahl == 6)
{
versuche = 1;
}
Netzwerkkommunikation.Sende_TCP_Nachricht_an_alle_Spieler("Mitspieler;Würfel_update;" + würfelzahl);
if (!Prüfe_Figurbeweglichkeit() && versuche > 0)
{
Aktiviere_Deaktiviere_Würfel(true);
}
else if (!Prüfe_Figurbeweglichkeit() && versuche <= 0)
{
Gebe_Spielrecht_weiter();
}
}
public static void TCP_Listener()
{
while (spielstatus)
{
//testcode////////////////////////////////////////////////////////////////
//Analysiere_Nachricht(new string[] { "Würfel_update", "6" });
//Analysiere_Nachricht(new string[] { "Figur_update", "GELB", "1", "10"});
//Analysiere_Nachricht(new string[] { "Figur_update", "ROT", "1", "20" });
//for (int i = 0; i < 44; i++)
//{
// Analysiere_Nachricht(new string[] { "Figur_update", "GELB", "1", i.ToString() });
// Analysiere_Nachricht(new string[] { "Figur_update", "BLAU", "1", i.ToString() });
// Analysiere_Nachricht(new string[] { "Figur_update", "ROT", "1", i.ToString() });
// Analysiere_Nachricht(new string[] { "Figur_update", "GRÜN", "1", i.ToString() });
// Thread.Sleep(100);
//}
//testcode///////////////////////////////////////////////////////////////
Netzwerkkommunikation.Start_TCP_Listener();
}
}
// Spielstart ------------------------------------------------------------------------------------------------------------------------
private static void Starte_Spiel()
{
// Erstellt Computergegner
if (Spieler_Rot == "Computergegner")
{
Erstelle_Spieler("ROT", "CP Gegner Rot", Netzwerkkommunikation.Eigene_IP_Adresse());
}
if (Spieler_Gelb == "Computergegner")
{
Erstelle_Spieler("GELB", "CP Gegner Gelb", Netzwerkkommunikation.Eigene_IP_Adresse());
}
if (Spieler_Grün == "Computergegner")
{
Erstelle_Spieler("GRÜN", "CP Gegner Grün", Netzwerkkommunikation.Eigene_IP_Adresse());
}
if (Spieler_Blau == "Computergegner")
{
Erstelle_Spieler("BLAU", "CP Gegner Blau", Netzwerkkommunikation.Eigene_IP_Adresse());
}
if (Spieler_Rot == "Ich")
{
Erstelle_Spieler("ROT", Statische_Variablen.lokaler_Spieler, Netzwerkkommunikation.Eigene_IP_Adresse());
}
if (Spieler_Gelb == "Ich")
{
Erstelle_Spieler("GELB", Statische_Variablen.lokaler_Spieler, Netzwerkkommunikation.Eigene_IP_Adresse());
}
if (Spieler_Grün == "Ich")
{
Erstelle_Spieler("GRÜN", Statische_Variablen.lokaler_Spieler, Netzwerkkommunikation.Eigene_IP_Adresse());
}
if (Spieler_Blau == "Ich")
{
Erstelle_Spieler("BLAU", Statische_Variablen.lokaler_Spieler, Netzwerkkommunikation.Eigene_IP_Adresse());
}
Start_Button.Dispatcher.Invoke(new Click_Event(Start_Invoker));
}
//--------------Würfellogick--------------//
private void Btn_Wuerfel_Click(object sender, RoutedEventArgs e)
{
z = zufallszahl.Next(1, 7);
Btn_Wuerfel.Content = z.ToString();
Btn_Wuerfel.IsEnabled = false;
Netzwerkkommunikation.Sende_TCP_Nachricht_an_alle_Spieler("Wuerfelzahl," + z.ToString());
if (!Zug_ist_möglich(z, aktiver_spieler.eigene_Figuren))
{
if (z != 6)
{
if (Sind_alle_Figuren_im_Haus())
{
verbleibende_würfelversuche -= 1;
if (verbleibende_würfelversuche > 0)
{
if (aktiver_spieler.spieler_art == SPIELER_ART.NORMALER_SPIELER)
{
Btn_Wuerfel.IsEnabled = true;
}
}
else
{
Forward_Spielrecht();
}
}
else
{
Forward_Spielrecht();
}
}
else
{
if (aktiver_spieler.spieler_art == SPIELER_ART.NORMALER_SPIELER)
{
Btn_Wuerfel.IsEnabled = true;
}
}
}
//________________________________________________________________________________________________________________________
//if (Sind_alle_Figuren_im_Haus() && verbleibende_würfelversuche > 0)
//{
// if (z != 6 && verbleibende_würfelversuche >0)
// {
// verbleibende_würfelversuche--;
// }
// else
// {
// Zug_ist_möglich(z,aktiver_spieler.eigene_Figuren);
// Btn_Wuerfel.IsEnabled = false;
// }
//}
//else if (Sind_alle_Figuren_im_Haus() && verbleibende_würfelversuche < 1)
//{
// Btn_Wuerfel.IsEnabled = false;
// Forward_Spielrecht();
//}
//else
//{
// if (z != 6)
// {
// if (Zug_ist_möglich(z,aktiver_spieler.eigene_Figuren))
// {
// Btn_Wuerfel.IsEnabled = false;
// }
// else
// {
// Btn_Wuerfel.IsEnabled = false;
// if(aktiver_spieler.spieler_art == SPIELER_ART.NORMALER_SPIELER) MessageBox.Show("Es ist kein Zug möglich", "Information", MessageBoxButton.OK);
// Forward_Spielrecht();
// }
// }
// else
// {
// if (Zug_ist_möglich(z, aktiver_spieler.eigene_Figuren))
// {
// Btn_Wuerfel.IsEnabled = false;
// }
// else
// {
// lokaler_spieler.status = true;
// }
// }
//}
//if (verbleibende_würfelversuche < 1) Forward_Spielrecht();
}
private void btn_spiel_starten_Click(object sender, RoutedEventArgs e)
{
//
//In den If Abfragen wird geprüft ob min 2 gültige spieler da sind und kein slot mehr offen ist und ein Name angegeben wurde.
//
int temp = 0;
if (!Überprüfe_eingabe_Name())
{
return;
}
if (Prüfe_Startbedingungen(L_Name_Spieler_rot))
{
temp++;
}
if (Prüfe_Startbedingungen(L_Name_Spieler_gelb))
{
temp++;
}
if (Prüfe_Startbedingungen(L_Name_Spieler_gruen))
{
temp++;
}
if (Prüfe_Startbedingungen(L_Name_Spieler_blau))
{
temp++;
}
if (temp < 2)
{
MessageBox.Show("Es müssen mindestens 2 Spieler gegeneinander antreten", "Fehler", MessageBoxButton.OK);
return;
}
if (temp >= 2)
{
broadcast_status = false;
if (L_Name_Spieler_rot.Text.ToString() == "Computergegner")
{
Spieler CP_Gegner1 = new Spieler(FARBE.ROT, "Computergegner 1", SPIELER_ART.COMPUTERGEGNER, new System.Net.IPAddress(0));
}
if (L_Name_Spieler_gelb.Text.ToString() == "Computergegner")
{
Spieler CP_Gegner1 = new Spieler(FARBE.GELB, "Computergegner 2", SPIELER_ART.COMPUTERGEGNER, new System.Net.IPAddress(0));
}
if (L_Name_Spieler_gruen.Text.ToString() == "Computergegner")
{
Spieler CP_Gegner1 = new Spieler(FARBE.GRUEN, "Computergegner 3", SPIELER_ART.COMPUTERGEGNER, new System.Net.IPAddress(0));
}
if (L_Name_Spieler_blau.Text.ToString() == "Computergegner")
{
Spieler CP_Gegner1 = new Spieler(FARBE.BLAU, "Computergegner 4", SPIELER_ART.COMPUTERGEGNER, new System.Net.IPAddress(0));
}
Spieler host_spieler = new Spieler(ausgewählte_farbe, Spielername_eingabe.Text, SPIELER_ART.NORMALER_SPIELER, eigene_IPAddresse);
host_spieler.status = true;
string client_startmessage = Statische_Methoden.Erstelle_Startnachricht_für_clients();
foreach (Spieler spieler in alle_Spieler)
{
if (spieler.spieler_art == SPIELER_ART.NORMALER_SPIELER)
{
Netzwerkkommunikation.Send_TCP_Packet(client_startmessage, spieler.ip);
}
}
Spielerstellenlabel.Clear();
root_Frame.Content = new Spielwiese(root_Frame);
}
}
