Dieses Forum nutzt Cookies

Logital · 16.09.2011 09:17

Möchte man Deutschland halbwegs im Originalmaßstab mit echten realen Fahrplänen nachbauen müsste man zunächst mal wissen welche Kartengröße anzusetzen ist. Nun ist bekannt, dass es im Spiel ja viele Maßstäbe gibt. Wichtig für einen realistischen Fahrplan wäre, dass die Züge um von einem Bahnhof zum anderen zu kommen die Fahrtzeit haben, die sie auch in der Realität haben. Dann widerum stelt sich zunächst die Frage mit welchen Ticks pro Minute man spielt:

Hierzu ein paar Überlegungen: Eine zu geringe Tickszahl bedeutet dass der Abstand zwischen 2 fahrenden Zügen auf einer Strecke zuviele Spielminute erfordert. Im realen Fernverkehr sind Abstände von bis zu 4 Minuten durchaus üblich. Das dürfte bei geringer Tickszahl schwierig sein zu realisieren.
Eine zu hohe Tickszahl bedeutet die Minute dauert länger, der Zug legt pro Minute mehr Spielfelder zurück. Die Karte muss größer werden um reale Fahrpläne abzubilden. Größere Karten erfordern leistungsfähigere Computer und machen mehr Arbeit.
Ich habe mich für 100 Ticks pro Minute als Kompromiss entschieden.

Nun habe ich 3 Testreihen aufgebaut. Auf einer fast endloslangen geraden Strecke habe ich einen Zug mit exakt 60, 80 und 100 km/h fahren lassen (mit Speedsignals einfach möglich). Der Zug hatte am Beginn der Teststrecke die vorgegebene Geschwindigkeit. Die Uhrzeit wurde notiert und nach einer Stunde laut Spieluhr das Spiel angehalten. Folgende Werte wurden ermittelt:

59 km/h 187 Felder
80 km/h 250 Felder
98 km/h 304 Felder (die Züge fahren nicht exakt die Geschwindigkeit der Speedsignals)

Dies bedeutet dass ein Feld ca 320m darstellen bzw sind 3,1 Felder ca 1km.

Wie groß wäre mit 100 Ticks pro Minute eine Deutschlandkarte?
Deutschland misst 886km von Nord nach Süd und 636km von Ost nach West in den maximalen Ausdehnungen. Umgerechnet macht das 2791 x 2003 Felder. Die ideale Kartengröße wären daher 2048 x 4096 Felder. Dann ist oben auch noch Platz für die Ostsee und unten für die Alpen sowie Österreich und Schweiz. In Ost West Richtung ist nicht viel Luft.

Wieviel Einwohner hätte Berlin?
Berlin misst 45 x 38km oder im Spiel 140 x 118 Felder. Ich habe mal eine so große Landfläche kreiert und darauf Städte ausdehnen lassen, Aber durchaus Freiräume gelassen, denn Berlin ist nicht quadratisch und hat auch ein paar grüne Flecken und Seen. Letztlich betrug die Weltbevölkerung (die auf der Karte nur aus Berlin bestand) ca. 300.000 Einwohner. In der Realität hat Berlin 3,4 Mio Einwohner. Also ungefähr ein Verhältnis von 1:10.

So mit dem Wissen bräuchte man nun "nur"noch eine entsprechende Deutschlandkarte.

Tomcatter · 16.09.2011 19:21

Hallo Logital,

4096x4096 sollten es schon sein. 160 bis 170 Ticks die Minute kommen bei einem
ungefähren Maßstab von 200m pro Feld schon hin. Darfst natürlich nicht die Erdkrümmung
vergessen, sonst wirst Du eine böse Überraschung erleben.

Städte driften ab und es kommt zu Verzerrungen, da man nur eine flache Spielwelt hat und man im Atlas linear abmisst.

Außerdem wird es eine riesen Arbeit sein, die Städte überall zu setzen und die Flüsse zu
ziehen.

Basel passt grad noch, da Sylt fast oben am Kartenrand ist.

