Rulasis

[perfect-code]

Hallo Zusammen

Eigentlich ist es weder ein Komerzielles System noch ein Angebot, aber ich find einzig dieses Thema passend für die Presentation meiner Software.

Dies ist eine kurze Zusammenfassung meiner, noch nicht fertige, Software. Die Beschreibung werde ich laufend anpassen. In den nächsten Tagen füge ich noch ein paar Printscreens hinzu. Eine erste Free Version sollte voraussichtlich erst in 1-2 Monaten hier als Download zur Verfügung stehen.

Viel Spass beim Lesen

===================================================

Rulasis (Roul Analyse und Simulation Software)

Bild 1

grosse Ansicht

Bild 2

grosse Ansicht

Bild 3

grosse Ansicht

Diagramm 1

grosse Ansicht

Diagramm 2

grosse Ansicht

Die Software wird primär für eigene Zwecke entwickelt. Die Vorgaben wurden relativ knapp gehalten. Der Wert wurde in der ersten Linie auf die Simulationsmöglichkeiten gelegt Zweite Voraussetzung war die Darstellung verschiedenen Chancen.

Die Idee basiert auf der Annahme, dass man die Setzungen nach klar definierten Regel tätigt (z.B. nach einem System oder Strategie). Ist diese Anname gegeben, dann kann man beliebige Systemideen mit dieser Software simulieren, um beurteilen zu können wie gut oder schlecht ein System bzw. Strategie ist.

Wie simuliert Rulasis ein Spiel?

Damit die Software ein Spiel simulieren kann, braucht es nur zwei Angaben von unserer Seite:

- ein Spielverlauf (Permanenz) muss vorhanden sein,

- die Software muss unsere Setzungen bzw. System oder Strategie kennen

Permanenzen

Permanenzen können entweder in das Programm als Textdateien geladen werden, oder man kann sie auch im Programm selbst generieren. Eine dritte Möglichkeit wäre auch die Coups manuell einzugeben.

Wird eine Reihenfolge der Coups eingelesen bzw. generiert oder eingegeben, so werden die Chancen neben der Coups automatisch im Listing angezeigt.

Setzungen (System / Strategie)

Im richtigen Spiel wird man nach jedem Coup seine Setzungen nach bestimmten Regel oder voraussetzungen tätigen. Damit das Programm unsere Strategie oder System an der Permanenz anwenden kann, um ein spielverlauf zu simulieren, muss es das System oder die Strategie kennen und umsetzen wissen. Dies passiert über ein vorgegebenes S_cript, das man logischerweise selber erstellen muss. Das Vorgehen ist relativ einfach:

- Im Editorfenster erfassen wir unsere Strategieidee oder Systemidee mit einem VB ähnlichem S_cript

- Ist die Stopp!programmierung fertig, so wird die Simulation über eine Schaltfläche gestartet.

- Das Programm analysiert unseres S_cript und wendet die Spielweise, die es aus unserem S_cript ausgelesen hat, an die angegebene Permanenz. Die Setzungen werden Coup für Coup nach, von uns definierten S_criptregel, gesetzt.

- Das Programm rechnet parallel im Hintergrund auch den Bankverlauf und verschiedene Statistiken, die man schliesslich nach dem Simulationsende angezeigt bekommt.

Auswertungen

Es können verschiedene Auswertungstypen generiert werden:

- Diagramme

- Coup – Listenauswertung

- Statistik Listenauswertung

Bei Diagrammen werden die Abweichungen der Chancen angezeigt. Das ist mir persönlich erste Priorität gewesen. Ich muss zugeben, dass ich in der Zwischenzeit (hauptsächlich durch dieses Forum) erkannt habe, dass es weit mehr Diagrammtypen gibt. Diese werden mit der Zeit priorisiert und laufen implementiert.

Zusatzinfo:

Die Diagramm Engine habe ich selber programmiert, somit braucht es keine dritt DDLs die ein System unter Umständen dauerhaft zum Abstürzt bringen könnte.

