You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2065 lines
109 KiB
C#
2065 lines
109 KiB
C#
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;
|
|
}
|
|
}
|
|
}
|