An dieser Karte spiele ich grad. Deshalb ist eine 4000er Karte schon in Ordnung. Wenn Du das
Ruhrgebiet "besiedelst", wirst Du schon merken, das ein kleinerer Maßstab schlecht ist.

Hatte vorher auch mal eine 2000er Karte gespielt. Da bekommt man aber keine hohe Taktfrequenz hin.

Oder Du versuchst 250m pro Feld. Das Ruhrgebiet wird es Dir danken.

MfG Tomcatter

Eddi · 16.09.2011 19:25

Die Erdkrümmung is dein Problem? Nedu, allein schon die nichteuklidische Behandlung von diagonalen Gleisen ist ein Problem, die dir so ziemlich alle Maßstäbe kaputt macht.

Sallarsahr · 16.09.2011 19:52

und dann 250m ein Feld? In Wirklichkeit ist ein 2 Spurige Strecke "nur" 13,5m breit...tolle Rellation 500m für ne 2 Spurige Strecke.....(nur so nebenbei großes Grinsen

)

Eddi · 16.09.2011 20:01

oh, ich hatte mal ein kleines Skript geschrieben, das mir spherische Koordinaten in Spielkoordinaten umrechnet. Falls da Bedarf besteht, kann ich das mal raussuchen.

Logital · 17.09.2011 13:26

Ja, da hätte ich durchaus Bedarf.

Eddi · 17.09.2011 16:12

Na dann ungefähr so: (eigene Daten am Anfang eintragen, dann mit "python spher.py" auf der Kommandozeile ausführen)

Code:

#!/usr/bin/python2

# encoding: utf8

# hier Kartengröße eintragen

map_x = 2048

map_y = 2048

# hier interessante Punkte eintragen

l1 = {

'm0': (60,13), #obere Ecke

'm2': (51,29), #rechte Ecke

'm1': (50,-1), #linke Ecke

'O20-': map(lambda x: (x,20), xrange(45,58)), # Meridian 20° ö.L. in 1er Schritten zwischen 45° n.B. und 58° n.B.

'Stockholm' : (59.331789, 18.066416), # einzelne Koordinaten (z.B. Städte)

'Paris'     : (48.839413,  2.38266 ),

'München'   : (48.10468 , 11.56929 ),

'Hamburg'   : (53.541123,  9.989319),

'Zufallspunkte': [(52,12),(51,11),(50,10)], # Liste von Koordinaten (z.B. Flußverlauf)

}

from math import sin, cos, pi, atan, atan2, sqrt

deg=pi/180

r=6371

class Kart:

    x=0

    y=0

    z=0

    def __init__(self, x,y,z):

        self.x=x

        self.y=y

        self.z=z

    @classmethod

    def fromSpher(cls, *args):

        if len(args)==1:

            r=args[0].r

            a=args[0].a

            m=args[0].m

        else:

            r=args[0]

            a=args[1]

            m=args[2]

        return cls(

            r*cos(m*deg)*cos(a*deg),

            r*cos(m*deg)*sin(a*deg),

            r*sin(m*deg))

    def __str__(self):

        return '{x: '+str(self.x)+', y: '+str(self.y)+', z: '+str(self.z)+'}'

    def __repr__(self):

        return self.__class__.__name__+'('+str(self.x)+','+str(self.y)+','+str(self.z)+')'

    def __add__(self, other):

        return Kart(self.x+other.x, self.y+other.y, self.z+other.z)

    def __sub__(self, other):

        return Kart(self.x-other.x, self.y-other.y, self.z-other.z)

    def __mul__(self, other):

        if isinstance(other, Kart):

            "Kreuzprodukt"

            return Kart(self.y*other.z-self.z*other.y, self.z*other.x-self.x*other.z, self.x*other.y-self.y*other.x)

        else:

            return Kart(self.x*other, self.y*other, self.z*other)

    def __div__(self, other):

        return Kart(self.x/other, self.y/other, self.z/other)