Coup Statistik wird im Listing schon beim Laden der Permanenz direkt angezeigt. Dies ist für mich auch eine sehr wichtige Ansichtsart gewesen! Ich wollte übersichtliche Darstellung aller Chancen. Auch hier habe ich ich in den letzten Tagen erfahren, dass es weit mehr Möglichkeiten geben kann. Zum Beispiel statt einen X könnte man direkt die gezogene Zahl anzeigen. Solche Vorschläge sind willkommen und werden nächstens auch implementiert.

Statistik Listenauswertung ist eine Zusammenfassung der allgemeinen Zahlenstatistik. Mit verschiedenen Flagoptionen kann man eine oder andere Infos ein oder ausblenden.

S_cripting

Für die Erstellung von S_cripts gibt es ein eigenes Fenster. Hier kann man die Idee in Stopp!code umsetzen und speichern oder ausführen. Es gibt zwei Simulationsmodus:

- periodisch

- ununterbrochen

Hier bin ich davon ausgegangen, dass ein System eigentlich nicht erfolgreich anzuwenden ist auch wenn er bei allen Coups ein Plussaldo aufweist aus dem einfachen Grund, weil kein Mensch kann 10 oder mehr Stunden ununterbrochen spielen! Wenn ein Spieltag an einem Tisch etwa 300 Coups im Durchschnitt dauert, würde es also keinen Sinn machen ein System auf 1000 oder mehr Coups ununterbrochen zu testen, weil das würde bedeuten, dass man dann 2-3 tagen ununterbrochen an einem Tisch spielen müsste, um mit dem System einen Gewinn zu machen!? Also hab ich eine periodische Spielweise eingeführt. Die Parameter sind:

- Coupdauer in Minuten

- und Spieldauer in Stunden

Das Programm berechnet die Simulation dann so wie wenn man an einem Tisch zu den zufälligen Zeiten spielen würde. Mein persönliches Ziel ist es ein System oder eine Strategie zu finden, mit der ich 1-2 oder 3 Stunden an beliebigen Tisch zu beliebigen Zeiten spielen könnte und dabei einen sehr kleinen Risikoverlust hätte! Wenn ich also ein System entwickle, dann kann ich es realistisch mit diesem Spielmodus austesten.

Ich hab aber auch ein ununterbrochenes Spielmodus implementiert damit ich Spielentwicklung über längere Zeit beobachten kann und auch den Saldovergleich zu periodischer Spielweise bei gleichem System machen kann.

Programmoptionen

Ich bin scheinbar kein Freund der Windowsschaltflächen, weil ich zum grössten Teil alle Optionen über entsprechende Kontextmenüs programmiert habe. Spass bei Seite, es hat nen besseren Grund. Die Kontextmenüs haben den Vorteil, dass sie keinen Platzt auf dem Formular benötigen. Somit bleibt mehr Platz für die Listenfelder.

Zurzeit sind folgende Kontextmenüs programmiert:

- Im Hauptlistenfeld: Permanenz laden , Permanenz generieren, X Annonce setzen, Y Annonce setzen, Einstellungen und Info

Mit Permanenzfunktionen kann man die Simulationsdaten dem Programm zur Verfügung stellen, damit der Spielverlauf mit unserem S_cript berechnet werden kann.

X und Y Annoncen sind die Zahlen - Reihenfolgen die man selber definieren kann. Diese werden dann im Listing mit einem X ausgewertet. Ich bin auf diese Idee gekommen, weil ich einmal wissen wollte, wie oft die Primzahlen bei einem Roulettespiel vorkommen. Da hab ich wenige Primzahlen bei der X Annonce eingegeben und den Rest bei Y Annonce. Danach konnte man bei der Permanenzauswertung im Listing für jede Primzahl die gezogen wurde in der Spalte X Annonce ein X sehen und in der Y Spalte war ein X für alle Nicht Primzahlen.

Über einstellungen kann man zurzeit Sprache (Englisch oder Deutsch) auswählen. Man kann (und muss beim ersten Start) auch die Stammverzeichnisse für Stopp!e, Statistik und Permanenzen definieren usw.

