Forenbeiträge von Bradley Ingesamt 153 Beiträge
Ich hab das Projekt ist auf Visual Studio Team Service umgestellt.
Dazu habe ich mein Backlog mit Trello verknüft.
https://trello.com/b/IfcrDW9U/space-opera-rebuild
Also primär interessiert mich ob ich das backlog und / oder tasks/bugs quasi public machen kann.
Finde ich ja nett das mein ProjektThread als Beispiel heran gezogen wird. 😁
Korrekterweise muss man sagen das ich aktuelle MonoGame verwende, da XNA leider seits Microsoft tot ist.
Also im Prinzip kann MononGame alles was du forderst. Vieles musst du dir erstmal einfach bauen.
MonoGame selbst versucht immer bei 60 FPS zu bleiben.
Wenn ich das richtig im Kopf habe läst sich das aber im entsprechenden Konstruktur einstellen.
Ich wollte mich mal erkundigen ob jemand einschlägige Erfahrung mit Visual Studio TEam Service hat.
Nach dem erstem darüber Schauen sieht es für mich aus wie eine Team Foundation Server 'light'.
Kann diese einschätzung jemand bestätigen/wiederlegen ?
Nachdem das Bewegen nun klappt ist das wechsel auf die Battlemap der nächste Schritt.
Dazu kommt jetzt noch das Platzieren eines Gegners.
EDIT:
Nächste Schritte währen das GUI für die Waffenkontrolle und eine Funktion einen bestimmen von mehreren Gegnern als Ziel zu markieren bzw. dessen Statuswerte anzuzeigen.
Ein kleines Update, die Bilder für Diagonale bewegung sind fertig gepixelt.
Dabei ist mir noch ein kleiner Bug bei der Karte aufgefallen, aber das wird noch behoben.
Nächster Prototyp jetzt mit Diagonaler Bewegung.
Hallo herbivore,
erstmal danke für dein Lob und Interesse an meinem Projekt, sowas hört man gerne 🙂
Mal zum Punkt der Sichtbarkeit des Raumschiffes, Nebel werden Definitv Transparenter.
Ausserdem kommt noch eine kleine 'Blink' Animation für Positionslichter hinzu, sind zwar nur ein paar Pixel aber das lenkt schon etwas das Auge. Das gleiche für den Antrieb
Dann habe ich noch ein paar andere Gedanken, zum Beispiel die Nebel und Asteroidenfelder quasi in der höhe zu kappen das die Figur 'darüberschwebt', das natürlich an/abschaltbar 😉
Eine andere möglichkeit dich ich da sehen ist, das Raumschiff auf eine Art Pixelsockel zu stellen auf dem das Raumschiff 'klebt'.
Eine Hexagonale Map würde dieses Problem definitv umgehen.
Nur bin ich im Moment definitv zu Faul das alles neu zu schreiben und zu Pixeln 😁
Aber das Diagonale bewegen wird definitv kommen. Das wird zwar auf der Karte ein paar unschöe Treppeneffekte haben, aber damit muss man vorerst leben.
Edit:
Ganz vergessen, es wird auch möglich sein mehere Wegpunkte vorzugeben und das Spiel erstellt dann dazuwischen den Pfad.
Der erste Prototyp der Routenplanung sieht doch schon mal ganz brauchbar aus. Linksklick auf der Karte erzeugt die Route, Rechtsklick auf das gleiche Kartenfeld und das Schiff bewegt sich.
Der führt zu einem realtiv goßen GIF welches den Vorgang zeigt, die größe übersteigt leider die maximale größe eines Anhangs.
http://bradley-labs.de/download/SO_Pictures/MoveBeispiel.gif
Das Release 0.11 war für mich ein guter Schritt in die richtige Richtung was Features und Struktur angeht. Dass das Spielerschiff nun so modular vorliegt wie geplant war eine Grundvoraussetzung für das kommende Kampfsystem. Wo unter anderem das gesamte Schiff oder auch einzelne Module gezielt anvisiert und beschädigt werden können.
Um dieses aber so umzusetzten wie mir es vorschwebt, nämlich als tatsächliches Kampffeld auf dem sich der Spieler und Gegner Rundenweise bewegen, muss ich noch das bewegen per Maus und ein einfaches bewegungssystem für den Gegener programmieren.
Zumindest für die Zukunft ist geplant das der Gegner sich selbst aus einem Rumpf und vorhandenen Modulen zusammen setzt.
Fürs erste werde ich 1-5 verschiedene Gegnertypen programmieren. Von leicht bis unmöglich.
In wie weit ich ein komplexeres 'verhalten' einbaue, das muss man sehen.
Ausserdem muss ich mich weiter mit dem einbauen und dem Balacinge der Module beschäftigen.
Als kommendes Modul wird definitv noch der Computerkern kommen.
Der Computerkern soll verschiedene Boni liefern je nach auslegung. So stelle ich mir vor das ein Gefechtscomputer deutliche Bonis auf Treffer und Ausweichchance gibt, während ein Industriecomputer die Effizents der Raffiniere verbessert, ein Forschungsrechner gibt wiederum Boni auf die Forschung.
Auch hier schwebt mir vor das der Spieler in Zukunft auch Drohnen bauen und Kontrollieren kann. Auch da wird der Bordcomputer eine Rolle spielen wie viele Drohnen kontrolliert werden können.
Nach einigen arbeiten und verknüpfen von etlichen losen Enden ist endlich Version 0.11 bereit.
Die Forschung ist fertig implementiert, ebenso der Schiffskonfigurator welcher Module aus den Forschung erhält.
Ebenso gibt es ein Optionsmenu über welches sich die Auflösung und die Lautstärke de Musik regeln läßt.
Der Vollständige Beitrag ist auf meinen Blog zu finden:
https://bradley-software.blogspot.de/2018/03/space-opera-release-011.html
Auch ist wieder die Musik implementiert.
Downloadlink:
http://www.bradley-labs.de/download/SpaceOpera/SO_StandAlone_0.11.rar
Hab etwas herumgepixelt und mal endlich den Blauen Platzhalter gegen ein Schiff ausgetauscht.
Eventuell muss ich dem nebel etwas mehr transparents verpassen das man das Schiff besser sieht.
Mh schon ein wenig ... peinlich das gerade so was nicht drin ist.
Aber danke für den Link.
Ich stehe gerade vor einem Rätsel.
Ich versuche alle der Grafikkarte unterstützten auflösungen auszugeben.
Mein Gedanke war das ich diese über ein Array bekomme von:
Screen[] screen = Screen.AllScreens;
Damit bekomme ich aber lediglich alle angeschlossene Bildschirme und deren aktuelle Bildschirmauflösungen aber nicht die unterstützten Auflösungen.
Kennt dazu jemand eine Lösung?
Version 0.11 kommt gut voran und es sind einige Modultypen integriert. Hier mal eine kurze zusammenfassung:
Struktur: Das ist das was das Schiff im Grunde zusammen hält. Sinken die Hitpoints hier auf Null wars das. Game Over
Maximale Masse: Bestimmt die Maximal im Schiff bewegbare Masse
Waffenslots: Wie viele Waffen können verbaut werden
Panzerung: Das was man sich allgemeinen darunter eben vorstellt. Eine auf die Struktur aufgebrachte Schicht an Stahl oder einem anderen Material das Schaden absorbiert.
Ausweichchance: Sollte hier bessere Tarnungschance heißen, tut aber letztlich das gleiche. Das Schiff ist schwerer zu treffen
Absorption: Eingehender Schaden wird im x% reduzier
Schildgenerator: Das Modul welches die Schildemiter und Zellen mit Energieversorgt.
Aufladerate: Läd das Schild während des Gefechts/Runden um Wert x auf
Schildemitter: Emitter oder Zellen, bestimmen die maximale Stärke eines Schild.
Schildstärke: Die Maximale stärke des Schilds
Reaktor: Das Modul welches Energie im Schiff erzeugt
Energieoutput: Die Menge an erzeugter Energie Pro Runde
Energienetz: Erzeugte Energie muss irgendwo gespeichert werden
Deuteriumkosten: Reaktoren benötigen Treibstoff
EnergieKondensatoren: Ein Modul welches Primär darauf ausgelegt Energie zu speichern
Energienetz: Erzeugte Energie muss irgendwo gespeichert werden
Sublichtantrieb: Das Modul ist eher im Kampf interresant und stellt klassische Schubdüsen dar
Ausweichchance: Bessere Schubdüsen ermöglichen bessere und schnellere Ausweichmanöver
Trefferchance: Was für das Ausweichen gilt, gilt auch für das Treffen
Sprungantrieb: Dieses Modul bewegt den Spieler über die eigentliche Karte
Optimale Masse: Bis zu diesem Punkt kostet das bewegen eines Schiffes nur geringe Mengen von Energie
Maximale Masse: Bis zu diesem Punkt kostet das bewegen deutlich mehr Energie als normal, darüber wird das Schiff zwar bewegt aber das Schiff erleidet Schäden.
Raffinerie: Ein Modul welches die Rohstoffe verarbeitet
Slots: Die Anzahl der Verarbeitungsslots in der Raffiniere, mehrere Slots ermöglichen das verarbeiten mehrer Ressourcen pro Runde
Slotgröße: Die Maximale Menge an Ressourcen die pro Runde und Slot verabreit werden können
Effizents: Die Menge an Ressourcen die tatsächlich gewonnen werden kann
Konstruktionseinheit: Das Modul welches andere Module baut
Baupunkte: Einfach nur die GEschwindigkeit in der andere Module gebaut werden können.
Forschungseinheit: Das Modul welches das Forschen überhaupt ermöglicht
Forschungspunkte: Einfach nur die Geschwindigkeit in der geforscht werden kann.
Sensoren: Irgendwie muss man ja den Raum um sich herum warnehmen können
Trefferchance: Je besser die Sensoren desdo besser kann man auch ein Ziel treffen
Sensorstärke: Bessere Sensoren entdecken mehr Ressourcen oder auch mal verschollene und versteckte dinge
Waffen: Alles was anderen Schaden zufügt
Schaden: Die Menge an Schaden der potentiel zugefügt wird
Hitchance: Basistrefferchance der Waffe
Alle module und Forschungen werden als XML beschrieben und sind somi wunderbar modbar
Vorschau auf die nächste Version 0.11
Forschungen schalten weitere Forschungen und/oder Module frei.
Die freigeschalteten Module, und die aktuel verbauten Module können im Schiffskonfigurator angesehen werden.
Vorschau auf die nächste Version 0.11
Hauptpunkt der Version ist die Forschung und das Produzieren von Modulen.
Das Bild zeigt das Forschungslabor.
Die verfügbaren Forschungspunkte können auf eine oder mehrere Forschungen verteilt werden.
Zusätzlich muss auch noch aktiviert werden ob eine Forschung erforscht wird.
Endlich ist Version 0.10 fertig. Im Vergleich zur Vorschau konnte ich einige Bugs erschlagen, aber auch einige Features einbauen.
Das Hauptaugenmerk habe ich dabei auf die Gewinnung und Veredelung von Ressourcen gelegt.
Die neuen Grundrohstoffe sind Roherz und Wasser. Roherz läßt sich wie gewohnt aus Asteroiden gewinnen. Aus Nebel läßt sich nun Wasser gewinnen statt wie bisher Deuterium.
Über die Raffinerie kann man nun auswählen ob man das Roherz wie gehabt in Metall oder, nun neu, in Edelmetall raffinieren will. Wasser wird in Deuterium umgewandelt.
Um allerdings Organische Materie zu gewinnen muss man Wasser und Roherz raffinieren. Wer will kann sich jetzt einen Tank voller anaerobe Bakterien vorstellen welche die Grundstoffe zur Reproduktionen nutzten. In einem weiteren Schritt läßt sich die Organische Materie in Kunststoff umwandeln.
- Energie
- Deuterium (Raffiniert aus Wasser
- Roherz
- Metall
- Kunststoff (Raffiniert aus Organische Materie)
- Organische Materie (Raffiniert aus Wasser und Erz)
- Wasser
- Edelmetall (Raffiniert aus Roherz)
Im Kasten von 1 kann man die Grundstoffe; Roherz, Organische Materie und Wasser sehen bzw. die Menge die im Lager vorhanden ist.
Beim klicken auf das das Rohstoffsymbol in Kasten 2 wechselt man das Endprodukt und damit auch das was raffiniert werden soll, sowie die notwendigen Grundstoffe die verbraucht werden. Aktuell erfolgt die Umwandlung (1 zu 1 / Raffiniere Effizienz ) . Das bedeutet aus 2 Erz + 2 Energie = 2 Metall / 50% Raffinerie Effizient = 1 Metall.
Hier noch eine Liste der geschlossenen Tickets:
Behobene Bugs
#15: Forschungspunkte verteilen ohne Aktive Forschung
#17: Playerposition nach Laden
#16: Vergebene FP werden nach Forschungsende nicht zurück gesetzt
#25: Forschungspunkte verlust bei Rundenende
#27: Speichern der Forschungen funktioniert nicht
#28: Forschungspunkte nach Laden können negativ werden
Features
#20: Erstellene eines Shortcuts & Buttons um direkt das Ticketsystem zu öffnen
#26: Rundenende über Tastendruck
#18: Geöffnete Fenster verschieben
Funktioniert nur über Rechtsklick
#11: Automatischer Screenwechsel von IntroScreens zum MainMenu
#29: Ressourcen Implementieren
#30: Raffinerie ausbauen um Grundstoff zu raffinieren
Link zum Ticketsystem
https://bitbucket.org/bradleylabs/space-opera/issues?status=new&status=open
Nachdem ich jetzt ein wenig Zeit hatte, habe ich mit dem ganzen ein wenig herum gespielt.
Das wechseln von XML zu JSON hat schon mal gut 2/3 weniger Speicherbedarf gebracht.
Kleine Karte von 300 auf rund 100mb.
Jetzt noch ein paar Prüfungen rein wie von @dannoe empfohlen und ich bin von 100mb auf 10mb herunter. Die große Karte ist von rund 3GB auf rund 250 mb geschrumpft.
Habe ich einen link im Code, kann ich diesen ja per strg + Linksklick öffnen.
Dabei geht der von mir als Default eingestellte Browser von Windows auf und der Link wird geladen.
Gibt es eine möglichkeit der IDE zu sagen das sie den Link einfach in ihrem internen Browser laden soll ?
Eigentlich eine kleinigkeit die mich aber wahnsinnig macht.
Hätte Abt mir noch mitgeteilt das er das Thema getrennt hätte, hätte ich auch noch hier drauf geantwortet 😄
Also Zeroformater sieht schon mal sehr interresant aus.
Damit werde ich mich weiter beschäftigen.
Erstmal Danke für die Hilfe.
Ich denke mal das Speichern in Binärform ist für die Map tatsächlich sinnvoll.
Leider stoße ich hier an technischen beschränkungen schon bei der mittleren Map.
Bis ich da eine brauchbare lösung habe, reduziere ich den Inhalt der mapfield - Klasse und speichere es als JSON.
Stimmt schon was du sagst.
ID kann raus.
Maplevel ebenso -> überbleibsel einer Idee die ich verworfen habe
Koordinaten brauch ich ingame.
Mit dem Resetcounter bringst du mich da tatsächlich auf einen Gedanken.
Nur wie kann ich steuern ob das Feld Serialisiert wird wenn es nicht den Standartwert von 0 hat ?
Hab mal eine kleine Testreihe gemacht, XML vs. JSON.
Kleine Karte (1000x1000): 312 mb | 116 mb
Mittlere Karte (2500x2500): 1.967 mb | 744 mb
Große Karte (5000x5000): 7.900 mb | 3.000 mb
Dieser Klasse wird pro Feld Serialisiert.
public class mapField
{
public Int64 ID { get; set; }
public int Maplevel { get; set; }
public Vector2 Koordinaten { get; set; }
public SpaceFieldTypes FeldTyp { get; set; }
public SpaceFieldTypes FeldTypOrigin { get; set; }
public int RessourceResetCounter { get; set; }
public SpaceFieldVisble Visible { get; set; }
}
Forum habe ich wieder online gebracht. Leider ohne den alten Inhalt.
http://forum.bradley-labs.de/
Grad mal nachgeschlagen, nicht nur das JSON 'Kleiner' ist, es kann auch Arrays.
Die Map ist ja nix anderes als ein Array aus Klassen, um das in XML zu de/serialisieren musste ich immer den umweg gehen das in eine Liste umzuwandeln.
Würde damit 2 Fliegen erschlagen, Code verschlanken und dann noch kleinere Datei erzeugen.
=)
In den letzten 2 Jahren gab es einige große Umbrüche. Sowohl Privat als auch Beruflich. Letztlich habe ich aber wieder Zeit mich meinem kleinen Dauerprojekt zu widmen.
Ich bin dabei den kompletten unterbau von Space Opera neu zugestalten.
Was eigentlich einen kompletten Rebuild gleicht. Einer der Punkte ist eine möglichst offene Struktur an Daten. So möchte ich das möglichst viel an Daten und Informationen über XML gespeichert werden.
Ziel ist dabei die XML "selbstbeschreibend" zu machen, im Moment sieht das dann so aus, wobei die Startressourcen noch in eine Eigene XML wandern werden.
Das Spiel verfügt nun auch wieder über eine Speicherfunktion, wie aus vielen Spielen bekannt ist F5 Schnellspeichern und F9 Schnellladen. Dabei kam heraus das ich überraschend große Menge speichern muss. Das mag allerdings am Format von XML liegen.
So komme ich bei einer kleinen Karte auf gute 220mb (1000x1000 Felder) während eine große Karte (5000x5000 Felder) auf schlappe 3GB kommt. Wie ich diese Datenmenge kleiner bekomme muss ich mir noch gezielt überlegen.
Hier noch ein Screenshoot der aktullen Version, dabei ist zu sehen das die Karte - wie bereits ursprünglich geplant - unsichtbar ist. Danach erscheint ein "For of War".
FogOfWar
Das ganze ist noch eine sehr umfangreiche Baustelle bis ich alle Funktionen wie vom letzten Release sauber neu geschrieben habe.
Dennoch arbeiten bereits einige der neuen Funktionen soweit das ich sie Release kann.
Die Steuerung der Menus erfolgt wie gewohnt mit der Maus.
Die Steuerung des Spielers (der Blaue Platzhalterpfeil) über die Tasten W,A,S und D.
Speichern und Laden über F5 und F9
Im Spiel selbst gibt es auch eine Konsole die mit F12 geöffnet werden kann.
Bisher unterstützt die Konsole folgende Befehle:
- add_energie:
- add_deut:
- add_erz:
- add_metall:
gefolgt von einer Positiven oder Negativen Ganzzahl und einem Enter.
Was bereits Funktional Integriert ist:
Bewegung des Spielers
Laden/Speichern
Ressourcenabbau über Scannfunktion
Veredeln von Ressourcen über Raffinerrie
Grundzüge der Forschung (allerdings ohne weitere Forschungen oder Module)
Ich hoffe das ich in den nächsten Woche dazu kommen die Fehlenden Inhalte wie Forschung, Kampf, Sound und Bauen integrieren kann damit die Version 0.10 nicht lange eine Preview bleibt.
Der Download der Preview zur Version 0.10 ist in folgenden Blogeintrag ganz unten enthalten.
Über Kritik und Anregungen, als Kommentar oder Mail, würde ich mich freuen.
Okay, ich denke damit währe das Thema erschlagen.
Danke.
Ich stoße bei Codeschnipseln immer wieder auf folgende Schreibweise:
public void TEST(int a, int b) {
...
}
statt wie in VS voreingestellt:
public void TEST(int a, int b)
{
...
}
Von einem bekannten habe ich nur gehört das eben die obere Art guter Codestil sein soll.
Wenn das Stimmt, erschließt sich mir da der vorteil nicht.
Oder ist es einfach Geschmackssache?
VS2017 überraschte mich Heute morgen mit der angehängten Fehlermeldung.
Kann einer von euch was damit anfangen ?
Mal vom offensichtlichen das ich kein Zugriff auf irgendwas habe was er braucht ?
Auch wenn Ich langsam fürchte das es den Rahmen des Threads deutlisch sprengt.
Habe ich versucht das ganze als 3 Schicht/Layer system nochmal neu aufzubauen.
Sorry für den Langen Quote, sofern gewünscht hänge ich das Projekt auch an.
namespace Test_Interface
{
class Program
{
static void Main(string[] args)
{
World world = new World();
while (true)
{
world.Simulation(world.Order);
}
}
}
class World
{
Ship s = new Ship() { Energy = 100 };
public World()
{
//möglichkeit der DeSerialiserung durch eine XML
s.DummyModul.Add(new Modul()
{
ModulStatus = Status.Online,
EnergyConsumptionMin = 0,
EnergyConsumptionMax = 10,
EnergyConsumptoonStandby = 5
});
}
private string InputConsole()
{
return Console.ReadLine();
}
public string Order { get { return InputConsole(); } }
public void Simulation(string eingabe)
{
string text = string.Empty;
switch (eingabe)
{
case "Energie":
text = "Energielevel bei: " + s.Energy;
Ausgabe(text);
break;
case "Energiebedarf":
text = "Energiebedarf bei: " + s.EnergyConsumption;
Ausgabe(text);
break;
case "Runde":
text = RoundTick();
Ausgabe(text);
break;
default:
text = "Befehl nicht verstanden";
Ausgabe(text);
break;
}
}
private string RoundTick()
{
string text = string.Empty;
text = "Energiespeicher ist gefüllt mit: " + s.Energy + "\r\n";
text += "Energiebedarf ist: " + s.EnergyConsumption + "\r\n";
if (s.Energy >= s.EnergyConsumption)
{
text += "Die Energie reicht für diese Runde aus.\r\n";
s.Energy -= s.EnergyConsumption;
}
else
{
text += "Die Energie reicht nicht aus. \r\n";
}
text += "Neuer Energiestand ist: " + s.Energy;
return text;
}
public void Ausgabe(string Text)
{
Console.WriteLine("-----");
Console.WriteLine(Text);
Console.WriteLine("-----");
}
}
public class Ship
{
List<Modul> dummyModul = new List<Modul>();
public int Energy { get; set; }
public int EnergyConsumption
{
get { return (from Element in dummyModul select Element.EnergyConsumption).Sum(); }
}
public List<Modul> DummyModul { get { return dummyModul; } set { dummyModul = value; } }
}
public class Modul : IEnergyConsumption, IStatus
{
public int EnergyConsumption
{
get
{
switch (ModulStatus)
{
case Status.Online:
return EnergyConsumptionMax;
case Status.Offline:
return EnergyConsumptionMin;
case Status.Standby:
return EnergyConsumptionMax;
default:
return 0;
}
}
}
public int EnergyConsumptionMin { get; set; }
public int EnergyConsumptionMax { get; set; }
public Status ModulStatus { get; set; }
public int EnergyConsumptoonStandby { get; set; }
}
public interface IStatus
{
Status ModulStatus { get; set; }
}
public interface IEnergyConsumption
{
int EnergyConsumption { get; }
int EnergyConsumptionMin { get; set; }
int EnergyConsumptionMax { get; set; }
int EnergyConsumptoonStandby { get; set; }
}
public enum Status
{
Online,
Offline,
Standby
}
}
@Abt,
Ja du hast vollkommen recht, in diesem Beispiel verwende ich keine 3-Schicht/Layer system.
Da muss ich direkt zugeben das ich noch damit Kämpfe es zu verstehen und anzuwenden.
Parallel zu deiner Antwort etwas herum gespielt.
Dabei ist das hier heraus gekommen:
Die ModulKlasse:
public class ModulC : IEnergyConsumption, IStatus
{
public int EnergyConsumption
{
get
{
switch (ModulStatus)
{
case Status.Online:
return EnergyConsumptionMax;
case Status.Offline:
return EnergyConsumptionMin;
case Status.Standby:
//Beispiel für zusätzlichen Status
return EnergyConsumptionMax / 2;
default:
return 0;
}
}
}
public int EnergyConsumptionMin { get; set; }
public int EnergyConsumptionMax { get; set; }
public Enum ModulStatus { get; set; }
}
und Ihr Interface:
public interface IStatus
{
Enum ModulStatus { get; set; }
}
Ich gebe dir recht das es schwierig wird wenn ich mehr als nur den "on/off" Status haben will.
Allerdings ist ein Enum doch nur in Form einer Methode in einem Interface unter zu bringen, oder Irre ich mich da ?
@Palin,
ich werde das "Modulintern", das Modul selbst weiß ob es an ist oder nicht. Dementsprechend wird das Property seinen Get gestaltet haben. Wenn Activ = True dann Energiedarf = X wenn False, denn Energiebedarf = 0.
Die Klasse Ship erhält dennoch listen an unterschiedlichen Modulen. In den Propertys (mit weiteren Methoden) der Klasse sammel ich mir dann die Infos zusammen wie viel Energie erzeugt, Verbraucht etc. wird.
Mag jetzt nicht DIE elegante Lösung sein, wie Sie mir am anfang vorschwebte aber elegant und pragmatisch genug das ich es ausbauen und noch gut serialisieren kann, bzw. Als Tempalte nutzen kann.
Du beziehst dich dabei auf die herangehensweise von T-Virus, richtig?
Denn IModule kann alles mögliche sein (generischer Bezeichner), aber wir haben hier ja offensichtlich eine Einschränkung auf Module für Energie.
Eigentlich sollte das sogar noch tiefer gehen, nämlich ob ein Modul auch Aktiv ist.
Daran gekoppelt wäre auch der Energiebedarf.
In einer nächsten Ausbaustufe könnte man darüber sprechen das ein Modul auch Trefferpunkte hat. Sinken die Trefferpunkte, sinkt der Energiebedarf - da das Modul nicht mehr voll Einsatzfähig ist.
Edit: Was die Bezeichnungen angeht, ja stimmt natürlich das durchgehend Englisch sinniger wäre.
@T-Virus,
danke das is ein guter Ansatz über den ich Nachdenken werde.
@Palin,
der Gedanke war, einmal eine Methode zu Implemenitieren welche die Subtraktion durchführt. Dazu brauchte ich ja beide Werte.
Ich war der Meinung mal gelesen zu haben das ich mit einem Aufrufen IEnergiebedarf, ALLE diese Methoden ansprechen kann.
Auf alle Fälle, danke. Das hilft mir schon mal weiter 😃
Ich versuche gerade zu verstehen was du meinst.
Meinst du eine Struktur in dieser Art?
Item : IEnergiebedarf
-- modulA()
-- modulB()
...
-- modulF()
Du hast mich mit der Liste auf einen anderen Lösungsansatz gebracht, bei dem ich im Moment allerdings auch Hänge, nämlich Reflections:
public void RundenTick()
{
Type t = this.GetType();
PropertyInfo[] pi = t.GetProperties();
foreach (PropertyInfo item in pi)
{
if (item.Name == "Energie")
{
Console.WriteLine(item.Name);
}
}
}
Damit bekomme ich zumindest das Properyt "Energie" welches direkt in Ship ist, allerdings nicht die Properytes von mA oder mB, selbst wenn ich diese Listen als Property anlegen.
public List<ModulA> modA
{
get { return mA; }
set { mA = value; }
}
Gibts ne möglichkeit auch auf diese zuzugreifen ?
Entschuldigung für die späte Antwort.
Das Problem saß, wie immer, vor dem Bildschirm.
Das Projekt hatte ich von X86 auf X64 umgestellt.
Dabei scheint mir der Hacken bei "Erstellen" verloren gegangen zu sein.
Nach dem setzten verhielt sich Visual Studio wieder wie gewohnt.
Hallo,
ich stehe gerade, mit einem Problem, auf dem Schlauch und weiß nicht in welcher Richtung ich hinunter fallen muss.
Hintergrund:
Ich arbeite an einem Rundenbasiertes Spiel.
Der Spieler hat ein Schiff, die Eigenschaften des Schiffes werden durch Module definiert.
Einige Module, unterschiedlichen Typs, verbrauchen Energie.
Das wollte ich über diese Klasse + Interface darstellen:
public interface IEnergiebedarf
{
int Energieverbrauch(int BasisEnergie);
int Energiebedarf { get; set; }
}
public class ModulA : IEnergiebedarf
{
public int Energiebedarf { get; set; }
public int Energieverbrauch(int BasisEnergie)
{
return BasisEnergie - Energiebedarf;
}
}
public class ModulB : IEnergiebedarf
{
public int Energiebedarf { get; set; }
public int Energieverbrauch(int BasisEnergie)
{
return BasisEnergie - Energiebedarf;
}
}
Das Schiff/Spieler erhält Listen von modulA bzw. modulB.
Dazu noch eine Implementierung der "BasisEnergie".
public class Ship
{
List<ModulA> mA = new List<ModulA>();
List<ModulB> mB = new List<ModulB>();
int BasisEnergie = 100;
public Ship()
{
mA.Add(new ModulA() { Energiebedarf = 1 });
mA.Add(new ModulA() { Energiebedarf = 5 });
mB.Add(new ModulB() { Energiebedarf = 5 });
}
public void RundenTick()
{
foreach (var item in mA)
{
BasisEnergie = item.Energieverbrauch(BasisEnergie);
}
}
public int Energie
{
get { return BasisEnergie; }
set { BasisEnergie = value; }
}
}
Problemlos lößbar ist jetzt jeweils für modulA und modulB eine getrennte Schleife zu durchlaufen und den Energiebedarf ab zu ziehen.
Ich persönliche empfinde das aber als unsauber gelößt.
Am liebsten würde ich "RundenTick" auf diese Art umsetzten:
public void RundenTick(IEnergiebedarf e)
{
BasisEnergie = e.Energieverbrauch(BasisEnergie);
}
So das beim einmaliegen aufrufen der Methode alle e.Energieverbrauch durchlaufen werden.
Leider komme ich an dieser Stelle mit der Implementierung nicht klar, da diese Implementierung:
Ship s = new Ship();
s.RundenTick(s.Energie);
wegen der Paramenter nicht geht:> Fehlermeldung:
Fehler CS1503 Argument "1": Konvertierung von "int" in "Test_Interface.IEnergiebedarf" nicht möglich.
Daher die Frage: Ist das was mir vorschwebt überhaupt so umsetzbar ?
Ich werde langsam wahnsinnig.
Bei absoluter jeder Datei dich gerade in meinem Projekt ändere erhalten ich die angehängt Fehlermeldung.
Ich verstehe aber nicht wie es kommt das diese Meldung jetzt beim jeden neuen Debuggen kommt.
Jemand eine Idee ?
Okay ich sehe ein das ich zu wenig Infos gegeben habe.
Ich verwende die XML Serialisierung.
Als beispiel folgende Klasse:
public class TEST
{
[XmlElement(ElementName = "test")]
public int ID { get; set; }
public string Titel { get; set; }
public string Text { get; set; }
}
Was ich mir jetzt machen möchte, wäre beim/vor dem Serialiesieren den ElementName durch einen beliebigen String auszutauschen.
Hallo,
ich versuche eine XML zu Serialisieren, das RootElement der XML will ich einen XMLElement(Element= ...) einsetzten.
Die Frage ist, ob ich den Namen des Element dynamisch erzeugen kann. Zum Beispiel durch ein Feld der Klasse oder ein Property?
Danke für die Hilfe.
Ich stehe gerade etwas auf den schlauch wegen einer Fehlermeldung.
Hintergrund ist der, das ich beim Starten meines Programms eine Combobox aus einer SQLite befüllen möchte.
Dabei wird immer die angehängte Fehlermeldung beim letzten Schritt: cb_Typ.DataSource = dt; ausgegeben. Wohlgemerkt bei dieser Zeile, nicht durch das Try/Catch.
Nach dem OK der Fehlermeldung ist allerdings alles wie gewünscht in der Combobox vorhanden und bedienbar.
private void Fill_ComboBox_DocType()
{
try
{
con.Open();
SQLiteCommand cmd = con.CreateCommand();
cmd.CommandText = "SELECT doctypelong,doctypevalue FROM DocType";
SQLiteDataReader reader;
reader = cmd.ExecuteReader();
DataTable dt = new DataTable();
dt.TableName = "TEST";
dt.Columns.Add("doctypevalue", typeof(string));
dt.Columns.Add("doctypelong", typeof(string));
dt.Load(reader);
cb_Typ.ValueMember = "doctypevalue";
cb_Typ.DisplayMember = "doctypelong";
cb_Typ.DataSource = dt;
}
catch (Exception ex)
{
MessageBox.Show(ex.GetType() + ": " + ex.Message);
con.Close();
}
con.Close();
}
Ja habs hinbekommen.
Vielen dank nochmal 😃
Erstmal vielen Dank für den Code 👍, ich denke ich verstehe was du gemacht hast.
Werds aber nochmal genauer bei mir durch testen 😄.