class Spher:

    r=0

    a=0

    m=0

    def __init__(self, x,y,z):

        self.r=x

        self.m=y

        self.a=z

    @classmethod

    def fromKart(cls, *args):

        if len(args)==1:

            x=args[0].x

            y=args[0].y

            z=args[0].z

        else:

            x=args[0]

            y=args[1]

            z=args[2]

        return cls(

            sqrt(x*x+y*y+z*z),

            atan2(y,x)/deg,

            atan(z/sqrt(x*x+y*y))/deg)

    def __str__(self):

        return '{r: '+str(self.r)+', a: '+str(self.a)+'°, m: '+str(self.m)+'°}'

    def __repr__(self):

        return self.__class__.__name__+'('+str(self.r)+','+str(self.a)+','+str(self.m)+')'

def dist(x, y):

    if isinstance(x, Spher):

        x=Kart.fromSpher(x)

    if isinstance(y, Spher):

        y=Kart.fromSpher(y)

    d=y-x

    return sqrt(d.x*d.x + d.y*d.y + d.z*d.z)

def det(M):

    return (+M[0][0]*M[1][1]*M[2][2]

        +M[0][1]*M[1][2]*M[2][0]

        +M[0][2]*M[1][0]*M[2][1]

        -M[0][2]*M[1][1]*M[2][0]

        -M[0][1]*M[1][0]*M[2][2]

        -M[0][0]*M[1][2]*M[2][1])

def LGS(x,y,z,p):

    A=[[x.x, y.x, z.x],[x.y,y.y,z.y],[x.z,y.z,z.z]]

    A1=[[p.x, y.x, z.x],[p.y,y.y,z.y],[p.z,y.z,z.z]]

    A2=[[x.x, p.x, z.x],[x.y,p.y,z.y],[x.z,p.z,z.z]]

    A3=[[x.x, y.x, p.x],[x.y,y.y,p.y],[x.z,y.z,p.z]]

    a=det(A)

    return det(A1)/a, det(A2)/a, det(A3)/a

class Map:

    o=Kart(0,0,0)

    x=Kart(1,0,0)

    y=Kart(0,1,0)

    z=Kart(0,0,1)

    xscale=1

    yscale=1

    def __init__(self, *args):

        points=[]

        for p in args[0:3]:

            if isinstance(p, Spher):

                p = Kart.fromSpher(p)

            points.append(p)

        self.o=points[0]

        self.x=points[1]-self.o

        self.y=points[2]-self.o

        self.z=self.x*self.y

        if len(args)>3:

            self.xscale=args[3]

            self.yscale=args[3]

        if len(args)>4:

            self.yscale=args[4]

        self.x*=self.xscale

        self.y*=self.yscale

        self.z*=self.xscale*self.yscale

    def check(self, p):

        if isinstance(p, Spher):

            p=Kart.fromSpher(p)

        return LGS(self.x, self.y, self.z, p-self.o)

    def checkall(self, l):

        m=[]

        for n,p in l.iteritems():

            m.append((n, self.check(p)))

        #m.sort(key=lambda (a,b): b[0]*b[0]+b[1]*b[1])

        m.sort(key=lambda (a,b): a)

        x=[]

        for n,p in m:

            if p[0]>0 and p[0]<1/self.xscale and p[1]>0 and p[1]<1/self.yscale:

                print n, '%dx%d, %s'%(lambda (x,y,z): (int(round(x)),int(round(y)),hex(int(1/self.xscale*round(y)+round(x)))))(p)

            else:

                x.append((n,p))

        print '--------- Außerhalb der Karte: ---------'

        for n,p in x:

            print n, '%dx%d, %s'%(lambda (x,y,z): (int(round(x)),int(round(y)),hex(int(1/self.xscale*round(y)+round(x)))))(p)

    def get(self, *args):

        if isinstance(args[0], Spher):

            p=Kart.fromSpher(args[0])

        elif isinstance(args[0], Kart):

            p=args[0]

        else:

            p=Kart(*args)

        return self.o + self.x*p.x + self.y*p.y + self.z*p.z

l={}

for n,p in l1.iteritems():

    if isinstance(p, list):

        for i, q in enumerate(p):

            l[n+str(i)]=Spher(r,q[0], q[1])

    else:

        l[n]=Spher(r,p[0], p[1])