- In unterem Fenster bei der Statistik gibt es folgende Kontextoptionen: Vorschau, Speichern als, Kopieren, Statistik löschen, dann folgen die Flags (Umsatz, Zahlenstatistik, Spielverlauf und Stopp!ing), Diagramme.

Im Vorschau kann man die Statistik im Ansichtsmodus anschauen und anschliessend auf das Papier drucken. Mit der Option Speichern als kann man Statistik als Text abspeichern. Diese Option habe ich einprogrammiert damit man die Daten eventuell mit Excel (über Import Text) weiter bearbeiten kann.

Mit der Option Kopieren kann man den Inhalt der Statistiklistenfeldes in die Zwischenablage kopieren und an einem anderem Ort einfügen (dies hab ich bei der Auswertungsanzeige hier im Forum gebraucht).

Den Inhalt des Listenfeldes kann man auch löschen.

Über vershciedene Flags kann man einstellen was im Listenfeld angezeigt werden soll. Man kann Zusammenfassung des Umsatzes einblenden, über Zahlenstatistik sehen wie oft die Zahlen und Chancen erschienen sind, Spielverlauf wird auch angezeigt und schliesslich kann man Stopp! auch anzeigen.

Fortsetzung folgt...

bearbeitet März 10, 2006 von perfect-code

[perfect-code]

Anpassung: 10.03.2006

================================================

- hab noch ein paar Fotos hinzugefügt.

================================================

[perfect-code]

Anpassung: 10.03.2006

================================================

- hab noch ein paar Diagramme hinzugefügt.

================================================

[Texas]

Hallo perfect-code,

zunächst mal: Respekt, Respekt!

Die Diagramm Engine habe ich selber programmiert, somit braucht es keine dritt DDLs die ein System unter Umständen dauerhaft zum Abstürzt bringen könnte.

1. Ist deine Diagramm-Engine so allgemein gehalten, dass man sie anderweitig einsetzen könnte?

2. bietet sie auch Features wie 3D-Balken und/oder ähnliches?

3. wäre sie lizenzfrei/zu welchen Kosten/Bedingungen in eigene Programme einsetzbar?

Da mir das VB-Diagrammteil nicht sonderlich zusagt, aber viele Optionen bietet, suche ich da noch immer nach einer guten und fertigen und preiswerten Alternative. Selber programmieren fällt zwar auch in diese Kategorie, ist für meine Zwecke aber nur selten den Aufwand wert.

Gruß

Texas

[perfect-code]

@Texas

Ich lösche jetzt meinen Beitrag, weil es hier langsam unübersichtlich wird. Den Code, den ich hier aus der Diagrammengine gepostet habe, hast Du sicher schon rauskopiert. Ansonsten kannste Dich ruhig mal melden wenn Du was brauchst.

Gruss

bearbeitet März 14, 2006 von perfect-code

[perfect-code]

Fortsetzung (14.03.2006)

Über Diagramoption kann man verschiedene Diagrammauswertungen anschauen.

S_c_r_i_p_t Explorer

Im S_c_r_i_p_t Explorer sind bereits einige Vorprogrammierte Systeme in Form von S_c_r_i_p_ts enthalten. In der Regel wird man aber eigene S_c_r_i_p_te erstellen. Damit die Übersicht erhalten bleibt, kann man verschiedene Ordnerstrukturen aufbauen.

S_c_r_i_p_t Editor

Wie bereits geschrieben, müssen wir unsere Idee dem Computer zuerst einmal beibringen, damit er sie anhand einer Permanenz simulieren kann. Dies hat allein nur den Vorteil, dass der PC eine Simulation in wenigen Sekunden durchgespielt hat. Wir würden bei einer manuellen Auswertung je nach Permanenzgrösse auch einige Stunden brauchen und wären bei weitem nicht sicher, ob unseres System wirklich bei meisten Permanenzen funktioniert oder wir nur das Glück hatten gerade die perfekte Permanenz zu testen!

