using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using _1869_Remake;
using _1869_Remake.ToolKlassen;
using _1869_Remake.Entities;
using Otter;

namespace _1869_Remake.Scenes
{
    public class HandelScene : Scene
    {
        // Der Handelsscreen ist etwas Tricky da hier bei jedem neuen Mal des Aufrufens, eine neue Konstellation an Elementen gen werden muss
        // -> Beispiel Konstellationen : BG: Holzhütte, Tafelwand: Ziegel mit Fass, Hintergrund: Tür geschlossen, Verkäufer: alter Mann      

        //TO Do: a) Sprites für Baukasten extrahieren -> erster Schritt screens aller Einkaufszimmer für alle Häfen & Positionen bei den Sprites auslooten(möglichst vereinheitlichen sonst muss alles feinjustiert werden)
        

        Dictionary<string, Image> BG = new Dictionary<string, Image>();
        Dictionary<string, Image> BG_Rechts = new Dictionary<string, Image>();
        Dictionary<string, Image> Verkäufer_Gesicht = new Dictionary<string, Image>();
        Dictionary<string, Image> Verkäufer_OKörper = new Dictionary<string, Image>();
        Dictionary<string, Image> Verkäufer_Hände = new Dictionary<string, Image>();
        Dictionary<string, Image> Verkäufer_DekoVerkäufer = new Dictionary<string, Image>();
        Dictionary<string, Image> Fenster_Tür = new Dictionary<string, Image>();
        Dictionary<string, Image> Tisch = new Dictionary<string, Image>();
        Dictionary<string, Image> TischFachL = new Dictionary<string, Image>();
        Dictionary<string, Image> TischFachM = new Dictionary<string, Image>();
        Dictionary<string, Image> TischFachR = new Dictionary<string, Image>();
        Dictionary<string, Image> Tisch_Deko_Boden = new Dictionary<string, Image>();
        Dictionary<string, Image> Tür_FeldL = new Dictionary<string, Image>();
        Dictionary<string, Image> Tür_FeldR = new Dictionary<string, Image>();
        Dictionary<string, Image> Decke_L = new Dictionary<string, Image>();
        Dictionary<string, Image> Decke_M = new Dictionary<string, Image>();
        Dictionary<string, Image> Decke_R = new Dictionary<string, Image>();
        Dictionary<string, Image> DekoTisch_L = new Dictionary<string, Image>();
        Dictionary<string, Image> DekoTisch_M = new Dictionary<string, Image>();
        Dictionary<string, Image> DekoTisch_R = new Dictionary<string, Image>();
        Dictionary<string, Image> Tafel = new Dictionary<string, Image>();
        Dictionary<string, Image> Tafel_BG = new Dictionary<string, Image>();
        Dictionary<string, Image> Tafel_VG = new Dictionary<string, Image>();

        //Liste aller Images, die angezeigt werden müssen in diesem Screen
        List<Image> AnzeigeListe = new List<Image>();

        TextBuilder TextLieferant;

        public Image FadeInBlackScreen = new Image(Assets.BLACKSCREEN);
        public Image FadeOutBlackScreen = new Image(Assets.BLACKSCREEN);

        //AnzeigeTimer 
        public const float TIMER_GRENZE = 90f;
        public float szenenTimer = 0f;
        public bool wahlFertig = true;
        public bool anzeigeFertig = false;

        //Temporärer Speicherort für die im Auswahlbaum gewählte Ware
        public Ware gewählteHandelsWare;
        //Temporärer Speicherort für die Filiale die aktuell verfügbar ist
        public Filiale gewählteSpielerFiliale;
        //Temporärer Speicherort für die Filiale die aktuell verfügbar ist
        public Schiff gewähltesSpielerSchiff;
        public string gewählteGeldQuelle;
        //Menge an Waren und Preis die gehandelt werden
        public int gewählteMenge;
        public int gewählterPreis;
        public string gewähltesZiel;
        public bool WareLeer = false;
        public bool GeldLeer = false;
        //Temporäre Liste der möglichen Geldquellen
        public List<string> möglicheGeldQuellen = new List<string>();
        public int geldQuellenIndex = 0;
        //Letzte dem Textbuilder übergebene Liste an Paramtern (Wird nur für Shortcut funktionalität verwender)
        private List<string> letzteÜbergebeneListe = new List<string>();
                
        public Hafen aktuellerHafen;

        //TempTextVariablen
        Queue<string> TempSprachText = new Queue<string>();
        Queue<string> TempSprachParams = new Queue<string>();
        Queue<string> TempQueue = new Queue<string>();
        Schiff TempGeldQuellenSchiff;
        Filiale TempGeldQuellenFiliale;


        public HandelScene(string Preset)
        {
            //Initialisieren des Hauptbildschirms und einblenden
            Globals.aktuelleSzene = "Handel";

            //Informationen zum aktuellen Hafen wird geladen, Alle Handlungen beeinflussen den globalen Zustand des Hafens
            aktuellerHafen = Globals.AlleHäfen[Preset];
            //TestLogging
            Console.WriteLine("Aktueller Hafen ist " + aktuellerHafen.NAME);

            //Presets über die Dictionaries vorbereiten
            setzePresets();

            //Gewähltes Preset aus dem Pool in die anzeigeliste schreiben
            importierePresetInListe(Preset);

            //anzeigen der anzeigeListe
            ladePresets();

            //TextBuilder einbinden (POS = Unterer RAND)
            TextLieferant = new TextBuilder(Globals.aktuelleSzene);
            Add(TextLieferant);

            //Einleitungssprachtexte 
            Queue<string> WillkommensText = new Queue<string>();
            WillkommensText.Enqueue("Helfen");
            TextLieferant.erzeugeSprachText(WillkommensText, new Queue<string>(), Globals.Remake.HalfWidth, 100);

            //Auswahltexte
            TextLieferant.erzeugeAuswahlText(new Queue<string>(), 25, 410);

            //Tafeltexte
            List<Ware> TempWarenListeExport = new List<Ware>();
            List<Ware> TempWarenListeImport = new List<Ware>();

            //Füllen aller vorhanden Waren in eine Liste für die TafelTexte(Export zuerst)
            foreach (Ware item in Globals.AlleHäfen[Preset].EXPORTWARE)
            {
                TempWarenListeExport.Add(item);
            }

            foreach (Ware item in Globals.AlleHäfen[Preset].IMPORTWARE)
            {
                TempWarenListeImport.Add(item);
            }

            //Erzeuge Tafeltexte mit Position der Tafel -> Texte werden intern im Builder richtig Positioniert und mit den Filler-Texten versehen
            TextLieferant.erzeugeTafelText(TempWarenListeExport, TempWarenListeImport);

            //Vorbereiten des Blackscreens
            FadeInBlackScreen.CenterOrigin();
            FadeInBlackScreen.X = Globals.Remake.HalfWidth;
            FadeInBlackScreen.Y = Globals.Remake.HalfHeight;
            FadeInBlackScreen.Alpha = 1f;

            FadeOutBlackScreen.CenterOrigin();
            FadeOutBlackScreen.X = Globals.Remake.HalfWidth;
            FadeOutBlackScreen.Y = Globals.Remake.HalfHeight;
            FadeOutBlackScreen.Alpha = 0f;

            Tween(FadeInBlackScreen, new { Alpha = 0f }, 64f, 0f).Ease(Ease.BackInOut);
            AddGraphics(FadeInBlackScreen);
            AddGraphic(FadeOutBlackScreen);
        }