m1=Map(l['m0'],l['m1'],l['m2'],1./map_x,1./map_y)

m1.checkall(l)

lx= dist(l['m0'],l['m1'])

ly= dist(l['m0'],l['m2'])

print

print 'len_x=',lx

print 'len_y=',ly

print 'ratio=',lx*m1.xscale/(ly*m1.yscale)

Getestet mit Python 2.7, keinerlei Garantien.

T1000 · 18.09.2011 13:17

(16.09.2011 19:21)Tomcatter schrieb: 4096x4096 sollten es schon sein.

Geht das überhaubt bei OpenTTD ??
Ich dachte es sind nur 2048*2048 möglich?

Logital · 18.09.2011 13:22

Mit Chills Patch Pack sind die Begrenzungen eher durch den eigenwn Computer vorgegeben.

@Eddi

Was genau macht man jetzt mit diesem Code?

T1000 · 18.09.2011 13:33

Wo bekommt man das Chills Patch Pack her??

**Yoshi** · 18.09.2011 13:38

Hier:
Thread im englischen Forum

T1000 · 18.09.2011 13:44

Danke dir

Eine Deutschlandkarte würde mich auch sehr Interessieren.
Hat noch keiner so ein Szenario gemacht?

Hmm Bin zu doof dafür Traurig

Habe mir r22553-chipp-v13.5-win32.rar
runter geladen.
abeim starten kommt ein Error
Failed to find a graphics set. Please acquire a graphics set for openTTD. See section 4.1 of readme.text

**Yoshi** · 18.09.2011 14:00

Doch, Myfineshrine hat eine Deutschland und Mitteleuropakarte gemacht... die gibts hier und auf der Bananenplantage...

Eddi · 18.09.2011 14:22

(18.09.2011 13:22)Logital schrieb: @Eddi

Was genau macht man jetzt mit diesem Code?

Python 2.x (nicht 3.x) runterladen, und von der Kommandozeile aus das Skript ausführen.

SVW-Gigant · 18.09.2011 15:44

Hmmm, also ich hatte eig. keine Probleme in meiner Karte, auf 512x512 Feldern (= km) maßstabsgerecht zu bauen. Was die Erdkrümung angeht, wird es erst annährend problematisch, wenn man die Arabische Haldinsel, Australien oder Indien nachbauen will (so dass es sich eher lohnen würde, auf die Mercator-Ebene zu gehen). Deutschland ist ja ein sehr kleines Flächenland...

Aber auch da rechnet man nach Auslesen aus Microdem die Felder aus und macht das Quadrat draus, indem man den Rest abschneidet...

Logital · 18.09.2011 18:52

Also die Dinge an sich können ja nicht maßstabsgerecht zu einander sein. Und ohne Uhrzeit wüsste ich gar nicht woran ich überhaupt einen Maßstab festmachen könnte. Doch mir geht es ja nur dass zwischen den deutschen Städten realistische Fahrtzeiten entstehen und dann ändert sich natürlich der Maßstab relativ zur Anzahl der Ticks, die eine Minute darstellen.

Gibt es eigentlich eine Möglichkeit die Norddeutschlandkarte hochzuskalieren ohne dass dabei die Flüsse rausfliegen?

Eddi · 18.09.2011 21:51

(18.09.2011 18:52)Logital schrieb: Gibt es eigentlich eine Möglichkeit die Norddeutschlandkarte hochzuskalieren ohne dass dabei die Flüsse rausfliegen?

Nein.

godsprototype · 19.09.2011 10:51

(18.09.2011 13:17)T1000 schrieb:
(16.09.2011 19:21)Tomcatter schrieb: 4096x4096 sollten es schon sein.

Geht das überhaubt bei OpenTTD ??
Ich dachte es sind nur 2048*2048 möglich?

Wenn man Chills Patchpack nicht benutzen will.
http://www.tt-forums.net/viewtopic.php?f...2ca0f33441

T1000 · 19.09.2011 20:20