Das Beibringen des Systems unserem Computer erfolgt zuerst einmal über die Erstellung eines neuen S_c_r_i_p_ts im S_c_r_i_p_t Explorer. Ist ein S_c_r_i_p_t erstellt, so kann man es in neuem S_c_r_i_p_t Editor über ein Doppelklick öffnen. In neuem Fenster (S_c_r_i_p_t Editor) ist ein eingabefenster für die S_c_r_i_p_t programmierung enthalten, so wie ein Listenfeld in dem die Compilermeldungen angezeigt werden, falls wir Programmierfehler bei der S_c_r_i_p_t erstellung gemacht haben. Weiter ist noch die Berechnungsart vorhanden (periodisch und ununterbrochen) sowie Speicher- und Ausführungsknopf.

S_c_r_i_p_t Programmierung

Im Editorfenster kann man über Kontextmenü meiste verfügbare Programmierfunktionen und Befehle aufrufen. Man muss sich also diese unzählige Befehle gar nicht merken, einfach rechte Maustaste und alle werden aufgelistet.

S_c_r_i_p_t Aufbau

Merken wir uns zuerst einmal folgende zwei Sachen:

1. Alles was wir Programmieren bezieht sich immer auf das Listing der Permanenz wo alle Zahlen und Chancen aufgelistet wurden (darum ist es auch erst Permanenzladung möglich ein S_c_r_i_p_t zu öffnen). Wir können also die Werte aus dem Permanenz Listing auslesen oder auch bestimmte Werte auf dem Listing setzen.

2. Wenn wir alle Coups durchlaufen wollen (und das werden wir wohl tun müssen, wenn wir nach bestimmten Regel die Setzungen tätigen wollen), dann muss sich unserer Programmcode immer in der Hauptschleife befinden. Nur in der Hauptschleife werden alle Coups durchlaufen und wir können die Chancen abfragen und nach unseren Regel die Setzungen tätigen.

Die Hauptschleife Struktur muss man nicht unbedingt selber eingeben, man kann sie aus dem Kontextmenü automatisch holen (das gilt für die meiste Befehle, die wir in einem S_c_r_i_p_t brauchen könnten). Also holen wir unsere Hauptschleife und unseres S_c_r_i_p_t wird dann so aussehen:

LOOP

END LOOP

Wenn wir unseres S_c_r_i_p_t straten, dann wird diese Schleife solange durchgelaufen, bis zum letzten Coup. Auf die Zeilen greifen wir über Index zu (das werden wir später genauer sehen). Es kann aber passieren, dass wir auf eine Zeile zugreifen möchten, die es gar nicht existiert, zum Beispiel wenn wir bereits bei dem letzten Coup sind und wollen auf den nächsten Coup setzen! Dann hätten wir einen sogenannten Laufzeitfehler. Um solche zur Laufzeit entstehende Fehler zu vermeiden, sollten wir einen speziellen Konstrukt Namens TRY END TRY verwenden (TRY = VERSUCHEN). Alles was sich innerhalb dieses Konstrukts befindet wird unproblematisch VERSUCHT (TRY) ausgeführt zu werden und wenn es nicht klappt, wird das Programm ohne Laufzeitfehler weiter fortgesetzt. Entsprechend siehet unseres Programm dann so aus:

LOOP
   TRY

   END TRY
END LOOP

Nun wir haben uns bereits gemerkt, dass wir einige Werte (Kolonnen) aus dem Permanenzlisting sowohl auslesen als auch setzen können. Dann versuchen wir es einmal: Wir möchten bei jedem Coup immer auf Schwartz genau 5 Stück setzen. Der Code sieht so aus:

LOOP
   TRY

       Listing.NextNoir = 5
   END TRY
END LOOP

Die Ausgabe im Permanenzlisting dann so:

grosse Ansicht

Als ein wunderschönes Nebeneffekt wird auch unsere Bank ausgerechnet. In unterem Fenster STATISTIK sehen wir auch den Gesamtsaldo, aber zu dem später etwas mehr.