        public override void Update()
        {
            base.Update();
            // In der Klasse wird nur anzeige logik behandelt -> Klicklogik wird von Textbuilder abgefangen
            // Resultat eines Klicks wird hier aber gecheckt und bei richtiger Situation in andere Szene gewechselt

            //hochzählendes Zeitelement um Aktionen in der Szene zu Takten
            szenenTimer++;

            if (FadeOutBlackScreen.Alpha >= 0.999f)
            {
                Globals.LetzteSzene = "Handel";
                this.RemoveAll();
                Globals.Remake.SwitchScene(new worldMap());
            }

            //Bei Tick überprüfen, ob etwas im Textbuilder geklickt wurde (1 = Obere Auswahl, 2 = Mitlere Auswahl, 3 = Untere Auswahl, 4 = Oberer Pfeil, 5 = unterer Pfeil)
            //Zuerst überprüfen auf welcher Ebene wir uns aktuell befinden und danach was dort geklickt wurde

            int tempAuswahl = TextLieferant.checkAuswahl();
            string auswahlMouseButton = TextLieferant.checkButtonAuswahl();

            switch (TextLieferant.aktuelleEbene)
            {
                // Textbaum - Root
                case "1":
                    #region RootLogik

                    switch (tempAuswahl)
                    {
                        case 0:
                            //Noch keine Auswahl getroffen
                            break;

                        // Hier muss für jede Auswahl immer alle Möglichen Baumstränge abgedeckt werden, wenn neuer Baumzweig hinzukommt muss hier seine Auswahl verwaltet werdenkd
                        case 1:
                            Console.WriteLine("Auswahl " + tempAuswahl + " der Ebene " + TextLieferant.aktuelleEbene);
                            letzteÜbergebeneListe.Clear();

                            //Auswahl Angebot                                                        
                            foreach (Ware item in aktuellerHafen.EXPORTWARE)
                            {
                                TempQueue.Enqueue(item.BEZEICHNUNG);
                                letzteÜbergebeneListe.Add(item.BEZEICHNUNG);
                            }

                            Queue<string> TempSprachText = new Queue<string>();

                            // Wenn Hafen keine Waren für Export hat kann keine Einkaufslogik erfolgen
                            if (TempQueue.Count() == 0)
                            {

                                TempSprachText.Enqueue("Ausverkauft");
                                TextLieferant.erzeugeSprachText(TempSprachText, new Queue<string>(), Globals.Remake.HalfWidth, 100);
                            }
                            else
                            {
                                // Wenn dieser Übergang kein Shortcut ist Sprachtext auslösen
                                if (TempQueue.Count() > 1)
                                {
                                    TempSprachText.Enqueue("Wählen_EINKAUF");
                                    TextLieferant.erzeugeSprachText(TempSprachText, new Queue<string>(), Globals.Remake.HalfWidth, 100);
                                }
                                else
                                {
                                    // Wenn nur eine Auswahlmöglichkeit im nächsten Baumzweig zu erwarten wäre, wird eine Auswahl vorgewählt (Shortcut Funktion)
                                    if (TempQueue.Count() == 1)
                                    {
                                        TextLieferant.setAuswahl(1);
                                    }
                                }
                                TextLieferant.wechsleAuswahlText("1.1A", TempQueue, true);

                            }

                            break;
                        case 2:
                            Console.WriteLine("Auswahl " + tempAuswahl + " der Ebene " + TextLieferant.aktuelleEbene);
                            //Auswahl Verkauf 

                            //Sammeln aller möglichen Warenquellen                           
                            //Wenn Filiale vorhanden -> Lager ist mögliche Quelle    

                            // MöglicheGeldQuelle wird im Verkaufsstrang als ZielKasse benutzt
                            möglicheGeldQuellen.Clear();
                            if (aktuellerHafen.filialeVorhanden)
                            {
                                foreach (Filiale f in aktuellerHafen.vorhandeneFilialen)
                                {
                                    if (f.BESITZER == Globals.AktuellerSpieler && f.LAGER.IsNotEmpty())
                                    {
                                        TempQueue.Enqueue("Verkauf aus Lager");
                                        möglicheGeldQuellen.Add("LAGER");
                                        letzteÜbergebeneListe.Add("LAGER");
                                    }
                                }

                            }

                            //Wenn Schiffe vorhanden -> Schiff ist mögliche Quelle
                            foreach (Schiff Boot in aktuellerHafen.angedockteSchiffe)
                            {
                                if (Boot.COMMANDEUR == Globals.AktuellerSpieler)
                                {
                                    if (Boot.LADUNG.IsNotEmpty())
                                    {
                                        TempQueue.Enqueue(Boot.NAME);

                                        letzteÜbergebeneListe.Add(Boot.NAME);
                                    }
                                    //Mögliche Geldziele sind alle Schiffe des Spielers
                                    möglicheGeldQuellen.Add(Boot.NAME);

                                }
                            }

                            // Wenn nur eine Auswahlmöglichkeit im nächsten Baumzweig zu erwarten wäre, wird eine Auswahl vorgewählt (Shortcut Funktion)
                            TempSprachText = new Queue<string>();

                            // Wenn Hafen keine Waren für Import hat -> kann keine Verkaufslogik erfolgen
                            if (TempQueue.Count() == 0)
                            {

                                TempSprachText.Enqueue("Warenlos");
                                TextLieferant.erzeugeSprachText(TempSprachText, new Queue<string>(), Globals.Remake.HalfWidth, 100);
                            }
                            else
                            {
                                // Wenn dieser Übergang kein Shortcut ist Sprachtext auslösen
                                if (TempQueue.Count() == 1)
                                {
                                    TextLieferant.setAuswahl(1);
                                }
                                else
                                {
                                    TempSprachText.Enqueue("HANDEL_VERKAUFSQUELLE");
                                    TextLieferant.erzeugeSprachText(TempSprachText, new Queue<string>(), Globals.Remake.HalfWidth, 100);
                                }
                                TextLieferant.wechsleAuswahlText("1.2A", TempQueue, true);
                            }
                            break;

                        case 3:
                            Console.WriteLine("Auswahl 3 Logik des Handelsfensters");

                            //Untere Auswahl im ersten MenüBaum = Verlassen
                            //FadeOut zu WorldMap                                           
                            Tween(FadeOutBlackScreen, new { Alpha = 1f }, 180f, 0f).Ease(Ease.BackInOut);

                            TextLieferant.setzeFadeOut();

                            break;

                    }

                    #endregion

                    break;
                //Auswahlmöglichkeiten Angebot (Hier werden die Exportwaren angezeigt)
                case "1.1A":
                    #region AngebotsLogik - Warenauswahl
                    // Hier wird die Ware ausgewählt und die anzeige des Ziels vorbereitet
                    switch (tempAuswahl)
                    {
                        case 0:
                            //Noch keine Auswahl getroffen
                            break;

                        case 999:
                            // 999 bei variablen Listen ist immer Abbruch
                            // Wenn abbruch erfolgen soll -> zurück zu Root
                            letzteÜbergebeneListe.Clear();
                            gewählteHandelsWare = null;
                            gewählteSpielerFiliale = null;
                            gewähltesSpielerSchiff = null;
                            TextLieferant.wechsleAuswahlText("1", new Queue<string>(), false);
                            break;

                        default:
                            // Bei allen anderen werten übernahme des aktuellen Wertes
                            // Es können nur max. 2 Exportwaren angezeigt werden trotzdem werden unendlich viele (außer 999 abgefangen)                            

                            // Übernahme der gewählten Ware (-1 hier weil der Textbuilder von 1 beginnt zu zählen
                            gewählteHandelsWare = aktuellerHafen.EXPORTWARE[tempAuswahl - 1];
                            letzteÜbergebeneListe.Clear();
                            möglicheGeldQuellen.Clear();

                            // Aufbau der Auswahlliste, je nach dem was vorhanden ist (Keine Absicherung, da mindestens 1 Eintrag da sein muss sonst wäre man nicht in diesem Menü)
                            // Wenn aber nur 1 Eintrag vorhanden ist, direkt diesen auswählen (Shortcut Funktion)                            
                            if (aktuellerHafen.filialeVorhanden)
                            {
                                TempQueue.Enqueue("Die Ware soll ins Lager!");
                                letzteÜbergebeneListe.Add("LAGER");
                                möglicheGeldQuellen.Add("LAGER");

                            }

                            foreach (Schiff Boot in aktuellerHafen.angedockteSchiffe)
                            {
                                TempQueue.Enqueue(Boot.NAME);
                                letzteÜbergebeneListe.Add(Boot.NAME);
                                möglicheGeldQuellen.Add(Boot.NAME);

                            }

                            // Da hier immer mindestens 1 ist brauchen wir auf keine gefunden nicht abfangen
                            if (TempQueue.Count() == 1)
                            {
                                //Shortcut zu Mengenbestimmungsscreen setzen
                                TextLieferant.setAuswahl(1);
                            }
                            else
                            {
                                // Wenn kein Shortcut erfolgen soll muss ein Text angezeigt werden
                                TempSprachText.Enqueue("Wählen_ZIEL");
                                TextLieferant.erzeugeSprachText(TempSprachText, new Queue<string>(), Globals.Remake.HalfWidth, 100);

                            }
                            //Wechsel zu Auswahl von Ziellagerort
                            TextLieferant.wechsleAuswahlText("1.1B", TempQueue, true);
                            break;
                    }
                    #endregion 
                    break;
                //Auswahlmöglichkeiten Ziellagerort (Hier werden die im Hafen vorhandenen Ziele angezeigt)
                case "1.1B":
                    #region Angebotslogik - Ziellagerort 
                    //Auswahl des Ziels und Vorbereitung für Handelsbestätigung 
                    switch (tempAuswahl)
                    {
                        case 0:
                            //Noch keine Auswahl getroffen
                            break;
                        case 999:
                            // 999 bei variablen Listen ist immer Abbruch

                            // Wenn abbruch erfolgen soll -> zurück zu Root
                            letzteÜbergebeneListe.Clear();
                            gewählteHandelsWare = null;
                            gewählteSpielerFiliale = null;
                            gewähltesSpielerSchiff = null;
                            TextLieferant.wechsleAuswahlText("1", new Queue<string>(), false);
                            break;

                        default:
                            // Bei allen anderen Werten 
                            // Übernahme der letzen Auswahl (Überprüfen ob letzte Auswahl eine Filiale oder Schiff war)
                            gewähltesSpielerSchiff = null;
                            gewählteSpielerFiliale = null;
                            TempGeldQuellenSchiff = null;
                            TempGeldQuellenFiliale = null;

                            bool TempWareMinKauf = false;

                            // Übernahme des gewählten Ortes als default Geldquelle                            
                            geldQuellenIndex = tempAuswahl - 1;
                            gewählteGeldQuelle = möglicheGeldQuellen[geldQuellenIndex];

                            if (letzteÜbergebeneListe[tempAuswahl - 1] == "LAGER")
                            {
                                gewählteSpielerFiliale = aktuellerHafen.überprüfeAktuelleFilialeVorhanden(Globals.AktuellerSpieler);
                                TempGeldQuellenFiliale = gewählteSpielerFiliale;
                            }
                            else
                            {
                                // Wenn nicht die Filiale gewählt wurde sondern ein bestimmtes Schiff -> Finden des Schiffs
                                List<Schiff> TempListe = aktuellerHafen.überprüfeEigeneSchiffeVorhanden(Globals.AktuellerSpieler);

                                foreach (Schiff s in TempListe)
                                {
                                    if (s.NAME == letzteÜbergebeneListe[tempAuswahl - 1])
                                    {
                                        gewähltesSpielerSchiff = s;
                                        TempGeldQuellenSchiff = s;
                                        break;
                                    }

                                }
                            }

                            // Wenn der ZielLagerort bekannt ist muss die maximal Einkaufsmenge errechnet werden
                            gewählteMenge = 0;
                            gewählterPreis = 0;
                            if (gewählteSpielerFiliale != null)
                            {

                                gewählteMenge = gewählteSpielerFiliale.BUDGET / (gewählteHandelsWare.LAGERPREIS);
                                if (gewählteMenge == 0)
                                {
                                    TempWareMinKauf = true;
                                }

                                //überprüfen, wie viel maximalware im Hafenlager ist
                                WareLeer = false;
                                foreach (Ware item in aktuellerHafen.EXPORTWARE)
                                {
                                    if (item.BEZEICHNUNG == gewählteHandelsWare.BEZEICHNUNG)
                                    {
                                        if (item.MENGE < gewählteMenge)
                                        {
                                            // Wenn im Hafen verfügbare Menge kleiner der errechneten max budget Menge dann nur soviel verkaufen als auch im Hafen ist
                                            gewählteMenge = item.MENGE;
                                            //setzen Indikator, dass Mengengrenze erreicht ist
                                            WareLeer = true;
                                        }
                                    }
                                }
                                gewählterPreis = gewählteMenge * gewählteHandelsWare.LAGERPREIS;
                                gewähltesZiel = "LAGER";

                            }
                            else
                            {
                                gewählteMenge = gewähltesSpielerSchiff.SCHIFFSBUDGET / (gewählteHandelsWare.LAGERPREIS);
                                if (gewählteMenge == 0)
                                {
                                    TempWareMinKauf = true;
                                }

                                //überprüfen, wie viel maximalware im Hafenlager ist
                                foreach (Ware item in aktuellerHafen.EXPORTWARE)
                                {
                                    if (item.BEZEICHNUNG == gewählteHandelsWare.BEZEICHNUNG)
                                    {
                                        if (item.MENGE < gewählteMenge)
                                        {
                                            // Wenn im Hafen verfügbare Menge kleiner der errechneten max budget Menge dann nur soviel verkaufen als auch im Hafen ist
                                            gewählteMenge = item.MENGE;
                                            //setzen Indikator, dass Mengengrenze erreicht ist
                                            WareLeer = true;
                                        }
                                    }
                                }
                                gewählterPreis = gewählteMenge * gewählteHandelsWare.LAGERPREIS;
                                gewähltesZiel = gewähltesSpielerSchiff.NAME;
                            }

                            // Alte Übergabeliste wird nicht mehr benötigt und verworfen
                            letzteÜbergebeneListe.Clear();

                            // Aufbau der Auswahlliste, je nach dem was vorhanden ist (Keine Absicherung, da mindestens 1 Eintrag da sein muss sonst wäre man nicht in diesem Menü)
                            // Wenn aber nur 1 Eintrag vorhanden ist, direkt diesen auswählen (Shortcut Funktion)                            

                            // 1. Param ist errechnete max Menge im Bezug auf vorhandenem Budget sein  
                            TempQueue.Enqueue(gewählteMenge.ToString());
                            letzteÜbergebeneListe.Add(gewählteMenge.ToString());

                            // 2. Param ist Lademittel der Ware
                            if (gewählteMenge > 1)
                                TempQueue.Enqueue(gewählteHandelsWare.LADEMITTEL + "N");
                            else
                                TempQueue.Enqueue(gewählteHandelsWare.LADEMITTEL);
                            letzteÜbergebeneListe.Add(gewählteHandelsWare.LADEMITTEL);

                            // 3. Param ist der Name der Ware
                            TempQueue.Enqueue(gewählteHandelsWare.BEZEICHNUNG);
                            letzteÜbergebeneListe.Add(gewählteHandelsWare.BEZEICHNUNG);

                            // 4. Param ist der Zielort
                            if (gewähltesZiel == "LAGER")
                            {
                                TempQueue.Enqueue("INS " + gewähltesZiel);
                            }
                            else
                            {
                                TempQueue.Enqueue("AUF DIE " + gewähltesZiel);
                            }
                            letzteÜbergebeneListe.Add(gewähltesZiel);

                            // 5. Param ist der GeldQuelle
                            if (gewähltesZiel == "LAGER")
                            {
                                TempQueue.Enqueue("IM " + gewähltesZiel + " VERFÜGE ICH");
                            }
                            else
                            {
                                TempQueue.Enqueue("DIE " + gewähltesZiel + " VERFÜGT");
                            }
                            letzteÜbergebeneListe.Add(gewähltesZiel);

                            // 6. Param Budget des Ziels in EURO                            
                            if (TempGeldQuellenFiliale != null)
                            {
                                TempQueue.Enqueue((TempGeldQuellenFiliale.BUDGET / 100).ToString());
                                letzteÜbergebeneListe.Add((TempGeldQuellenFiliale.BUDGET / 100).ToString());
                            }
                            else
                            {
                                TempQueue.Enqueue((TempGeldQuellenSchiff.SCHIFFSBUDGET / 100).ToString());
                                letzteÜbergebeneListe.Add((TempGeldQuellenSchiff.SCHIFFSBUDGET / 100).ToString());
                            }


                            // 7. Param Budget des Ziels in CENT
                            if (gewählteSpielerFiliale != null)
                            {
                                TempQueue.Enqueue((TempGeldQuellenFiliale.BUDGET % 100).ToString());
                                letzteÜbergebeneListe.Add((TempGeldQuellenFiliale.BUDGET % 100).ToString());
                            }
                            else
                            {
                                TempQueue.Enqueue((TempGeldQuellenSchiff.SCHIFFSBUDGET % 100).ToString());
                                letzteÜbergebeneListe.Add((TempGeldQuellenSchiff.SCHIFFSBUDGET % 100).ToString());
                            }

                            // Veranlassen eines Initialsprachtextes mit Erläuterung zum Preis -> Preisbildung wird zuerst erläutert                           

                            // Überprüfen ob das gewählte Ziel genügend geld hat für wenigstens 1 Kiste Ware
                            if (TempWareMinKauf)
                            {
                                TempSprachText.Enqueue("Geldlos");
                                TempSprachText.Enqueue("Geldlos2");
                                TempSprachText.Enqueue("Geldlos3");

                                // Füllen der Sprachparameter
                                // # VERFÜGT NICHT ÜBER GENÜGEND GELD FÜR MINDESTENS 1 #
                                // 1. # = Geldquelle ("IHR LAGER" || "DIE <Schiffsname>"), 2. # = Lademittel
                                if (TempGeldQuellenFiliale != null)
                                {
                                    TempSprachParams.Enqueue("IHR LAGER");
                                }
                                else
                                {
                                    TempSprachParams.Enqueue("DIE " + TempGeldQuellenSchiff.NAME);
                                }

                                TempSprachParams.Enqueue((gewählteHandelsWare.LADEMITTEL));

                            }
                            else
                            {
                                // Wenn mehr als 1 Kiste gekauft werden kann wird dieser Text angezeigt
                                TempSprachText.Enqueue("Erläuterung1");
                                TempSprachText.Enqueue("Erläuterung2");

                                // Füllen der Sprachparameter
                                // 1. Text: # ERHALTEN SIE FÜR $ #,# je # !
                                // 1. # = Warenbezeichnung, 2. # = Preis Dollar, 3. # = Preis Cent, 4. # = Lademittel

                                TempSprachParams.Enqueue(gewählteHandelsWare.BEZEICHNUNG);
                                TempSprachParams.Enqueue((gewählteHandelsWare.LAGERPREIS / 100).ToString());
                                TempSprachParams.Enqueue((gewählteHandelsWare.LAGERPREIS % 100).ToString());
                                TempSprachParams.Enqueue((gewählteHandelsWare.LADEMITTEL));
                                // 2. Text: DIE # # KOSTEN SIE DAHER $ #,#
                                // 1. # = Menge, 2. # = Lademittel, 3. # = Preis Dollar, 4. # = Preis Cent
                                TempSprachParams.Enqueue(gewählteMenge.ToString());
                                if (gewählteMenge > 1)
                                {
                                    TempSprachParams.Enqueue((gewählteHandelsWare.LADEMITTEL + "N"));
                                }
                                else
                                {
                                    TempSprachParams.Enqueue((gewählteHandelsWare.LADEMITTEL));
                                }

                                TempSprachParams.Enqueue((gewählterPreis / 100).ToString());
                                TempSprachParams.Enqueue((gewählterPreis % 100).ToString());

                            }

                            TextLieferant.erzeugeSprachText(TempSprachText, TempSprachParams, Globals.Remake.HalfWidth, 100);

                            TextLieferant.wechsleAuswahlText("1.1.1", TempQueue, false);

                            break;
                    }

                    #endregion
                    break;
                //Auswahlmöglichkeiten Abschluss des Handels (Hier wird Preis/Menge)
                case "1.1.1":
                    #region Abschluss Einkauf

                    switch (tempAuswahl)
                    {
                        case 0:
                            //Noch keine Auswahl getroffen
                            break;
                        case 1:
                            // Auswahl 1: Mengenregulierung (Links klick mehr Menge/Rechtsklick weniger Menge)
                            //Neu Berechnung der Menge und überprüfen ob Max oder Min Menge erreicht                            

                            // Indikator resetten
                            WareLeer = false;
                            GeldLeer = false;

                            if (auswahlMouseButton == "MausLinks")
                            {
                                // Logik fürs erhöhen der Menge  
                                if (TempGeldQuellenFiliale != null)
                                {
                                    // Logik bei gewählter Filiale

                                    // Überprüfen, ob mindestens 1 Lademittel gekauft werden kann
                                    int TempMaxMenge = TempGeldQuellenFiliale.BUDGET / (gewählteHandelsWare.LAGERPREIS);

                                    // Erhöhen der Menge(Wenn Warenmenge > im Hafen vorhandener Menge wird erhöhung nicht erlaubt + Sprachtext als hinweis)
                                    gewählteMenge++;

                                    if (TempMaxMenge == 0)
                                    {
                                        gewählteMenge = 0;
                                    }

                                    //Sprachtext vorbereiten
                                    if (gewählteMenge == 0)
                                    {
                                        //Minimalmenge erreicht -> Ausgabe Sprachtext für zu keine Berechnung
                                        TempSprachText.Enqueue("KeineKosten");
                                    }
                                    else
                                    {

                                        //überprüfen, wie viel maximalware im Hafenlager ist
                                        foreach (Ware item in aktuellerHafen.EXPORTWARE)
                                        {
                                            if (item.BEZEICHNUNG == gewählteHandelsWare.BEZEICHNUNG)
                                            {
                                                if (item.MENGE < gewählteMenge)
                                                {
                                                    // Wenn im Hafen verfügbare Menge kleiner der errechneten max budget Menge dann nur soviel verkaufen als auch im Hafen ist
                                                    gewählteMenge = item.MENGE;
                                                    //setzen Indikator, dass Mengengrenze erreicht ist
                                                    WareLeer = true;
                                                }
                                            }
                                        }

                                        // Wenn gewählte Menge größer als maximale Menge ist muss wieder zurückreduziert werden und budget reicht nicht text eingeblendet werden
                                        if (TempMaxMenge < gewählteMenge)
                                        {
                                            gewählteMenge--;
                                            //Maximalmenge erreicht -> Ausgabe Sprachtext für zu viel Menge
                                            GeldLeer = true;
                                        }
                                    }


                                }
                                else
                                {
                                    // Logik bei gewähltem Schiff
                                    // Überprüfen, ob mindestens 1 Lademittel gekauft werden kann
                                    int TempMaxMenge = TempGeldQuellenSchiff.SCHIFFSBUDGET / (gewählteHandelsWare.LAGERPREIS);

                                    // Erhöhen der Menge(Wenn Warenmenge > im Hafen vorhandener Menge wird erhöhung nicht erlaubt + Sprachtext als hinweis)
                                    gewählteMenge++;

                                    if (TempMaxMenge == 0)
                                    {
                                        gewählteMenge = 0;
                                    }

                                    //Sprachtext vorbereiten
                                    if (gewählteMenge == 0)
                                    {
                                        //Minimalmenge erreicht -> Ausgabe Sprachtext für zu keine Berechnung
                                        TempSprachText.Enqueue("KeineKosten");
                                    }
                                    else
                                    {
                                        //überprüfen, wie viel maximalware im Hafenlager ist
                                        foreach (Ware item in aktuellerHafen.EXPORTWARE)
                                        {
                                            if (item.BEZEICHNUNG == gewählteHandelsWare.BEZEICHNUNG)
                                            {
                                                if (item.MENGE < gewählteMenge)
                                                {
                                                    // Wenn im Hafen verfügbare Menge kleiner der errechneten max budget Menge dann nur soviel verkaufen als auch im Hafen ist
                                                    gewählteMenge = item.MENGE;
                                                    //setzen Indikator, dass Mengengrenze erreicht ist
                                                    WareLeer = true;
                                                }
                                            }
                                        }

                                        // Wenn gewählte Menge größer als maximale Menge ist muss wieder zurückreduziert werden und budget reicht nicht text eingeblendet werden
                                        if (TempMaxMenge < gewählteMenge)
                                        {
                                            gewählteMenge--;
                                            GeldLeer = true;

                                        }


                                    }
                                }

                            }
                            else
                            {
                                if (auswahlMouseButton == "MausRechts")
                                {
                                    // Logik fürs vermindern der Menge                                  
                                    // Fallunterscheidung für Filiale oder Schiff nicht nötig da beide untergrenze 0 haben
                                    if (gewählteMenge <= 0)
                                    {
                                        //Minimalmenge erreicht -> Ausgabe Sprachtext für zu keine Berechnung
                                        gewählteMenge = 0;
                                        TempSprachText.Enqueue("KeineKosten");

                                    }
                                    else
                                    {
                                        // Wenn nicht erreicht -> Vermindere um 1 ( Im Original waren es hier Mengenabschnitte -> Ich finde einzelschritte Sinnvoller)
                                        gewählteMenge--;
                                    }
                                }
                            }

                            // Neu berechnen des Preises je nach neuer Menge
                            gewählterPreis = gewählteMenge * gewählteHandelsWare.LAGERPREIS;

                            // Aufbau der Auswahlliste, je nach dem was vorhanden ist (Keine Absicherung, da mindestens 1 Eintrag da sein muss sonst wäre man nicht in diesem Menü)
                            // Wenn aber nur 1 Eintrag vorhanden ist, direkt diesen auswählen (Shortcut Funktion)

                            // 1. Param ist errechnete max Menge im Bezug auf vorhandenem Budget sein  
                            TempQueue.Enqueue(gewählteMenge.ToString());
                            letzteÜbergebeneListe.Add(gewählteMenge.ToString());

                            // 2. Param ist Lademittel der Ware
                            if (gewählteMenge > 1)
                            {
                                TempQueue.Enqueue(gewählteHandelsWare.LADEMITTEL + "N");
                            }
                            else
                            {
                                TempQueue.Enqueue(gewählteHandelsWare.LADEMITTEL);
                            }

                            letzteÜbergebeneListe.Add(gewählteHandelsWare.LADEMITTEL);

                            // 3. Param ist der Name der Ware
                            TempQueue.Enqueue(gewählteHandelsWare.BEZEICHNUNG);
                            letzteÜbergebeneListe.Add(gewählteHandelsWare.BEZEICHNUNG);

                            // 4. Param ist der Zielort
                            if (gewähltesZiel == "LAGER")
                            {
                                TempQueue.Enqueue("INS " + gewähltesZiel);
                            }
                            else
                            {
                                TempQueue.Enqueue("AUF DIE " + gewähltesZiel);
                            }

                            // 5. Param ist der GeldQuelle
                            if (gewählteGeldQuelle == "LAGER")
                            {
                                TempQueue.Enqueue("IM " + gewählteGeldQuelle + " VERFÜGE ICH");
                            }
                            else
                            {
                                TempQueue.Enqueue("DIE " + gewählteGeldQuelle + " VERFÜGT");
                            }
                            letzteÜbergebeneListe.Add(gewählteGeldQuelle);

                            // 6. Param Budget des Ziels in EURO
                            if (gewählteGeldQuelle == "LAGER")
                            {
                                TempQueue.Enqueue((TempGeldQuellenFiliale.BUDGET / 100).ToString());
                                letzteÜbergebeneListe.Add((TempGeldQuellenFiliale.BUDGET / 100).ToString());
                            }
                            else
                            {
                                TempQueue.Enqueue((TempGeldQuellenSchiff.SCHIFFSBUDGET / 100).ToString());
                                letzteÜbergebeneListe.Add((TempGeldQuellenSchiff.SCHIFFSBUDGET / 100).ToString());
                            }

                            // 7. Param Budget des Ziels in CENT
                            if (TempGeldQuellenFiliale != null)
                            {
                                TempQueue.Enqueue((TempGeldQuellenFiliale.BUDGET % 100).ToString());
                                letzteÜbergebeneListe.Add((TempGeldQuellenFiliale.BUDGET % 100).ToString());
                            }
                            else
                            {
                                TempQueue.Enqueue((TempGeldQuellenSchiff.SCHIFFSBUDGET % 100).ToString());
                                letzteÜbergebeneListe.Add((TempGeldQuellenSchiff.SCHIFFSBUDGET % 100).ToString());
                            }

                            // Veranlassen eines Sprachtextes mit Erläuterung zum neuen Preis
                            // & Füllen der Sprachparameter  
                            // Besonderheit: Geldmangel > Warenmangel | D.h. Wenn Spieler sowohl zu wenig Geld hat sowie der Hafen nicht mehr Ware hat wird nur
                            // angezeigt, dass das Geld fehlt 
                            if (GeldLeer)
                            {
                                TempSprachText.Enqueue("BudgetReichtNicht");
                                TempSprachText.Enqueue("Kosten");
                                TempSprachParams.Enqueue((gewählterPreis / 100).ToString());
                                TempSprachParams.Enqueue((gewählterPreis % 100).ToString());
                                GeldLeer = false;
                            }
                            else
                            {
                                if (WareLeer)
                                {
                                    TempSprachText.Enqueue("Restposten1");
                                    TempSprachText.Enqueue("Restposten2");
                                    // Params Restposten 1
                                    TempSprachParams.Enqueue(gewählteMenge.ToString());
                                    if (gewählteMenge > 1)
                                    {
                                        TempSprachParams.Enqueue(gewählteHandelsWare.LADEMITTEL + "N");
                                    }
                                    else
                                    {
                                        TempSprachParams.Enqueue(gewählteHandelsWare.LADEMITTEL);
                                    }
                                    TempSprachParams.Enqueue(gewählteHandelsWare.BEZEICHNUNG);
                                    // Params Restposten 2
                                    TempSprachParams.Enqueue(gewählteMenge.ToString());
                                    if (gewählteMenge > 1)
                                    {
                                        TempSprachParams.Enqueue(gewählteHandelsWare.LADEMITTEL + "N");
                                    }
                                    else
                                    {
                                        TempSprachParams.Enqueue(gewählteHandelsWare.LADEMITTEL);
                                    }
                                    TempSprachParams.Enqueue((gewählterPreis / 100).ToString());
                                    TempSprachParams.Enqueue((gewählterPreis % 100).ToString());
                                    WareLeer = false;
                                }
                                else
                                {
                                    if (gewählteMenge != 0)
                                    {
                                        TempSprachText.Enqueue("Kosten");
                                        TempSprachParams.Enqueue((gewählterPreis / 100).ToString());
                                        TempSprachParams.Enqueue((gewählterPreis % 100).ToString());
                                    }
                                }
                            }

                            TextLieferant.erzeugeSprachText(TempSprachText, TempSprachParams, Globals.Remake.HalfWidth, 100);

                            TextLieferant.wechsleAuswahlText("1.1.1", TempQueue, false);

                            break;
                        case 2:
                            // Auswahl 2: Abschluss Handel
                            // Übergeben der gekauften Ware an den Ziellagerort
                            // Nur Logik erlauben wenn links geklickt wurde nicht rechts
                            if (auswahlMouseButton == "MausLinks")
                            {
                                if (gewähltesZiel == "LAGER")
                                {
                                    //Einlagern der Ware in die vorhandene Filiale im Hafen
                                    foreach (Filiale f in aktuellerHafen.vorhandeneFilialen)
                                    {
                                        if (f.BESITZER == Globals.AktuellerSpieler)
                                        {
                                            f.einlagernWare(new Ware(gewählteHandelsWare.BEZEICHNUNG, 0, gewählteMenge, 0, gewählteHandelsWare.LADEMITTEL));
                                            break;
                                        }
                                    }

                                }
                                else
                                {
                                    //Einlagern der Ware in das angedockte Schiff
                                    foreach (Schiff s in aktuellerHafen.angedockteSchiffe)
                                    {
                                        if (s.NAME == gewähltesSpielerSchiff.NAME)
                                        {
                                            s.einlagernLadung(new Ware(gewählteHandelsWare.BEZEICHNUNG, 0, gewählteMenge, 0, gewählteHandelsWare.LADEMITTEL));
                                            break;
                                        }
                                    }

                                }

                                // Abziehen des Budgets der Geldquelle
                                if (gewählteGeldQuelle == "LAGER")
                                {

                                    foreach (Filiale f in aktuellerHafen.vorhandeneFilialen)
                                    {
                                        if (f == TempGeldQuellenFiliale)
                                        {
                                            f.verringereBudget(gewählterPreis);
                                            break;
                                        }
                                    }
                                }
                                else
                                {
                                    foreach (Schiff s in aktuellerHafen.angedockteSchiffe)
                                    {
                                        if (s == TempGeldQuellenSchiff)
                                        {
                                            s.vermindernBudget(gewählterPreis);
                                            break;
                                        }
                                    }

                                }

                                // Abziehen der Ware vom Hafenlager
                                foreach (Ware item in aktuellerHafen.EXPORTWARE)
                                {
                                    if (item.BEZEICHNUNG == gewählteHandelsWare.BEZEICHNUNG)
                                    {
                                        // reduzieren der Ware vom Bestand
                                        item.MENGE -= gewählteMenge;

                                    }

                                }
                                // Wenn Ware durch reduzierung leer wurde -> Löschen aus dem Bestand
                                for (int index = 0; index < aktuellerHafen.EXPORTWARE.Count(); index++)
                                {
                                    if (aktuellerHafen.EXPORTWARE[index].MENGE == 0)
                                    {
                                        aktuellerHafen.EXPORTWARE.RemoveAt(index);
                                        // wenn ein Eintrag gefunden -> reset der Schleife da sich Count geändert hat (Notwendig wenn mehrere Waren je Prozess auf 0 gefallen sind)
                                        index = 0;
                                    }
                                }

                                // Zurück zu Root
                                letzteÜbergebeneListe.Clear();
                                gewählteHandelsWare = null;
                                gewählteSpielerFiliale = null;
                                gewähltesSpielerSchiff = null;
                                gewähltesZiel = "";

                                // Wenn abbruch erfolgen soll -> zurück zu Root (Wenn zurück zu Root haben sich evtl Tafeltexte verändert(weil leergekauft)-> neu zeichnen

                                List<Ware> TempWarenListeExport = new List<Ware>();
                                List<Ware> TempWarenListeImport = new List<Ware>();

                                //Füllen aller vorhanden Waren in eine Liste für die TafelTexte(Export zuerst)
                                foreach (Ware item in aktuellerHafen.EXPORTWARE)
                                {
                                    TempWarenListeExport.Add(item);
                                }

                                foreach (Ware item in aktuellerHafen.IMPORTWARE)
                                {
                                    TempWarenListeImport.Add(item);
                                }
                                TextLieferant.erzeugeTafelText(TempWarenListeExport, TempWarenListeImport);

                                TextLieferant.wechsleAuswahlText("1", new Queue<string>(), false);
                            }
                            break;
                        case 3:
                            // Auswahl 3: Auswahl Bezahlungsquelle                            

                            // Untersuchen, ob es noch andere Bezahlungsquellen gibt(angedockte Schiffe oder einer Filiale)
                            if (möglicheGeldQuellen.Count() > 1)
                            {
                                if (auswahlMouseButton == "MausRechts")
                                {
                                    geldQuellenIndex--;
                                }
                                else
                                {
                                    geldQuellenIndex++;
                                }

                                if (geldQuellenIndex == möglicheGeldQuellen.Count())
                                {
                                    geldQuellenIndex = 0;
                                }

                                if (geldQuellenIndex < 0)
                                {
                                    geldQuellenIndex = möglicheGeldQuellen.Count() - 1;
                                }

                                gewählteGeldQuelle = möglicheGeldQuellen[geldQuellenIndex];
                                TempGeldQuellenFiliale = null;
                                TempGeldQuellenSchiff = null;

                                if (möglicheGeldQuellen[geldQuellenIndex] == "LAGER")
                                {
                                    foreach (Filiale f in aktuellerHafen.vorhandeneFilialen)
                                    {
                                        if (f.BESITZER == Globals.AktuellerSpieler)
                                        {
                                            TempGeldQuellenFiliale = f;
                                            break;
                                        }


                                    }
                                }
                                else
                                {
                                    foreach (Schiff s in aktuellerHafen.angedockteSchiffe)
                                    {
                                        if (s.NAME == möglicheGeldQuellen[geldQuellenIndex])
                                        {
                                            TempGeldQuellenSchiff = s;
                                            break;
                                        }


                                    }
                                }

                                // Zuerst überprüfen ob neue Geldquelle genug Geld für mindestens 1 Lademittel hat 
                                int TempMaxMenge = 0;
                                if (möglicheGeldQuellen[geldQuellenIndex] == "LAGER")
                                {
                                    TempMaxMenge = TempGeldQuellenFiliale.BUDGET / (gewählteHandelsWare.LAGERPREIS);

                                }
                                else
                                {
                                    TempMaxMenge = TempGeldQuellenSchiff.SCHIFFSBUDGET / (gewählteHandelsWare.LAGERPREIS);
                                }

                                // neue gewählte Menge ist immer die Maximalmenge der neuen Geldquelle
                                //Überprüfen ob Hafenlager großgenug ist für Budget der neuen Quelle
                                foreach (Ware item in aktuellerHafen.EXPORTWARE)
                                {
                                    if (item == gewählteHandelsWare)
                                    {
                                        if (item.MENGE >= TempMaxMenge)
                                        {
                                            gewählteMenge = TempMaxMenge;
                                        }
                                        else
                                        {
                                            gewählteMenge = item.MENGE;
                                        }
                                        break;
                                    }
                                }

                                gewählterPreis = gewählteMenge * gewählteHandelsWare.LAGERPREIS;

                                // Da Geldquelle geändert wurde -> neu Zeichnen und berechnen der des Auswahltextes
                                // Aufbau der Auswahlliste, je nach dem was vorhanden ist (Keine Absicherung, da mindestens 1 Eintrag da sein muss sonst wäre man nicht in diesem Menü)
                                // Wenn aber nur 1 Eintrag vorhanden ist, direkt diesen auswählen (Shortcut Funktion)                               

                                // 1. Param ist errechnete max Menge im Bezug auf vorhandenem Budget sein  
                                TempQueue.Enqueue(gewählteMenge.ToString());
                                letzteÜbergebeneListe.Add(gewählteMenge.ToString());

                                // 2. Param ist Lademittel der Ware
                                if (gewählteMenge > 1)
                                {
                                    TempQueue.Enqueue(gewählteHandelsWare.LADEMITTEL + "N");
                                }
                                else
                                {
                                    TempQueue.Enqueue(gewählteHandelsWare.LADEMITTEL);
                                }
                                letzteÜbergebeneListe.Add(gewählteHandelsWare.LADEMITTEL);

                                // 3. Param ist der Name der Ware
                                TempQueue.Enqueue(gewählteHandelsWare.BEZEICHNUNG);
                                letzteÜbergebeneListe.Add(gewählteHandelsWare.BEZEICHNUNG);

                                // 4. Param ist der Zielort
                                if (gewähltesZiel == "LAGER")
                                {
                                    TempQueue.Enqueue("INS " + gewähltesZiel);
                                }
                                else
                                {
                                    TempQueue.Enqueue("AUF DIE " + gewähltesZiel);
                                }

                                // 5. Param ist der GeldQuelle -> Übernahme der geänderten Geldquelle
                                if (möglicheGeldQuellen[geldQuellenIndex] == "LAGER")
                                {

                                    TempQueue.Enqueue("IM " + möglicheGeldQuellen[geldQuellenIndex] + " VERFÜGE ICH");
                                    letzteÜbergebeneListe.Add(möglicheGeldQuellen[geldQuellenIndex]);

                                }
                                else
                                {

                                    TempQueue.Enqueue("DIE " + möglicheGeldQuellen[geldQuellenIndex] + " VERFÜGT");
                                    letzteÜbergebeneListe.Add(möglicheGeldQuellen[geldQuellenIndex]);
                                }

                                // 6. Param Budget der Geldquelle in EURO
                                if (möglicheGeldQuellen[geldQuellenIndex] == "LAGER")
                                {
                                    TempQueue.Enqueue((TempGeldQuellenFiliale.BUDGET / 100).ToString());
                                    letzteÜbergebeneListe.Add((TempGeldQuellenFiliale.BUDGET / 100).ToString());
                                }
                                else
                                {
                                    TempQueue.Enqueue((TempGeldQuellenSchiff.SCHIFFSBUDGET / 100).ToString());
                                    letzteÜbergebeneListe.Add((TempGeldQuellenSchiff.SCHIFFSBUDGET / 100).ToString());
                                }

                                // 7. Param Budget der Geldquelle in CENT
                                if (möglicheGeldQuellen[geldQuellenIndex] == "LAGER")
                                {
                                    TempQueue.Enqueue((TempGeldQuellenFiliale.BUDGET % 100).ToString());
                                    letzteÜbergebeneListe.Add((TempGeldQuellenFiliale.BUDGET % 100).ToString());
                                }
                                else
                                {
                                    TempQueue.Enqueue((TempGeldQuellenSchiff.SCHIFFSBUDGET % 100).ToString());
                                    letzteÜbergebeneListe.Add((TempGeldQuellenSchiff.SCHIFFSBUDGET % 100).ToString());
                                }

                                // Veranlassen eines Sprachtextes mit Erläuterung zum neuen Preis
                                // & Füllen der Sprachparameter                                   

                                // Wenn neue gewählte Menge 0 ist, wird ein spezieller Text angezeigt
                                if (gewählteMenge != 0)
                                {
                                    TempSprachText.Enqueue("Kosten");
                                    TempSprachParams.Enqueue((gewählterPreis / 100).ToString());
                                    TempSprachParams.Enqueue((gewählterPreis % 100).ToString());
                                }
                                else
                                {
                                    //Minimalmenge erreicht -> Ausgabe Sprachtext für zu keine Berechnung
                                    TempSprachText.Enqueue("KeineKosten");
                                }

                                TextLieferant.erzeugeSprachText(TempSprachText, TempSprachParams, Globals.Remake.HalfWidth, 100);

                                TextLieferant.wechsleAuswahlText("1.1.1", TempQueue, false, false);
                            }
                            // wenn nicht mehr als 1 Geldquellen vorhanden sind soll einfach nichts passieren                            

                            break;
                        case 4:
                            // Auswahl 4: Abbruch Handel
                            letzteÜbergebeneListe.Clear();
                            gewählteHandelsWare = null;
                            gewählteSpielerFiliale = null;
                            gewähltesSpielerSchiff = null;
                            gewähltesZiel = "";

                            // Wenn abbruch erfolgen soll -> zurück zu Root
                            TextLieferant.wechsleAuswahlText("1", new Queue<string>(), false);
                            break;
                    }
                    break;
                #endregion


                case "1.2A":
                    //Auswahlmöglichkeiten Verkauf (Hier wird der Quelllagerort gewählt)
                    #region VerkaufsLogik - Auswahl Quelle

                    switch (tempAuswahl)
                    {
                        case 0:
                            //Noch keine Auswahl getroffen
                            break;
                        case 999:
                            // 999 bei variablen Listen ist immer Abbruch

                            // Wenn abbruch erfolgen soll -> zurück zu Root
                            TextLieferant.wechsleAuswahlText("1", new Queue<string>(), false);
                            break;

                        default:
                            // Bei allen anderen Werten 
                            // Übernahme der letzen Auswahl (Überprüfen ob letzte Auswahl eine Filiale oder Schiff war)
                            gewähltesSpielerSchiff = null;
                            gewählteSpielerFiliale = null;
                            TempGeldQuellenFiliale = null;
                            TempGeldQuellenSchiff = null;

                            // Übernahme des gewählten Ortes als default Warenquelle        
                            if (letzteÜbergebeneListe[tempAuswahl - 1] == "LAGER")
                            {
                                gewählteSpielerFiliale = aktuellerHafen.überprüfeAktuelleFilialeVorhanden(Globals.AktuellerSpieler);
                                gewähltesZiel = "LAGER";

                                foreach (Filiale f in aktuellerHafen.vorhandeneFilialen)
                                {
                                    if (f.BESITZER == Globals.AktuellerSpieler)
                                    {
                                        TempGeldQuellenFiliale = f;
                                        geldQuellenIndex = tempAuswahl - 1;
                                        break;
                                    }

                                }

                            }
                            else
                            {
                                // Wenn nicht die Filiale gewählt wurde sondern ein bestimmtes Schiff -> Finden des Schiffs
                                List<Schiff> TempListe = aktuellerHafen.überprüfeEigeneSchiffeVorhanden(Globals.AktuellerSpieler);

                                // Wenn mehrere eigene Schiffe im Hafen sind -> Suchen des gewählten Schiffes
                                foreach (Schiff s in TempListe)
                                {
                                    if (s.NAME == letzteÜbergebeneListe[tempAuswahl - 1])
                                    {
                                        gewähltesSpielerSchiff = s;
                                        gewähltesZiel = s.NAME;
                                        TempGeldQuellenSchiff = s;
                                        geldQuellenIndex = tempAuswahl - 1;
                                    }

                                }
                            }

                            TempQueue = new Queue<string>();
                            // Alte Übergabeliste wird nicht mehr benötigt und verworfen
                            letzteÜbergebeneListe.Clear();

                            // Wenn Warenquelle vorhanden ist muss aus den vorhandenen Waren gewählt werden
                            if (gewählteSpielerFiliale != null)
                            {
                                foreach (Ware item in gewählteSpielerFiliale.LAGER)
                                {
                                    TempQueue.Enqueue(item.BEZEICHNUNG);
                                    letzteÜbergebeneListe.Add(item.BEZEICHNUNG);
                                }

                            }
                            else
                            {
                                foreach (Ware item in gewähltesSpielerSchiff.LADUNG)
                                {
                                    TempQueue.Enqueue(item.BEZEICHNUNG);
                                    letzteÜbergebeneListe.Add(item.BEZEICHNUNG);
                                }
                            }

                            // Veranlassen eines Initialsprachtextes mit Erläuterung zum Preis -> Preisbildung wird zuerst erläutert
                            TempSprachText = new Queue<string>();
                            TempSprachParams = new Queue<string>();

                            if (TempQueue.Count() == 1)
                            {
                                TextLieferant.setAuswahl(1);
                            }

                            //TextLieferant.erzeugeSprachText(TempSprachText, TempSprachParams, Globals.Remake.HalfWidth, 100);

                            TextLieferant.wechsleAuswahlText("1.2B", TempQueue, true);
                            break;

                    }
                    #endregion
                    break;

                case "1.2B":
                    //Auswahlmöglichkeiten Verkauf (Hier wird Ware des Quelllagerorts gewählt)                   
                    #region VerkaufsLogik - Auswahl Quelle

                    switch (tempAuswahl)
                    {
                        case 0:
                            //Noch keine Auswahl getroffen
                            break;
                        case 999:
                            // 999 bei variablen Listen ist immer Abbruch

                            //Wenn abbruch erfolgen soll -> zurück zu Vorherigen Menü
                            //Vorheriges Menü neu Aufbauen (Auswahl Warenbezugsquelle)
                            //Wenn Filiale vorhanden -> Lager ist mögliche Quelle     
                            letzteÜbergebeneListe.Clear();
                            TempQueue = new Queue<string>();
                            if (aktuellerHafen.filialeVorhanden)
                            {
                                foreach (Filiale f in aktuellerHafen.vorhandeneFilialen)
                                {
                                    if (f.BESITZER == Globals.AktuellerSpieler && f.LAGER.IsNotEmpty())
                                    {
                                        TempQueue.Enqueue("Verkauf aus Lager");
                                        letzteÜbergebeneListe.Add("LAGER");
                                    }
                                }

                            }

                            //Wenn Schiffe vorhanden -> Schiff ist mögliche Quelle
                            foreach (Schiff Boot in aktuellerHafen.angedockteSchiffe)
                            {
                                if (Boot.COMMANDEUR == Globals.AktuellerSpieler && Boot.LADUNG.IsNotEmpty())
                                {
                                    TempQueue.Enqueue(Boot.NAME);
                                    letzteÜbergebeneListe.Add(Boot.NAME);
                                }
                            }

                            TempSprachText = new Queue<string>();
                            TempSprachParams = new Queue<string>();

                            TempSprachText.Enqueue("HANDEL_VERKAUFSQUELLE");
                            TextLieferant.erzeugeSprachText(TempSprachText, TempSprachParams, Globals.Remake.HalfWidth, 100);

                            TextLieferant.wechsleAuswahlText("1.2A", TempQueue, true);
                            break;

                        default:
                            // Bei allen anderen Werten 
                            // Übernahme der letzen Auswahl (Verkaufte Ware)   + Voreinstellen der MaximalMenge

                            if (gewähltesZiel == "LAGER")
                            {
                                foreach (Filiale f in aktuellerHafen.vorhandeneFilialen)
                                {
                                    if (f.BESITZER == Globals.AktuellerSpieler)
                                    {
                                        foreach (Ware item in f.LAGER)
                                        {
                                            if (item.BEZEICHNUNG == letzteÜbergebeneListe[tempAuswahl - 1])
                                            {
                                                //Kopieren der Ware für später bearbeitung
                                                gewählteHandelsWare = new Ware(item);
                                                // Menge ist immer die im Lager maximal vorhandene Menge
                                                gewählteMenge = gewählteHandelsWare.MENGE;
                                                //Wenn die Ware gefunden wurde ist die Bearbeitung abgeschlossen
                                                break;
                                            }
                                        }
                                        //Wenn die Filiale gefunden wurde ist Bearbeitung abgeschlossen
                                        break;
                                    }
                                }

                            }
                            else
                            {
                                foreach (Schiff s in aktuellerHafen.angedockteSchiffe)
                                {
                                    if (s.NAME == gewähltesZiel)
                                    {
                                        foreach (Ware item in s.LADUNG)
                                        {
                                            if (item.BEZEICHNUNG == letzteÜbergebeneListe[tempAuswahl - 1])
                                            {
                                                //Kopieren der Ware für spätere Bearbeitung
                                                gewählteHandelsWare = new Ware(item);
                                                //Menge ist immer die in der Ladung vorhandenen maximal Menge
                                                gewählteMenge = gewählteHandelsWare.MENGE;
                                                //Wenn Ware gefunden wurde ist Bearbeitung abgeschlossen
                                                break;
                                            }
                                        }
                                        //Wenn Zielschiff gefunden wurde ist Bearbeitung abgeschlossen
                                        break;
                                    }

                                }
                            }

                            // Wenn Ware übernommen ist muss Preis errechnet werden -> Als Referenz wird die ImportwarenListe (Und der Preis dazu genommen)
                            // Sollte die Importwarenliste des Hafens diese Ware nicht benötigen wird die Hälfte des Durchschnittspreises genommen (ist vordefiniert)                          
                            // Sonderregel: Wenn die Menge der erwünschten Ware unter eine bestimmte Menge fällt wird nur noch ein Teil des Importpreises gezahlt

                            //PreisReduziert status:
                            //0 = keine Reduktion -> Vollpreis
                            //1 = etwas Reduktion -> Teilpreis
                            //2 = nicht erwünscht -> mindestpreis
                            int PreisReduziert = 2;
                            gewählterPreis = 0;
                            foreach (Ware item in aktuellerHafen.IMPORTWARE)
                            {
                                if (item.BEZEICHNUNG == gewählteHandelsWare.BEZEICHNUNG)
                                {
                                    // Wenn die Ware pauschal unter 25 benötigt wird, wird nur noch 3/4 des Import preises gezahlt + anderer Sprachtext als sonst
                                    if (item.MENGE <= 25)
                                    {
                                        PreisReduziert = 1;
                                        gewählterPreis = gewählteMenge * (item.LAGERPREIS * 75 / 100);
                                    }
                                    else
                                    {
                                        PreisReduziert = 0;
                                        gewählterPreis = gewählteMenge * item.LAGERPREIS;
                                    }
                                }
                            }

                            // Wenn Ware nicht importiert wird, wird der Preis aus der globalen reduzierten Preisliste genommen
                            if (PreisReduziert == 2)
                            {
                                gewählterPreis = Globals.PreisListe_UnerwünschteWare[gewählteHandelsWare.BEZEICHNUNG];
                            }

                            //Aufbau der Parameter für die Auswahltexte
                            // 1. Param ist errechnete max Menge im Bezug auf vorhandenem Budget sein  
                            TempQueue.Enqueue(gewählteMenge.ToString());
                            letzteÜbergebeneListe.Add(gewählteMenge.ToString());

                            // 2. Param ist Lademittel der Ware
                            if (gewählteMenge > 1)
                            {
                                TempQueue.Enqueue(gewählteHandelsWare.LADEMITTEL + "N");
                            }
                            else
                            {
                                TempQueue.Enqueue(gewählteHandelsWare.LADEMITTEL);
                            }
                            letzteÜbergebeneListe.Add(gewählteHandelsWare.LADEMITTEL);

                            // 3. Param ist der Name der Ware
                            TempQueue.Enqueue(gewählteHandelsWare.BEZEICHNUNG);
                            letzteÜbergebeneListe.Add(gewählteHandelsWare.BEZEICHNUNG);

                            // 4. Param ist der GeldQuelle
                            if (gewähltesZiel == "LAGER")
                            {
                                TempQueue.Enqueue("IM " + gewähltesZiel + " verfüge ich ");
                            }
                            else
                            {
                                TempQueue.Enqueue("AUF DER " + gewähltesZiel + " verfüge ich ");
                            }
                            letzteÜbergebeneListe.Add(gewähltesZiel);

                            // 5. Param Budget des Ziels in EURO                            
                            if (TempGeldQuellenFiliale != null)
                            {
                                TempQueue.Enqueue((TempGeldQuellenFiliale.BUDGET / 100).ToString());
                                letzteÜbergebeneListe.Add((TempGeldQuellenFiliale.BUDGET / 100).ToString());
                            }
                            else
                            {
                                TempQueue.Enqueue((TempGeldQuellenSchiff.SCHIFFSBUDGET / 100).ToString());
                                letzteÜbergebeneListe.Add((TempGeldQuellenSchiff.SCHIFFSBUDGET / 100).ToString());
                            }

                            // 6. Param Budget des Ziels in CENT
                            if (TempGeldQuellenFiliale != null)
                            {
                                TempQueue.Enqueue((TempGeldQuellenFiliale.BUDGET % 100).ToString());
                                letzteÜbergebeneListe.Add((TempGeldQuellenFiliale.BUDGET % 100).ToString());
                            }
                            else
                            {
                                TempQueue.Enqueue((TempGeldQuellenSchiff.SCHIFFSBUDGET % 100).ToString());
                                letzteÜbergebeneListe.Add((TempGeldQuellenSchiff.SCHIFFSBUDGET % 100).ToString());
                            }

                            // Je nachdem wie viel reduziert wurde, wird anderer Sprachtext erstellt
                            TempSprachText = new Queue<string>();
                            TempSprachParams = new Queue<string>();
                            switch (PreisReduziert)
                            {
                                case 0:
                                    break;
                                case 1:
                                    break;
                                case 2:
                                    break;

                            }

                            //TextLieferant.erzeugeSprachText(TempSprachText, TempSprachParams, Globals.Remake.HalfWidth, 100);

                            TextLieferant.wechsleAuswahlText("1.2.1", TempQueue, false);
                            break;
                    }
                    #endregion
                    break;
                case "1.2.1":

                    #region Verkaufsbestätigung
                    //TODO: Preisspannen Logik untersuchen und implementieren beim Verkauf
                    //Biserhige Erkentnis: Wenn Ware hohen Import hat gibts Sonderpreise, wenn Ware keinen Import hat gibts Standartisierten Minimalstpreis
                    // Eventuell gilt: 3 Preis zonen (Hoher Import, regulärer Import, Kein Import)
                    // Herauszufinden gilt auch die Geldbeträge im Hohen import bereich -> Sind nicht standardisiert (Z.B Früchte in Triest kosten 1$ mehr, in Sydney aber 1.50$ | evtl Prozentual?)
                    switch (tempAuswahl)
                    {
                        case 0:
                            //Noch keine Auswahl getroffen
                            break;
                        case 1:
                            //Auswahl 1 = Auswahl Menge

                            // Indikator resetten
                            WareLeer = false;

                            // Linksklick Erhöhung der Menge, Rechtsklick Verminderung der Menge
                            if (auswahlMouseButton == "MausLinks")
                            {
                                // Logik fürs erhöhen der Menge -> Erhöhen ist nur erlaubt wenn nicht maximum der Ware erreicht ist
                                if (gewählteSpielerFiliale != null)
                                {
                                    foreach (Ware item in gewählteSpielerFiliale.LAGER)
                                    {
                                        if (item.BEZEICHNUNG == gewählteHandelsWare.BEZEICHNUNG)
                                        {
                                            if (gewählteMenge < item.MENGE)
                                            {
                                                gewählteMenge++;
                                            }
                                            else
                                            {
                                                // Wenn nicht erhöht werden konnte hat man nicht mehr im Lager -> Erzeugt besonderen Hinweis Sprachtext
                                                WareLeer = true;
                                            }
                                            break;
                                        }

                                    }

                                }
                                else
                                {
                                    foreach (Ware item in gewähltesSpielerSchiff.LADUNG)
                                    {
                                        if (item.BEZEICHNUNG == gewählteHandelsWare.BEZEICHNUNG)
                                        {
                                            if (gewählteMenge < item.MENGE)
                                            {
                                                gewählteMenge++;
                                            }
                                            else
                                            {
                                                // Wenn nicht erhöht werden konnte hat man nicht mehr in Ladung -> Erzeugt besonderen Hinweis Sprachtext
                                                WareLeer = true;
                                            }
                                            break;
                                        }

                                    }
                                }

                            }
                            else
                            {
                                if (auswahlMouseButton == "MausRechts")
                                {
                                    // Logik fürs vermindern der Menge -> Vermindern ist nur erlaubt wenn nicht 0 erreicht ist
                                    if (gewählteMenge > 0)
                                    {
                                        gewählteMenge--;
                                    }

                                }

                            }

                            // Neu berechnen des Preises je nach neuer Menge
                            int PreisReduziert = 2;
                            gewählterPreis = 0;
                            foreach (Ware item in aktuellerHafen.IMPORTWARE)
                            {
                                if (item.BEZEICHNUNG == gewählteHandelsWare.BEZEICHNUNG)
                                {
                                    // Wenn die Ware pauschal unter 25 benötigt wird, wird nur noch 3/4 des Import preises gezahlt + anderer Sprachtext als sonst
                                    if (item.MENGE <= 25)
                                    {
                                        PreisReduziert = 1;
                                        gewählterPreis = gewählteMenge * (item.LAGERPREIS * 75 / 100);
                                    }
                                    else
                                    {
                                        PreisReduziert = 0;
                                        gewählterPreis = gewählteMenge * item.LAGERPREIS;
                                    }
                                }
                            }

                            // Wenn Ware nicht importiert wird, wird der Preis aus der globalen reduzierten Preisliste genommen
                            if (PreisReduziert == 2)
                            {
                                gewählterPreis = Globals.PreisListe_UnerwünschteWare[gewählteHandelsWare.BEZEICHNUNG] * gewählteMenge;
                            }

                            //Aufbau der Parameter für die Auswahltexte
                            // 1. Param ist errechnete max Menge im Bezug auf vorhandenem Budget sein  
                            TempQueue.Enqueue(gewählteMenge.ToString());
                            letzteÜbergebeneListe.Add(gewählteMenge.ToString());

                            // 2. Param ist Lademittel der Ware
                            if (gewählteMenge > 1)
                            {
                                TempQueue.Enqueue(gewählteHandelsWare.LADEMITTEL + "N");
                            }
                            else
                            {
                                TempQueue.Enqueue(gewählteHandelsWare.LADEMITTEL);
                            }
                            letzteÜbergebeneListe.Add(gewählteHandelsWare.LADEMITTEL);

                            // 3. Param ist der Name der Ware
                            TempQueue.Enqueue(gewählteHandelsWare.BEZEICHNUNG);
                            letzteÜbergebeneListe.Add(gewählteHandelsWare.BEZEICHNUNG);

                            // 4. Param ist der GeldQuelle
                            if (gewählteGeldQuelle == "LAGER")
                            {
                                TempQueue.Enqueue("IM " + gewählteGeldQuelle);
                            }
                            else
                            {
                                TempQueue.Enqueue("AUF DER " + gewählteGeldQuelle);
                            }
                            letzteÜbergebeneListe.Add(gewählteGeldQuelle);

                            // 5. Param Budget des Ziels in EURO                            
                            if (TempGeldQuellenFiliale != null)
                            {
                                TempQueue.Enqueue((TempGeldQuellenFiliale.BUDGET / 100).ToString());
                                letzteÜbergebeneListe.Add((TempGeldQuellenFiliale.BUDGET / 100).ToString());
                            }
                            else
                            {
                                TempQueue.Enqueue((TempGeldQuellenSchiff.SCHIFFSBUDGET / 100).ToString());
                                letzteÜbergebeneListe.Add((TempGeldQuellenSchiff.SCHIFFSBUDGET / 100).ToString());
                            }

                            // 6. Param Budget des Ziels in CENT
                            if (TempGeldQuellenFiliale != null)
                            {
                                TempQueue.Enqueue((TempGeldQuellenFiliale.BUDGET % 100).ToString());
                                letzteÜbergebeneListe.Add((TempGeldQuellenFiliale.BUDGET % 100).ToString());
                            }
                            else
                            {
                                TempQueue.Enqueue((TempGeldQuellenSchiff.SCHIFFSBUDGET % 100).ToString());
                                letzteÜbergebeneListe.Add((TempGeldQuellenSchiff.SCHIFFSBUDGET % 100).ToString());
                            }

                            // Je nachdem wie viel reduziert wurde, wird anderer Sprachtext erstellt
                            TempSprachText = new Queue<string>();
                            TempSprachParams = new Queue<string>();
                            switch (PreisReduziert)
                            {
                                case 0:
                                    break;
                                case 1:
                                    break;
                                case 2:
                                    break;

                            }

                            //TextLieferant.erzeugeSprachText(TempSprachText, TempSprachParams, Globals.Remake.HalfWidth, 100);

                            TextLieferant.wechsleAuswahlText("1.2.1", TempQueue, false);

                            break;
                        case 2:
                            //Auswahl 2 = Bestätigen Verkauf
                            // Übergeben der Verkauften Ware an den Hafen (Abziehen vom Import)
                            // Nur Logik erlauben wenn links geklickt wurde nicht rechts

                            // jedes Spieler Schiff und Filiale sollten gewählt werden können -> überarbeiten der Geldziel logik im Verkauf
                            if (auswahlMouseButton == "MausLinks")
                            {
                                // Zuerst vermindern des Bestandes im Ursprungslager
                                if (gewähltesZiel == "LAGER")
                                {
                                    //Auslagern der Ware von der vorhandene Filiale im Hafen
                                    foreach (Filiale f in aktuellerHafen.vorhandeneFilialen)
                                    {
                                        if (f.BESITZER == Globals.AktuellerSpieler)
                                        {
                                            f.AuslagernnWare(gewählteHandelsWare.BEZEICHNUNG, gewählteMenge);
                                            break;
                                        }
                                    }

                                }
                                else
                                {
                                    //Auslagern der Ware in das angedockte Schiff
                                    foreach (Schiff s in aktuellerHafen.angedockteSchiffe)
                                    {
                                        if (s.NAME == gewähltesSpielerSchiff.NAME)
                                        {
                                            s.löscheLadung(gewählteHandelsWare.BEZEICHNUNG, gewählteMenge);
                                            break;
                                        }
                                    }

                                }

                                // Erhöhen des Geldes im Zielbudget
                                if (gewählteGeldQuelle == "LAGER")
                                {

                                    foreach (Filiale f in aktuellerHafen.vorhandeneFilialen)
                                    {
                                        if (f == TempGeldQuellenFiliale)
                                        {
                                            f.erhöheBudget(gewählterPreis);
                                            break;
                                        }
                                    }
                                }
                                else
                                {
                                    foreach (Schiff s in aktuellerHafen.angedockteSchiffe)
                                    {
                                        if (s == TempGeldQuellenSchiff)
                                        {
                                            s.erhöhenBudget(gewählterPreis);
                                            break;
                                        }
                                    }

                                }

                                // Abziehen der Ware von der Importliste des Hafenlagers
                                // Besonderheit: Wenn der Hafen hier mehr ankauft als es eigentlich Importieren will wird trotzdem zum genannten Preis verkauft
                                // außer die gewünschte Importmenge ist schon von beginn der Verhandlungen unter 25 dann wird nur der reduzierte Preis angeboten
                                // und trotz reduziertem Preis nimmt Hafen die Ware immer an!
                                foreach (Ware item in aktuellerHafen.IMPORTWARE)
                                {
                                    if (item.BEZEICHNUNG == gewählteHandelsWare.BEZEICHNUNG)
                                    {
                                        // reduzieren der Ware vom Bestand
                                        item.MENGE -= gewählteMenge;
                                        if (item.MENGE <= 0)
                                        {
                                            item.MENGE = 0;
                                        }
                                        break;


                                    }

                                }
                                // Wenn Ware durch reduzierung leer wurde -> Löschen aus dem Bestand
                                for (int index = 0; index < aktuellerHafen.IMPORTWARE.Count(); index++)
                                {
                                    if (aktuellerHafen.IMPORTWARE[index].MENGE == 0)
                                    {
                                        aktuellerHafen.IMPORTWARE.RemoveAt(index);
                                        // wenn ein Eintrag gefunden -> reset der Schleife da sich Count geändert hat (Notwendig wenn mehrere Waren je Prozess auf 0 gefallen sind)
                                        index = 0;
                                    }
                                }

                                // Zurück zu Root
                                letzteÜbergebeneListe.Clear();
                                gewählteHandelsWare = null;
                                gewählteSpielerFiliale = null;
                                gewähltesSpielerSchiff = null;
                                gewähltesZiel = "";

                                // Wenn zurück zu Root haben sich evtl Tafeltexte verändert(weil leergekauft)-> neu zeichnen

                                List<Ware> TempWarenListeExport = new List<Ware>();
                                List<Ware> TempWarenListeImport = new List<Ware>();

                                //Füllen aller vorhanden Waren in eine Liste für die TafelTexte(Export zuerst)
                                foreach (Ware item in aktuellerHafen.EXPORTWARE)
                                {
                                    TempWarenListeExport.Add(item);
                                }

                                foreach (Ware item in aktuellerHafen.IMPORTWARE)
                                {
                                    TempWarenListeImport.Add(item);
                                }
                                TextLieferant.erzeugeTafelText(TempWarenListeExport, TempWarenListeImport);

                                TextLieferant.wechsleAuswahlText("1", new Queue<string>(), false);
                            }
                            break;
                        case 3:
                            // Auswahl 3 = Wechsel des Geldziels

                            // Untersuchen, ob es noch andere Bezahlungsquellen gibt(angedockte Schiffe oder einer Filiale)
                            if (möglicheGeldQuellen.Count() > 1)
                            {
                                if (auswahlMouseButton == "MausRechts")
                                {
                                    geldQuellenIndex--;
                                }
                                else
                                {
                                    geldQuellenIndex++;
                                }

                                if (geldQuellenIndex == möglicheGeldQuellen.Count())
                                {
                                    geldQuellenIndex = 0;
                                }

                                if (geldQuellenIndex < 0)
                                {
                                    geldQuellenIndex = möglicheGeldQuellen.Count() - 1;
                                }

                                gewählteGeldQuelle = möglicheGeldQuellen[geldQuellenIndex];
                                TempGeldQuellenFiliale = null;
                                TempGeldQuellenSchiff = null;

                                if (möglicheGeldQuellen[geldQuellenIndex] == "LAGER")
                                {
                                    foreach (Filiale f in aktuellerHafen.vorhandeneFilialen)
                                    {
                                        if (f.BESITZER == Globals.AktuellerSpieler)
                                        {
                                            TempGeldQuellenFiliale = f;
                                            break;
                                        }
                                    }
                                }
                                else
                                {
                                    foreach (Schiff s in aktuellerHafen.angedockteSchiffe)
                                    {
                                        if (s.NAME == möglicheGeldQuellen[geldQuellenIndex])
                                        {
                                            TempGeldQuellenSchiff = s;
                                            break;
                                        }
                                    }
                                }


                                // Da Geldquelle geändert wurde -> neu Zeichnen und berechnen der des Auswahltextes
                                // Aufbau der Auswahlliste, je nach dem was vorhanden ist (Keine Absicherung, da mindestens 1 Eintrag da sein muss sonst wäre man nicht in diesem Menü)
                                // Wenn aber nur 1 Eintrag vorhanden ist, direkt diesen auswählen (Shortcut Funktion)                               

                                //Aufbau der Parameter für die Auswahltexte
                                // 1. Param ist errechnete max Menge im Bezug auf vorhandenem Budget sein  
                                TempQueue.Enqueue(gewählteMenge.ToString());
                                letzteÜbergebeneListe.Add(gewählteMenge.ToString());

                                // 2. Param ist Lademittel der Ware
                                if (gewählteMenge > 1)
                                {
                                    TempQueue.Enqueue(gewählteHandelsWare.LADEMITTEL + "N");
                                }
                                else
                                {
                                    TempQueue.Enqueue(gewählteHandelsWare.LADEMITTEL);
                                }

                                letzteÜbergebeneListe.Add(gewählteHandelsWare.LADEMITTEL);

                                // 3. Param ist der Name der Ware
                                TempQueue.Enqueue(gewählteHandelsWare.BEZEICHNUNG);
                                letzteÜbergebeneListe.Add(gewählteHandelsWare.BEZEICHNUNG);

                                // 4. Param ist der Geldziel
                                if (TempGeldQuellenFiliale != null)
                                {
                                    TempQueue.Enqueue("IM LAGER");
                                }
                                else
                                {
                                    TempQueue.Enqueue("AUF DER " + möglicheGeldQuellen[geldQuellenIndex]);
                                }
                                letzteÜbergebeneListe.Add(möglicheGeldQuellen[geldQuellenIndex]);

                                // 5. Param Budget des Ziels in EURO                            
                                if (TempGeldQuellenFiliale != null)
                                {
                                    TempQueue.Enqueue((TempGeldQuellenFiliale.BUDGET / 100).ToString());
                                    letzteÜbergebeneListe.Add((TempGeldQuellenFiliale.BUDGET / 100).ToString());
                                }
                                else
                                {
                                    TempQueue.Enqueue((TempGeldQuellenSchiff.SCHIFFSBUDGET / 100).ToString());
                                    letzteÜbergebeneListe.Add((TempGeldQuellenSchiff.SCHIFFSBUDGET / 100).ToString());
                                }

                                // 6. Param Budget des Ziels in CENT
                                if (TempGeldQuellenFiliale != null)
                                {
                                    TempQueue.Enqueue((TempGeldQuellenFiliale.BUDGET % 100).ToString());
                                    letzteÜbergebeneListe.Add((TempGeldQuellenFiliale.BUDGET % 100).ToString());
                                }
                                else
                                {
                                    TempQueue.Enqueue((TempGeldQuellenSchiff.SCHIFFSBUDGET % 100).ToString());
                                    letzteÜbergebeneListe.Add((TempGeldQuellenSchiff.SCHIFFSBUDGET % 100).ToString());
                                }

                                TextLieferant.wechsleAuswahlText("1.2.1", TempQueue, false, false);
                            }
                            break;
                        case 4:
                            // Auswahl 4 = Abbruch
                            letzteÜbergebeneListe.Clear();
                            gewählteHandelsWare = null;
                            gewählteSpielerFiliale = null;
                            gewähltesSpielerSchiff = null;

                            // Wenn abbruch erfolgen soll -> zurück zu Root
                            TextLieferant.wechsleAuswahlText("1", new Queue<string>(), false);
                            break;
                    } 
                    #endregion
                    break;
            }


        }