(19.09.2011 10:51)godsprototype schrieb:
(18.09.2011 13:17)T1000 schrieb:
(16.09.2011 19:21)Tomcatter schrieb: 4096x4096 sollten es schon sein.

Geht das überhaubt bei OpenTTD ??
Ich dachte es sind nur 2048*2048 möglich?

Wenn man Chills Patchpack nicht benutzen will.
http://www.tt-forums.net/viewtopic.php?f...2ca0f33441

Ja wo mus ich die Datei hin kopieren oder was muss ich machen?
Kenne mich mit Pc nicht so aus Traurig

Hauptsache es läuft irgendwas.

Logital · 25.11.2011 12:25

Habe noch mal dieses Thema rausgeholt: Ich habe eine Exceltabelle entwickelt mit der man sehr leicht die die OTTD-Koordinaten ermitteln kann, die zu einem Bahnhof gehören.

Das funktioniert so:

Gelbe Felder: Einmalig vor Spielbeginn was eintragen.
Rote Felder: Nie was eintragen!
Weiße Felder: Werte je Bahnhof eingeben.
Grüne Felder: Nichts eintragen, nur ablesen!

Vorbereitung:

1. Schritt: Eingabe der Ticksanzahl (soviele Ticks sind eine Minute)
Hierzu sollte man sich folgende Gedanken machen: Welche Art von Verkehr will ich abbilden? Für Stadtverkehrsnetze empfehle ich 255 Ticks, mehr geht leider nicht. 700 wäre sehr praktisch, ein Feld wäre ca 46 Meter lang und die Planquadratlänge würde zum Maßstab der Fahrzeuggrafiken passen. Für Fernverkehrsnetze empfehle ich 130 Ticks, dann hat ein Feld 130m Länge.
Also die Zahl der Ticks einstellen. Man erhält nun die Ausgabe wieviele Meter ein Planquadrat darstellt. Nun muss man die Maße des Raumes kennen den man abbilden will und kann die Werte für die Kartengröße einstellen.

2. Schritt: Eingabe der Längengrade:
Da je nach Punkt auf der Erde der 1° Längengradunterschied eine andere ENtfernung hat sollte man den schon wissen. Wenn man beispielsweise das Netz in Norwegen nachbauen will ist das ein ganz anderer Wert als wenn man das spanische Netz nachbauen will. In Deutschland liegt er zwischen 63,8 km (Flensburg, Sylt) und 75,5 km (Oberstdorf). In der Tabelle sind 67km, der Wert für Berlin, voreingetragen.

3. Schritt: Eingabe einer Referenzkoordinate vn OpenTTD
Hier als Voreinstellung: 500x500.

4. Schitt: Eingabe Breiten- und Längengrade eines Referenzbahnhofs
Welcher Punkt (idealerweise ein Bahnhof) des nachzubildenden Netzes soll an der Referenzkoordinate liegen. Wer Deutschland nachbaut wählt sich idealerweise den Bahnhof Kassel Wilhelmshöhe, sucht (z. Bsp. mit Google Eahrth) die Koordinaten des Bahnhofs raus und trägt sie dort ein.

5. Nun will man relativ zum Referenzbahnhof einen weiteren Bahnhof bauen.
Also zum Beispiel vom Bahnhof Göttingen die Koordinaten raussuchen und in der Spalte Zielhaltestelle eintragen. Ganz am Ende im grünen Feld stehen nun die Koordinaten in OTTD des Bahnhofs Göttingen.

Viel Spaß dabei!

Möglicherweise verwandte Themen...
Thema:		Verfasser	Antworten:	Ansichten:	Letzter Beitrag
	Einige Gedanken zu Passangerreduktion und Daylength	Logital	12	5.215	24.10.2010 19:44 Letzter Beitrag: Logital
	Allgemeine Gedanken zu Wettkampfspielen	Logital	11	4.914	28.08.2009 07:50 Letzter Beitrag: planetmaker

Baumstrukturmodus \| Linearer Modus Gedanken zum Maßstab
Verfasser	Nachricht