Erläutern wir zuerst einmal die Codezeilen. LOOP und END LOOP kennen wir bereits. Mit diesem Konstrukt können wir alle Coups durchlaufen. Nun Listing.NextNoir ist aber neu. Es setzt sich aus zwei Wörter, die mit einem Punkt getrennt sind. Das erste Wort Listing repräsentiert unseres Permanenzlisting. Man kann sich vorstellen, dass man über das Wort LISTING auf alle Kolonnen einen Zugriff hat (entweder lese oder schreibe Zugriff).

Das zweite Wort NextNoir stellt die rechte Spalte unter der Überschrift NOIR dar. Können wir bereits jetzt eine logische Befehlsfortsetzung erkennen? Natürlich! Versuchen wir es mit LISTING.NEXTROUGE = 10 analog zu vorherigem Beispiel, sollte dieses auch funktionieren, oder? Also ergänzen wir unseren Code und schauen was daraus wird:

LOOP
   TRY

      Listing.NextNoir = 5
      LISTING.NEXTROUGE = 10

   END TRY
END LOOP

Ausgabe:

grosse Ansicht

Das sieht doch gut aus! Wir können also mit dem Konstrukt LISTING.NEXT.... beliebige Spalte setzen. Setzen? Jetzt ist es auch klar warum wir ein NEXT im Konstrukt haben, weil wenn wir an einem Tisch eine Setzung tätigen, dann können wir das nur auf die NAECHSTE (NEXT) Ziehung machen!

Uns fällt auch ein, dass Klein- und Grossschreibung keine Rolle spielen.

Also repetieren wir unsere Erkenntnisse noch einmal:

Mit dem Kostrukt LOOP END LOOP können wir alle Coups aus der geladene Permanenz durchlaufen.

Und mit dem Wort LISTING gefolgt mit einem Punkt haben wir zugriff auf alle Permanenzlisting Spalten (Rot, Schwarz, Gerade, Ungerade usw.) und können diese mit beliebigen Werten setzen, als ob wir am Tisch wären und selber auf Rot, Schwarz, Gerade o.ä. setzen würden. Als netter Nebeneffekt wird unsere Bank automatisch nach jedem Coup berechnet und wir sehen wie sich das Spiel entwickelt hat.

Gehen wir aber einen Schritt weiter. Wir werden wohl kaum bei allen Coups bedingungslos auf eine Chance setzen, oder? Wir werden eher nach unseren bestimmten Regeln (System oder Strategie) eine Setzung tätigen. Also erstellen wir ein kleines und einfaches System gerade für die Chance Schwarz: Wir werden immer dann auf Schwarz setzen, wenn Schwarz gefallen ist. Fällt Rot, dann setzen wir nichts. Über Sinn oder Unsinn dieses Systems müssen wir hier selbstverständlich nicht diskutieren! Wie programmieren wir das? Zuerst einmal brauchen wir unsere Hauptschleife so wie Versuchsblock (TRY...END TRY):

LOOP
   TRY

   END TRY
END LOOP

Jetzt wissen wir, dass mit jedem Durchlauf, Coup für Coup (Zeile für Zeile) abgefragt bzw. gesetzt werden kann. Machen wir das.

LOOP
   TRY
      IF Listing(Coup).Noir <> "" THEN
         Listing.NextNoir = 5
      End If
   END TRY
END LOOP

Und schauen wir noch schnell das Ergebnis an bevor wir näher auf den Code zurück kommen:

grosse Ansicht

Wie man es sehen kann, wenn immer Schwarz gefallen ist, haben wir den nächsten Coup auf Schwarz gesetzt. Wenn Rot gefallen ist, haben wir nichts gesetzt.

Schauen wir uns mal den Code an. Wir haben einen neuen Konstrukt IF...THEN END IF. Es handelt sich ein Standardkonstrukt, dass in jeder Programmiersprache vorhanden ist. In der Umgangssprache nennt man ihn einfach ABFRAGE (IF = Wenn , THEN = Dann). Für Nichtprogrammierer erklären wir dies in ein paar Sätzen:

Mit einer IF Abfrage kann man eine beliebige Bedingung abfragen. Ist sie Wahr, so wird der nachstehende Teil ausgeführt. Es gibt noch verschiedene Finessen bei diesem Konstrukt, aber zu dem kommen wir später.