        private void importierePresetInListe(string Preset)
        {

            switch (Preset)
            {   //Immer Hintergrund zu Vordergrund Hinzufügen
                // ToDo: Alle Häfen implementieren und deren Elemente aus den Vorlage Screens extrahieren und hier einpflegen
                case "LIVERPOOL":
                    AnzeigeListe.Add(BG["HOLZ"]);
                    AnzeigeListe.Add(Fenster_Tür["1"]);
                    AnzeigeListe.Add(Tür_FeldL["1"]);
                    AnzeigeListe.Add(Tisch["2"]);
                    AnzeigeListe.Add(Verkäufer_Gesicht["1"]);
                    AnzeigeListe.Add(Verkäufer_OKörper["1"]);
                    AnzeigeListe.Add(Verkäufer_Hände["1"]);
                    AnzeigeListe.Add(Tafel_BG["HOLZ"]);
                    AnzeigeListe.Add(Tafel["BASIC"]);
                    AnzeigeListe.Add(Tafel_VG["FASS_SCHWAMM"]);
                    break;
                case "LONDON":

                    break;
            }


        }


        public void ladePresets()
        {
            //Achtung Logik für Kontrolle der Renderreihenfolge muss nochh ausgearbeitet werden
            foreach (Image aktuellesBild in AnzeigeListe)
            {

                aktuellesBild.Alpha = 0;
                Tween(aktuellesBild, new { Alpha = 1f }, 180f, 0f).Ease(Ease.BackInOut);

                AddGraphic(aktuellesBild);
            }


        }


        private void setzePresets()
        {
            //Sammelt und fügt alle Sprite-Bausteine des Spiels in die Listen

            //TempImage für mitgeben der Image parameter wie Position
            Image tempImage;

            //Hier werden alle möglichen Sprites für den Handelsscreen bereit gelegt und in die Dictionarys geschrieben
            //Hintergründe
            tempImage = vorbereitenImage(Assets.HANDEL_RAUM_HOLZ, 0, 0);
            BG.Add("HOLZ", tempImage);

            //Fenster Tür
            tempImage = vorbereitenImage(Assets.HANDEL_TÜR_1, 99, 145);
            Fenster_Tür.Add("1", tempImage);

            //Deko
            tempImage = vorbereitenImage(Assets.HANDEL_DEKOTÜR_LINKS_1, 0, 145);
            Tür_FeldL.Add("1", tempImage);

            //Tische
            tempImage = vorbereitenImage(Assets.HANDEL_TISCH_2, 0, 290);
            Tisch.Add("2", tempImage);

            //Gesicht
            tempImage = vorbereitenImage(Assets.HANDEL_GESICHT_1, 234, 120);
            Verkäufer_Gesicht.Add("1", tempImage);

            //Oberkörper
            tempImage = vorbereitenImage(Assets.HANDEL_OKÖRPER_1, 234, 175);
            Verkäufer_OKörper.Add("1", tempImage);

            //Hände
            tempImage = vorbereitenImage(Assets.HANDEL_ARME_1, 234, 258);
            Verkäufer_Hände.Add("1", tempImage);

            //Tafel_BG
            tempImage = vorbereitenImage(Assets.HANDEL_TAFEL_HINTERGRUND_HOLZ, 444, 19);
            Tafel_BG.Add("HOLZ", tempImage);

            //Tafel
            tempImage = vorbereitenImage(Assets.HANDEL_TAFEL_BASIC, 444, 62);
            Tafel.Add("BASIC", tempImage);

            //Tafel_VG
            tempImage = vorbereitenImage(Assets.HANDEL_TAFEL_VORDERGRUND_1, 444, 333);
            Tafel_VG.Add("FASS_SCHWAMM", tempImage);


        }
        private Image vorbereitenImage(string Asset, int xPos, int yPos)
        {
            Image tempImage = new Image(Asset);
            tempImage.X = xPos;
            tempImage.Y = yPos;

            return tempImage;
        }

        //Errechnen der darzustellenden Maximalmenge des Zielschiffes (Schiff noch durchdenken weil da auch ein Mengen Cap vorhanden ist)
        private int errechneMaxMenge(string Ware, Schiff ZielLagerOrt)
        {

            return 0;
        }

        //Errechnen der darzustellenden Maximalmenge der Zielfiliale
        private int errechneMaxMenge(string Ware, Filiale ZielLagerOrt)
        {

            return 0;
        }
    }
}