Mit Listing(Coup).Noir greifen wir auf die linke Spalte unter der Überschrift NOIR im Listing. Die linke Spalte ist die automatische Auswertung der Permanenz und wird bereits beim Einlesen der Permanenz angezeigt. Mit etwas Fantasie können wir uns bereits vorstellen, wie man auf die anderen Spalten zugreifen könnte. Etwa mit Listing(Coup).Rouge würden wir auf die Ausgewertete Chance von ROT zugreifen oder mit Listing(Coup).Colonne3 auf die dritte Kolonne usw.

Der Ausdruck Listing(Coup).Noir <> "" heisst: Auswertungspalte Noir ist UNGLEICH (<> steht für ungleich) LEER ("" steht für Leer).

Ist also aktueller gezogener Coup ungleich leer bzw. ist diese Chance mit einem X gekennzeichnet das heisst ein Schwarz wurde gezogen (IF Listing(Coup).Noir <> "" THEN )

Dann (THEN)

Setze Schwarz mit 5 Stück (Listing.NextNoir = 5)

Das ganze wird dann mit END IF abgeschlossen, damit das Programm weißt bis wohin unsere Abfrage gelten soll.

Fortsetzung folgt

[Monopolis]

Moin perfect-code,

Im richtigen Spiel wird man nach jedem Coup seine Setzungen nach bestimmten Regel oder voraussetzungen tätigen. Damit das Programm unsere Strategie oder System an der Permanenz anwenden kann, um ein spielverlauf zu simulieren, muss es das System oder die Strategie kennen und umsetzen wissen. Dies passiert über ein vorgegebenes S_cript, das man logischerweise selber erstellen muss.

bitte nimm meine Bemerkungen nicht als negative Kritik sondern als Anregungen.

Das Programm soll den sinnvollsten Satz ermitteln und vorgeben.

Vorgegebene S_cripte lassen sich wie Karteikarten ablegen, vom Spieler und / oder Programm situationsbedingt auswählen.

Zur X-Darstellung: Über die Xse als Darstellung kann man nachdenken. Wichtig scheint mir, die Zahlen mit mehreren Nachkommastellen als Wert zu behandeln. Die Nachkommastellen erfassen bestimmte Bedingungen, wie Soll-Ist-Vergleiche, Folgenlängen etc.

MfG., Monopolis.

[perfect-code]

@Monopolis

bitte nimm meine Bemerkungen nicht als negative Kritik sondern als Anregungen.

Jede Bemerkung, jeder Vorschlag oder auch Kritik ist bei mir Willkommen. Nur so kann man sich weiter entwickeln und das gilt auch für meine Software. Also nur weiter so und Danke.

Das Programm soll den sinnvollsten Satz ermitteln und vorgeben.

Hmmm, sehr wahrscheinlich hab ich verpasst den Sinn bzw. das Grundkonzept des Programms besser zu erklären. Also:

Die einzige Aufgabe des Programms ist eigentlich Simulation eines Vorgegebenes Systems oder Strategie!. Die eigentliche Idee oder Voschlag oder Situationsreaktion muss klar von einem Mensch kommen. Das Tool ist wirklich das was es heisst, also WERKZEUG. Werkzeug mit dem man eigenes System oder eigene Strategie gründlich auf Risikoverlust praktisch und automatisch zeitsparend überprüfen kann bevor man den Fehler macht und sein Geld auf dem Tisch verliert. Und die viele Auswertungsmöglichkeiten sollten den Mensch zu neuen Ideen animieren.

Klar kann man das Programm auch in der Richtung erweitern, dass es entsprechende Vorschläge bietet bzw. sinnvollsten Satz ermittelt und vorgibt aber seien wir ehrlich ist das etwas was funktionieren würde?

Und wenn es funktionieren würde, warum würde man so ein Programm verkaufen wollen, wäre es nicht logischer als einziger das Programm für den Monatlichen Verdienst anzuwenden?

PS: Alle Programme die einem einen Spielvorschlag geben können reagieren entweder auf Satzsignale (RULASIS kann das bereits und zwar viel besser als alle andere Programme, weil man beliebige Reihenfolge von Satzsignalen definieren kann, also nicht nur letzte 2-3 Coups folge sondern beliebig viele), oder die Vorschläge basieren auf den Systemen, die bereits hardcodiert im Programm sind. Jetzt kann man sich vorstellen, wie viele Systeme muss man hardcodieren und wie gut diese sein müssen, damit das Programm einigermassen gut aussieht!? Wenn man aber ein System für 500 oder mehrere Tausend Euro verkauft, und auf der andere Seite jemand für ein Programm nur etwa 100 Euro verlang, dann kann man sich gut vorstellen welche hardcodierte Systeme darin enthalten sein könnten! Wenn diese so gut wären, würde er sie blanko verkaufen und sich keine mühe machen 1000de Zeilen von Code zu schreiben, oder?

Wie bereits gesagt, Rulasis bringt keine 'Inteligenz', aber mit dem Tool und deiner eigenen Inteligenz kannst Du beliebig viele Systeme erstellen und austetsen! Und ich denke mit diesem Programm wird man eigene Systeme viel besser verkaufen können, weil man dann nen festen Beweis für die Erfolgreichsquote in der Hand hat.

Vorgegebene S_cripte lassen sich wie Karteikarten ablegen, vom Spieler und / oder Programm situationsbedingt auswählen.

Auch hier schulde ich eine Zusatzerklärung: Das Programm wird man in der ersten Version wohl kaum zur Laufzeitspielen verwenden können (etwa OC o.ä), weil ich im Moment andere Prioritäte gesetzt habe.

Aber ich schliesse es nicht aus in der nächste Version irgendwann später auch das Programm OC fähig zu machen! Dann werden aber die momentane Konzepte etwas erweitert so dass auch dein erster Vorschlag zum teil implementiert werden kann (ich stell mir vor, dass das Tool Erfahrungswerte analysiert und eventuell doch einen oder anderen Vorshclag unverbindlich abgibt, aber auch hier kann man sich über Sinn und Unsinn bzw. Theorie und Praxis einer solchen maschinellen Funktionalität streiten. Ich persönlich würde keiner Maschine die Entscheidung übelassen.).

Mein grosses Problem im Moment ist die Zeit. Weil ich dieses Programm in der jetzigen Verfassung/Version nicht verkaufen werde, macht es für mich finanziell keinen grossen Sinn an dem Programm noch mehr Zeit zu investieren, weil ich dann keine zeit für Projekte hätte, die mir Lebensunterhalt ermöglichen. Das hat den grössten Nachteil, dass ich nur das nötigste programmiere wobei das nötigste stark subjektiv ist weil es klar gesagt leider meine eigene Prioritäte sind.

Zur X-Darstellung: Über die Xse als Darstellung kann man nachdenken. Wichtig scheint mir, die Zahlen mit mehreren Nachkommastellen als Wert zu behandeln. Die Nachkommastellen erfassen bestimmte Bedingungen, wie Soll-Ist-Vergleiche, Folgenlängen etc.

Im Moment hab ich nicht viel Diagramme erstellt. Wenn es soweit ist mit der Diagrammerweiterung, werde ich sicher hier um Hilfe bitten, weil ich leider zu wenig Ahnung von der Auswertungsmaterie habe.

Gruss

[Monopolis]

Guten Morgen, perfect-code,

vielen Dank für Deine ausfühliche Antwort. Leider oder

glücklicherweise ist die Zeit der Faktor, der Dich daran

hindert, Dich vorrangig mit dem RULASIS zu beschäftigen.

Mir fehlt in den nächsten Tagen auch die Zeit für eine

angemessene Antwort, weil ich noch einiges erledigen muß,

bevor es am Sonnabend wieder auf die Insel geht. Dort

habe ich Muße und werde Dir antworten. Bitte habe ein

wenig Geduld.

Freundliche Grüße, Monopolis.