Number Of Berth

[corne_mo]

I see now they are editable indeed. Never really got to the source of this ply format though. Thought is was something from RDK and not a generic file type.
Is there a (free) program that can transfer the ply file into a graphic file and vice versa?

I've once did a try to create a 2D port together with RDK. I drawn it in AutoCad, converted to a CorelDraw drawing and RDK converted it into a ply file combining it with the necessary secondary info. It was a bunch of work and never really got a good result (although the current Antwerp ports looks a lot like mine from back then).
_________________
Freight Containers In The Port Of Antwerp

[rdklein]

yes major problem was if you have a lot polylines (several thousand), things get very slow in the pocxxl engine (also the 3d engine doesnt like this),

I have a converter which I need to polish up then you can also use this for importing AI files and convert to PLY (and mel but thats another thing for the 3d).

[StickyMonk]

I am still very interested in being able to do my own 2d ports, I am VERY bored of doing the same map for 300 or so ports in my game!
_________________
Cheers
Matthew

for my ships,cargo and harbors don't visit my web site as they are not there anymore

[Zootier]

Same here
_________________
Visit http://www.pocshipyard.de for free ships and harbours

[rdklein]

yes we work on this now.

[Guest]

-- post deleted --

[rdklein]

Hi,
yes the source code of our reader program hope this helps, but this was the fastes to get a documentation of all:
The training harbour contains all sorts of polys

********************************************
* (C) 2002-2008 Rolf-Dieter Klein Munch GERMANY
********************************************

Sub read_polyhafen(fname As String)
Dim fn As Integer
Dim calx1 As Double
Dim caly1 As Double
Dim calx2 As Double
Dim caly2 As Double
Dim dx As Double
Dim dy As Double
Rem
Dim phi As Double
Rem
Dim x1 As Double
Dim y1 As Double
Dim x2 As Double
Dim y2 As Double
Dim cnt As Integer
Dim i As Integer
Dim j As Integer
Rem
Dim cmd As String
Dim Rev As String
Rem calibrierung
Rem
Dim callen As Double
Dim calmul As Double
Rem
Dim flg As Integer
Dim anfptr As Long
Dim berthtype As String
Dim tiefe As Double
Dim laenge As Double
Dim breite As Double
Dim art1 As Long
Rem
Dim xs As Double
Dim ys As Double
Dim norm1 As Double
Dim vx As Double
Dim vy As Double
Rem
Dim mptr As Long
Dim Rev1 As Long
Rem
On Error Resume Next
Rem auch wenn hafen nicht da...
g_ara1cnt = 0
g_ara2cnt = 0
g_ara2pcntcnt = 0 ' fuer multipolygons
glob_berthcnt = 0
glob_roadcnt = 0
glob_lock_cnt = 0
glob_railcnt = 0 ' r 20040702
Rem
Call sea_tobject_release ' falls alter counter noch da
Rem
glob_mpath_cnt = 0
glob_mpath_ptr_cnt = 0
glob_bridgecnt = 0
glob_assets_data_cnt = 0
Rem
glob_ctpath_ptr_cnt = 0
glob_ctpath_cnt = 0
Rem *****************************************
fn = FreeFile
Open fname For Input As #fn
If Err = 0 Then
flg = False
Rem
Line Input #fn, Rev ' revision
Do
Line Input #fn, cmd
If cmd = "calibration" Then
Rem
Input #fn, calx1, caly1
Input #fn, calx2, caly2
Rem
ElseIf Left$(cmd, Len("poly")) = "poly" Then
If cmd <> "poly" Then
art1 = Val(Right$(cmd, Len(cmd) - Len("poly ")))
Else
art1 = 1
End If
Rem non oder 1 =std 2= hafenohne 3=gruen 4=wassersperrgebiet
Input #fn, cnt ' Point count der x,y paare
anfptr = g_ara2cnt ' zeigt auf start
Rem
For i = 1 To cnt
Input #fn, x1, y1
Rem einlesen
t_ara2x(g_ara2cnt) = x1
t_ara2y(g_ara2cnt) = -y1
g_ara2cnt = g_ara2cnt + 1
Rem
Next i
Rem polygon ende erreicht
Rem
Rem 1=hafen 2=hafenohnerad 3=wiese 4=wasseruntiefen. 11=ice 12=reef
Rem
g_ara2ptrptr(g_ara2pcntcnt).ara2pointerxy = anfptr ' NEU index einfach zu handeln
g_ara2ptrptr(g_ara2pcntcnt).ara2ppolyart = art1
g_ara2ptrptr(g_ara2pcntcnt).ara2pcounters = g_ara2cnt - anfptr ' anzahl der punkte im polygon.
g_ara2pcntcnt = g_ara2pcntcnt + 1
Rem
ElseIf cmd = "berth" Then ' ****** SPATER AUCH NORMIEREN::::: getrenntes feld !!!!
Rem
Input #fn, x1, y1
Input #fn, x2, y2
Rem
Line Input #fn, berthtype '
Input #fn, laenge
Input #fn, tiefe
Rem
Rem
glob_berth(glob_berthcnt).x1 = x1
glob_berth(glob_berthcnt).y1 = -y1
glob_berth(glob_berthcnt).x2 = x2
glob_berth(glob_berthcnt).y2 = -y2
glob_berth(glob_berthcnt).art1 = berthtype
glob_berth(glob_berthcnt).Length = laenge
glob_berth(glob_berthcnt).depth = tiefe
Rem
glob_berthcnt = glob_berthcnt + 1
Rem
ElseIf cmd = "road" Then
Rem
Input #fn, x1, y1
Input #fn, x2, y2
glob_road(glob_roadcnt).x1 = x1
glob_road(glob_roadcnt).y1 = -y1
glob_road(glob_roadcnt).x2 = x2
glob_road(glob_roadcnt).y2 = -y2
glob_roadcnt = glob_roadcnt + 1
Rem
ElseIf cmd = "bridge" Then ' bruecke legen !!!
Rem
Input #fn, x1, y1
Input #fn, x2, y2
glob_bridge(glob_bridgecnt).x1 = x1
glob_bridge(glob_bridgecnt).y1 = -y1
glob_bridge(glob_bridgecnt).x2 = x2
glob_bridge(glob_bridgecnt).y2 = -y2
Rem
glob_bridgecnt = glob_bridgecnt + 1
Rem ************* ref 2004 *************************+++
ElseIf cmd = "ice 1" Then ' EIS Flaechen legen !!!
art1 = 11
Rem non oder 1 =std 2= hafenohne 3=gruen 4=wassersperrgebiet
Input #fn, cnt ' Point count der x,y paare
anfptr = g_ara2cnt ' zeigt auf start
For i = 1 To cnt
Input #fn, x1, y1
Rem einlesen
t_ara2x(g_ara2cnt) = x1
t_ara2y(g_ara2cnt) = -y1
g_ara2cnt = g_ara2cnt + 1
Rem
Next i
Rem polygon ende erreicht
Rem
Rem 1=hafen 2=hafenohnerad 3=wiese 4=wasseruntiefen. 11=ice 12=reef
Rem
g_ara2ptrptr(g_ara2pcntcnt).ara2pointerxy = anfptr ' NEU index einfach zu handeln
g_ara2ptrptr(g_ara2pcntcnt).ara2ppolyart = art1
g_ara2ptrptr(g_ara2pcntcnt).ara2pcounters = g_ara2cnt - anfptr ' anzahl der punkte im polygon..
g_ara2pcntcnt = g_ara2pcntcnt + 1
Rem
ElseIf cmd = "sand 1" Then ' SAND STrand setzen, r 20070501 !!
art1 = 22 ' r 20070501 sand
Rem non oder 1 =std 2= hafenohne 3=gruen 4=wassersperrgebiet
Input #fn, cnt ' Point count der x,y paare
anfptr = g_ara2cnt ' zeigt auf start
For i = 1 To cnt
Input #fn, x1, y1
Rem einlesen
t_ara2x(g_ara2cnt) = x1
t_ara2y(g_ara2cnt) = -y1
g_ara2cnt = g_ara2cnt + 1
Rem
Next i
Rem polygon ende erreicht
Rem
Rem 1=hafen 2=hafenohnerad 3=wiese 4=wasseruntiefen. 11=ice 12=reef
Rem
g_ara2ptrptr(g_ara2pcntcnt).ara2pointerxy = anfptr ' NEU index einfach zu handeln
g_ara2ptrptr(g_ara2pcntcnt).ara2ppolyart = art1
g_ara2ptrptr(g_ara2pcntcnt).ara2pcounters = g_ara2cnt - anfptr ' anzahl der punkte im polygon..
g_ara2pcntcnt = g_ara2pcntcnt + 1
Rem
ElseIf cmd = "reef 1" Then ' RIFFE legen !!!
art1 = 12
Rem non oder 1 =std 2= hafenohne 3=gruen 4=wassersperrgebiet
Input #fn, cnt ' Point count der x,y paare
anfptr = g_ara2cnt ' zeigt auf start
For i = 1 To cnt
Input #fn, x1, y1
Rem einlesen
t_ara2x(g_ara2cnt) = x1
t_ara2y(g_ara2cnt) = -y1
g_ara2cnt = g_ara2cnt + 1
Rem
Next i
Rem polygon ende erreicht
Rem
Rem 1=hafen 2=hafenohnerad 3=wiese 4=wasseruntiefen. 11=ice 12=reef
Rem
g_ara2ptrptr(g_ara2pcntcnt).ara2pointerxy = anfptr ' NEU index einfach zu handeln
g_ara2ptrptr(g_ara2pcntcnt).ara2ppolyart = art1
g_ara2ptrptr(g_ara2pcntcnt).ara2pcounters = g_ara2cnt - anfptr ' anzahl der punkte im polygon.
g_ara2pcntcnt = g_ara2pcntcnt + 1
Rem
Rem
Rem ************************ spaeter in eigene array, das auch drübergezeichnet wird
Rem wegen kollision und reihenfolge guenstiger...
Rem
ElseIf cmd = "haeuser 1" Then ' HAEUSER Feld per textur
art1 = 21
Rem non oder 1 =std 2= hafenohne 3=gruen 4=wassersperrgebiet
Input #fn, cnt ' Point count der x,y paare
anfptr = g_ara2cnt ' zeigt auf start
For i = 1 To cnt
Input #fn, x1, y1
Rem einlesen
t_ara2x(g_ara2cnt) = x1
t_ara2y(g_ara2cnt) = -y1
g_ara2cnt = g_ara2cnt + 1
Rem
Next i
Rem polygon ende erreicht
Rem
Rem 1=hafen 2=hafenohnerad 3=wiese 4=wasseruntiefen. 11=ice 12=reef
Rem
g_ara2ptrptr(g_ara2pcntcnt).ara2pointerxy = anfptr ' NEU index einfach zu handeln
g_ara2ptrptr(g_ara2pcntcnt).ara2ppolyart = art1
g_ara2ptrptr(g_ara2pcntcnt).ara2pcounters = g_ara2cnt - anfptr ' anzahl der punkte im polygon.
g_ara2pcntcnt = g_ara2pcntcnt + 1
Rem
Rem
Rem ************************ spaeter in eigene array, das auch drübergezeichnet wird
Rem wegen kollision und reihenfolge guenstiger...
ElseIf cmd = "uwass 1" Then ' Unterwasser schleusenbereich anlegen !!!
art1 = 20
Rem non oder 1 =std 2= hafenohne 3=gruen 4=wassersperrgebiet
Input #fn, cnt ' Point count der x,y paare
anfptr = g_ara2cnt ' zeigt auf start
For i = 1 To cnt
Input #fn, x1, y1
Rem einlesen
t_ara2x(g_ara2cnt) = x1
t_ara2y(g_ara2cnt) = -y1
g_ara2cnt = g_ara2cnt + 1
Rem
Next i
Rem polygon ende erreicht
Rem
Rem 1=hafen 2=hafenohnerad 3=wiese 4=wasseruntiefen. 11=ice 12=reef
Rem
g_ara2ptrptr(g_ara2pcntcnt).ara2pointerxy = anfptr ' NEU index einfach zu handeln
g_ara2ptrptr(g_ara2pcntcnt).ara2ppolyart = art1
g_ara2ptrptr(g_ara2pcntcnt).ara2pcounters = g_ara2cnt - anfptr ' anzahl der punkte im polygon.
g_ara2pcntcnt = g_ara2pcntcnt + 1
Rem
Rem
Rem ************************ spaeter in eigene array, das auch drübergezeichnet wird
Rem wegen kollision und reihenfolge guenstiger...
Rem
ElseIf cmd = "darken 1" Then ' ABDUNKELN - keine kollision objects
art1 = 13
Rem non oder 1 =std 2= hafenohne 3=gruen 4=wassersperrgebiet
Input #fn, cnt ' Point count der x,y paare
anfptr = g_ara2cnt ' zeigt auf start
For i = 1 To cnt
Input #fn, x1, y1
Rem einlesen
t_ara2x(g_ara2cnt) = x1
t_ara2y(g_ara2cnt) = -y1
g_ara2cnt = g_ara2cnt + 1
Rem
Next i
Rem polygon ende erreicht
Rem
Rem 1=hafen 2=hafenohnerad 3=wiese 4=wasseruntiefen. 11=ice 12=reef
Rem
g_ara2ptrptr(g_ara2pcntcnt).ara2pointerxy = anfptr ' NEU index einfach zu handeln
g_ara2ptrptr(g_ara2pcntcnt).ara2ppolyart = art1
g_ara2ptrptr(g_ara2pcntcnt).ara2pcounters = g_ara2cnt - anfptr ' anzahl der punkte im polygon.

g_ara2pcntcnt = g_ara2pcntcnt + 1
ElseIf cmd = "darken 2" Then ' ABDUNKELN - keine kollision objects ICE
art1 = 15
Rem non oder 1 =std 2= hafenohne 3=gruen 4=wassersperrgebiet
Input #fn, cnt ' Point count der x,y paare
anfptr = g_ara2cnt ' zeigt auf start
For i = 1 To cnt
Input #fn, x1, y1
Rem einlesen
t_ara2x(g_ara2cnt) = x1
t_ara2y(g_ara2cnt) = -y1
g_ara2cnt = g_ara2cnt + 1
Rem
Next i
Rem polygon ende erreicht
Rem
Rem 1=hafen 2=hafenohnerad 3=wiese 4=wasseruntiefen. 11=ice 12=reef
Rem
g_ara2ptrptr(g_ara2pcntcnt).ara2pointerxy = anfptr ' NEU index einfach zu handeln
g_ara2ptrptr(g_ara2pcntcnt).ara2ppolyart = art1
g_ara2ptrptr(g_ara2pcntcnt).ara2pcounters = g_ara2cnt - anfptr ' anzahl der punkte im polygon.
g_ara2pcntcnt = g_ara2pcntcnt + 1
ElseIf cmd = "lighten 1" Then ' AUFHELLEN -- keine kollision objects
art1 = 14
Rem non oder 1 =std 2= hafenohne 3=gruen 4=wassersperrgebiet
Input #fn, cnt ' Point count der x,y paare
anfptr = g_ara2cnt ' zeigt auf start
For i = 1 To cnt
Input #fn, x1, y1
Rem einlesen
t_ara2x(g_ara2cnt) = x1
t_ara2y(g_ara2cnt) = -y1
g_ara2cnt = g_ara2cnt + 1
Rem
Next i
Rem polygon ende erreicht
Rem
Rem 1=hafen 2=hafenohnerad 3=wiese 4=wasseruntiefen. 11=ice 12=reef
Rem
g_ara2ptrptr(g_ara2pcntcnt).ara2pointerxy = anfptr ' NEU index einfach zu handeln
g_ara2ptrptr(g_ara2pcntcnt).ara2ppolyart = art1
g_ara2ptrptr(g_ara2pcntcnt).ara2pcounters = g_ara2cnt - anfptr ' anzahl der punkte im polygon.
g_ara2pcntcnt = g_ara2pcntcnt + 1
Rem
ElseIf cmd = "rail 1" Then ' RAIL eigener bereich schienen legen
art1 = 16
Rem non oder 1 =std 2= hafenohne 3=gruen 4=wassersperrgebiet

Input #fn, cnt ' Point count der x,y paare ' damit linienzug
Rem

glob_rail(glob_railcnt).stflg = 1
glob_rail(glob_railcnt).rcnt = cnt ' counter poly
Rem
For i = 1 To cnt
Input #fn, x1, y1
glob_rail(glob_railcnt).x1 = x1
glob_rail(glob_railcnt).y1 = -y1 ' achtung gespiegelt...
glob_railcnt = glob_railcnt + 1
glob_rail(glob_railcnt).stflg = 0 ' next annehmen 0 zunaechst
glob_rail(glob_railcnt).rcnt = 0 ' savety
Rem
Next i
Rem
ElseIf cmd = "path 1" Then ' RAIL eigener bereich schienen legen
Dim faehrenname As String
Dim speed As Double
Dim loopflg As Integer
Dim overflg As Integer
Dim wartedefault As Double
Dim multiple As Long
Rem
art1 = 17
Input #fn, cnt ' Point count der x,y paare ' damit linienzug
mptr = glob_mpath_cnt ' merken fuer index
For i = 1 To cnt
Input #fn, x1, y1
Rem AB
glob_mpath(glob_mpath_cnt).x1 = x1
glob_mpath(glob_mpath_cnt).y1 = -y1
glob_mpath(glob_mpath_cnt).len1 = 0 ' spaeter
Rem laenge später ausrechnen.
glob_mpath_cnt = glob_mpath_cnt + 1
Next i
Rem
Line Input #fn, faehrenname
Input #fn, Rev1 ' 102 etc. fuer spaeter revs,
Input #fn, speed
Input #fn, loopflg
Input #fn, overflg
Input #fn, wartedefault
Input #fn, multiple
Rem
glob_mpath_ptr(glob_mpath_ptr_cnt).mindex = mptr ' index pointer
glob_mpath_ptr(glob_mpath_ptr_cnt).cnt = cnt
glob_mpath_ptr(glob_mpath_ptr_cnt).currentpos = 0
glob_mpath_ptr(glob_mpath_ptr_cnt).faehrenname = faehrenname
glob_mpath_ptr(glob_mpath_ptr_cnt).lentotal = 0 ' noch berechnen
glob_mpath_ptr(glob_mpath_ptr_cnt).loopflg = loopflg
glob_mpath_ptr(glob_mpath_ptr_cnt).overflg = overflg
glob_mpath_ptr(glob_mpath_ptr_cnt).speed = speed
glob_mpath_ptr(glob_mpath_ptr_cnt).direction = 0
glob_mpath_ptr(glob_mpath_ptr_cnt).wartedefault = wartedefault
glob_mpath_ptr(glob_mpath_ptr_cnt).multiple = multiple
Rem
Dim xres As Integer
Dim yres As Integer
Rem
glob_mpath_ptr(glob_mpath_ptr_cnt).object_hdib = get_gdib("harbors\sim2d\ships\" + faehrenname + ".png", xres, yres)
glob_mpath_ptr(glob_mpath_ptr_cnt).object_m_hdib = get_gdib_checkres("harbors\sim2d\ships\" + faehrenname + "_m.png", xres, yres)
' SUCHEN in USERADDONS ???
If glob_mpath_ptr(glob_mpath_ptr_cnt).object_hdib = 0 Then
Rem dann dort suchen:
glob_mpath_ptr(glob_mpath_ptr_cnt).object_hdib = get_gdib("harbors\sim2d\tships\" + faehrenname + ".png", xres, yres)
glob_mpath_ptr(glob_mpath_ptr_cnt).object_m_hdib = get_gdib_checkres("harbors\sim2d\tships\" + faehrenname + "_m.png", xres, yres)
' SUCHEN in USERADDONS ???
' später bei faehren ?!
If glob_mpath_ptr(glob_mpath_ptr_cnt).object_hdib = 0 Then ' user faehren
glob_mpath_ptr(glob_mpath_ptr_cnt).object_hdib = get_gdib("user_addons\ships\topview\" + faehrenname + ".png", xres, yres)
glob_mpath_ptr(glob_mpath_ptr_cnt).object_m_hdib = get_gdib_checkres("user_addons\ships\topview\" + faehrenname + "_m.png", xres, yres)
End If
Rem
End If
Rem
glob_mpath_ptr(glob_mpath_ptr_cnt).xres = xres
glob_mpath_ptr(glob_mpath_ptr_cnt).yres = yres
Rem
glob_mpath_ptr(glob_mpath_ptr_cnt).wartezeit = wartedefault * Rnd ' in 1..10 sec losfahren
Rem
glob_mpath_ptr_cnt = glob_mpath_ptr_cnt + 1
Rem
ElseIf cmd = "container 1" Then
Rem container single or multipolyline entlang auffuellen...
Input #fn, cnt ' Point count der x,y paare ' damit linienzug
Rem
mptr = glob_ctpath_cnt ' merken fuer inde
For i = 1 To cnt
Input #fn, x1, y1
glob_ctpath(glob_ctpath_cnt).x1 = x1
glob_ctpath(glob_ctpath_cnt).y1 = -y1
glob_ctpath(glob_ctpath_cnt).len1 = 0 ' spaeter
Rem laenge später ausrechnen.
glob_ctpath_cnt = glob_ctpath_cnt + 1
Rem
Next i
Rem
glob_ctpath_ptr(glob_ctpath_ptr_cnt).mindex = mptr ' index pointer
glob_ctpath_ptr(glob_ctpath_ptr_cnt).cnt = cnt
glob_ctpath_ptr(glob_ctpath_ptr_cnt).pos1 = 0 ' erst mal dort starten...
glob_ctpath_ptr(glob_ctpath_ptr_cnt).Dir1 = 0 ' erst mal dort starten...
glob_ctpath_ptr(glob_ctpath_ptr_cnt).fahrz = 0 ' erst mal dort starten...
glob_ctpath_ptr(glob_ctpath_ptr_cnt).warte = 0 ' erst mal dort starten...
Rem
glob_ctpath_ptr_cnt = glob_ctpath_ptr_cnt + 1 ' neuer pointerpointer
Rem
Rem
ElseIf cmd = "lock 1" Then ' Schleusen...
Rem
Rem nur xm, ym berechnen...
Rem kein cnt...
Input #fn, x1, y1
Input #fn, x2, y2
Rem
Input #fn, laenge
Input #fn, breite
Rem
Rem
glob_lock(glob_lock_cnt).x1 = x1
glob_lock(glob_lock_cnt).y1 = -y1
glob_lock(glob_lock_cnt).x2 = x2
glob_lock(glob_lock_cnt).y2 = -y2
glob_lock(glob_lock_cnt).Length = laenge
glob_lock(glob_lock_cnt).width = breite
Rem
glob_lock(glob_lock_cnt).shipa = 0
glob_lock(glob_lock_cnt).shipb = 0
glob_lock(glob_lock_cnt).shipl = 0
Rem
glob_lock_cnt = glob_lock_cnt + 1
Rem
ElseIf cmd = "assets" Then ' sonderfall nur xy
Rem assets
Rem 8
Rem 1
Rem geb2
Rem 0
Rem 205.065
Rem 231.7455
Input #fn, cnt ' zahl
For i = 0 To cnt - 1
Input #fn, glob_assets_data(i).idx
Line Input #fn, glob_assets_data(i).name1
Input #fn, glob_assets_data(i).phi1
Input #fn, glob_assets_data(i).x1
Input #fn, y1
glob_assets_data(i).y1 = -y1
Next i
Rem
glob_assets_data_cnt = cnt
Rem
ElseIf cmd = "end" Then
flg = True
End If
Loop While (Not EOF(fn)) And (flg = False)
Rem
Close #fn
Rem *********** danach alles calibrieren **************
Rem alle coordinaten werden auf 0,0 calibriert und auf 1 pixel = 0.61 meter
Rem der cal vektor ist 500 meter
callen = Sqr((calx2 - calx1) * (calx2 - calx1) + (caly2 - caly1) * (caly2 - caly1))
Rem n pixel = 500 meter
Rem es soll 1pixel = 0.61 meter sein nach der calibrierung
Rem
If callen = 0 Then callen = 500# ' SAVETY
calmul = 500# / (callen * 0.61)
Rem
Rem ref_minx = Round(t_ara2x(0) * calmul)
Rem ref_miny = Round(t_ara2y(0) * calmul)
Rem
For i = 0 To g_ara2cnt - 1
g_ara2polyx(i) = Round(t_ara2x(i) * calmul)
g_ara2polyy(i) = Round(t_ara2y(i) * calmul)
Rem If g_ara2polyx(i) < ref_minx Then ref_minx = g_ara2polyx(i)
Rem If g_ara2polyy(i) < ref_miny Then ref_miny = g_ara2polyy(i)
Next i
Rem dann min,max suchen fuer alle polygone
Rem
Dim idx As Integer
For i = 0 To g_ara2pcntcnt - 1
Rem
idx = g_ara2ptrptr(i).ara2pointerxy ' auf die koordinaten
g_ara2ptrptr(i).minx = g_ara2polyx(idx)
g_ara2ptrptr(i).miny = g_ara2polyy(idx)
g_ara2ptrptr(i).maxx = g_ara2polyx(idx)
g_ara2ptrptr(i).maxy = g_ara2polyy(idx)
Rem
For j = 1 To g_ara2ptrptr(i).ara2pcounters - 1 ' 0tes schon abgearbeitet
Rem
If g_ara2ptrptr(i).minx > g_ara2polyx(idx + j) Then g_ara2ptrptr(i).minx = g_ara2polyx(idx + j)
If g_ara2ptrptr(i).miny > g_ara2polyy(idx + j) Then g_ara2ptrptr(i).miny = g_ara2polyy(idx + j)
If g_ara2ptrptr(i).maxx < g_ara2polyx(idx + j) Then g_ara2ptrptr(i).maxx = g_ara2polyx(idx + j)
If g_ara2ptrptr(i).maxy < g_ara2polyy(idx + j) Then g_ara2ptrptr(i).maxy = g_ara2polyy(idx + j)
Rem
Next j
Rem
Next i

Rem min werte fuer offsetxy, bei polydraw gebrauch linke obere ecke...
Rem
For i = 0 To glob_berthcnt - 1
glob_berth(i).x1 = glob_berth(i).x1 * calmul
glob_berth(i).y1 = glob_berth(i).y1 * calmul
glob_berth(i).x2 = glob_berth(i).x2 * calmul
glob_berth(i).y2 = glob_berth(i).y2 * calmul
Rem berechnen der anderen werte ggf hier auch schon ok...
glob_berth(i).xm = (glob_berth(i).x2 + glob_berth(i).x1) / 2#
glob_berth(i).ym = (glob_berth(i).y2 + glob_berth(i).y1) / 2#
Rem winkel von x1y1 nach x2y2
Rem
dx = glob_berth(i).x2 - glob_berth(i).x1
dy = glob_berth(i).y2 - glob_berth(i).y1
Rem
phi = getwinkel(dx, dy)
glob_berth(i).phi = phi
Rem
Next i
Rem
Dim l1 As Double
Dim w1 As Double
Dim xm As Double
Dim ym As Double
Dim nx As Double
Dim ny As Double
For i = 0 To glob_lock_cnt - 1
Rem
glob_lock(i).x1 = glob_lock(i).x1 * calmul
glob_lock(i).y1 = glob_lock(i).y1 * calmul
glob_lock(i).x2 = glob_lock(i).x2 * calmul
glob_lock(i).y2 = glob_lock(i).y2 * calmul
Rem berechnen der anderen werte ggf hier auch schon ok...

glob_lock(i).xm = (glob_lock(i).x2 + glob_lock(i).x1) / 2#
glob_lock(i).ym = (glob_lock(i).y2 + glob_lock(i).y1) / 2#
Rem winkel von x1y1 nach x2y2
Rem
xm = glob_lock(i).xm
ym = glob_lock(i).ym
Rem
dx = glob_lock(i).x2 - glob_lock(i).x1
dy = glob_lock(i).y2 - glob_lock(i).y1
l1 = Sqr(dx * dx + dy * dy) ' gesamtlaenge...
If l1 > 0 Then
dx = dx / l1
dy = dy / l1
glob_lock(i).vx = dx
glob_lock(i).vy = dy

Rem laengen ausrechnen
nx = dy
ny = -dx
End If
Rem
l1 = glob_lock(i).Length / c_zoom1 ' umrechnen von meter auf pixel !!!
w1 = glob_lock(i).width / c_zoom1
Rem +++++++++++++++ STATE init
Rem
phi = getwinkel(dx, dy)
glob_lock(i).phi = phi
Rem
Rem Polygon definieren:
Rem ---->nx
Rem b
Rem 0 - 1
Rem ! ! l/4
Rem 2 - 3
Rem ! !
Rem ! m ! l
Rem ! !
Rem 4 - 5
Rem ! ! l/4
Rem 6 - 7
Rem 0,1 und 6,7 = triggerfelder 2,3,4,5 = innerer der schleuse
Rem relativ zu x0,y0 und normiert auf PIXEL, kein calmul noetig...
Rem
glob_lock(i).px(0) = -nx * w1 / 2# + dx * (l1 + 2 * w1) / 2#
glob_lock(i).py(0) = -ny * w1 / 2# + dy * (l1 + 2 * w1) / 2#
glob_lock(i).px(1) = nx * w1 / 2# + dx * (l1 + 2 * w1) / 2#
glob_lock(i).py(1) = ny * w1 / 2# + dy * (l1 + 2 * w1) / 2#
glob_lock(i).px(2) = -nx * w1 / 2# + dx * l1 / 2#
glob_lock(i).py(2) = -ny * w1 / 2# + dy * l1 / 2#
glob_lock(i).px(3) = nx * w1 / 2# + dx * l1 / 2#
glob_lock(i).py(3) = ny * w1 / 2# + dy * l1 / 2#
glob_lock(i).px(4) = -nx * w1 / 2# - dx * l1 / 2#
glob_lock(i).py(4) = -ny * w1 / 2# - dy * l1 / 2#
glob_lock(i).px(5) = nx * w1 / 2# - dx * l1 / 2#
glob_lock(i).py(5) = ny * w1 / 2# - dy * l1 / 2#
glob_lock(i).px(6) = -nx * w1 / 2# - dx * (l1 + 2 * w1) / 2#
glob_lock(i).py(6) = -ny * w1 / 2# - dy * (l1 + 2 * w1) / 2#
glob_lock(i).px(7) = nx * w1 / 2# - dx * (l1 + 2 * w1) / 2#
glob_lock(i).py(7) = ny * w1 / 2# - dy * (l1 + 2 * w1) / 2#
Rem die ungrehten polys
glob_lock(i).npx(0) = -w1 / 2#
glob_lock(i).npy(0) = l1 / 2# + w1
glob_lock(i).npx(1) = w1 / 2#
glob_lock(i).npy(1) = l1 / 2# + w1
glob_lock(i).npx(2) = -w1 / 2#
glob_lock(i).npy(2) = l1 / 2#
glob_lock(i).npx(3) = w1 / 2#
glob_lock(i).npy(3) = l1 / 2#
glob_lock(i).npx(4) = -w1 / 2#
glob_lock(i).npy(4) = -l1 / 2#
glob_lock(i).npx(5) = w1 / 2#
glob_lock(i).npy(5) = -l1 / 2#
glob_lock(i).npx(6) = -w1 / 2#
glob_lock(i).npy(6) = -l1 / 2# - w1
glob_lock(i).npx(7) = w1 / 2#
glob_lock(i).npy(7) = -l1 / 2# - w1
glob_lock(i).winkela = 0 ' 0=close 1=open ' spee
glob_lock(i).winkelb = 0 ' 0=close 1=open ' spee
If Rnd < 0.5 Then
glob_lock(i).lockState = 3 ' 3=go to state water up .. 0=both closed...or 12.-..
Else
glob_lock(i).lockState = 12 ' 3=go to state water up .. 0=both closed...or 12.-..
End If
Rem ggf rnd maessig...
glob_lock(i).waterlevel = 0.5 ' close half
Next i
Rem
Rem
For i = 0 To glob_roadcnt - 1
glob_road(i).x1 = glob_road(i).x1 * calmul
glob_road(i).y1 = glob_road(i).y1 * calmul
glob_road(i).x2 = glob_road(i).x2 * calmul
glob_road(i).y2 = glob_road(i).y2 * calmul
Rem
glob_road(i).xm = (glob_road(i).x2 + glob_road(i).x1) / 2#
glob_road(i).ym = (glob_road(i).y2 + glob_road(i).y1) / 2#
dx = glob_road(i).x2 - glob_road(i).x1
dy = glob_road(i).y2 - glob_road(i).y1
Rem
phi = getwinkel(dx, dy)
glob_road(i).phi = phi
Rem
Next i
Rem dann anlegestellen element etc.
Rem
For i = 0 To glob_bridgecnt - 1
glob_bridge(i).x1 = glob_bridge(i).x1 * calmul
glob_bridge(i).y1 = glob_bridge(i).y1 * calmul
glob_bridge(i).x2 = glob_bridge(i).x2 * calmul
glob_bridge(i).y2 = glob_bridge(i).y2 * calmul
Rem
glob_bridge(i).xm = (glob_bridge(i).x2 + glob_bridge(i).x1) / 2#
glob_bridge(i).ym = (glob_bridge(i).y2 + glob_bridge(i).y1) / 2#
Rem laenge ausrechnen
Rem
dx = glob_bridge(i).x2 - glob_bridge(i).x1
dy = glob_bridge(i).y2 - glob_bridge(i).y1
Rem
glob_bridge(i).l1 = Sqr((dx * dx + dy * dy))
phi = getwinkel(dx, dy)
glob_bridge(i).phi = phi
Rem
Next i
Rem
For i = 0 To glob_railcnt - 1
glob_rail(i).x1 = glob_rail(i).x1 * calmul
glob_rail(i).y1 = glob_rail(i).y1 * calmul
Rem --- hier ggf xs ys berechnen...r
If i > 0 And i <= glob_railcnt - 1 Then ' nicht mehr fuer den letzten puntk auch
Rem die zwischenpunkte sind nicht valide, werden aber auch nicht verwendet...
dx = glob_rail(i).x1 - glob_rail(i - 1).x1
dy = glob_rail(i).y1 - glob_rail(i - 1).y1
vx = -dy
vy = dx ' 90 grad drehen
norm1 = Sqr(vx * vx + vy * vy) ' kann null sein bei endpunkt...
glob_rail(i - 1).len1 = norm1 ' merken laenge des schienenstrangs.
If norm1 <> 0 Then
vx = -vx / norm1
vy = -vy / norm1
End If
glob_rail(i - 1).xs = vx
glob_rail(i - 1).ys = vy
End If
Rem
Next i
Rem
Rem mpath hybrid
For i = 0 To glob_mpath_cnt - 1
glob_mpath(i).x1 = glob_mpath(i).x1 * calmul
glob_mpath(i).y1 = glob_mpath(i).y1 * calmul
Rem
Next i
For i = 0 To glob_mpath_ptr_cnt - 1
Rem dann alle punkte durchlaufen laenge berechnen
Dim n1 As Double
mptr = glob_mpath_ptr(i).mindex ' start in datenfeld...
glob_mpath_ptr(i).lentotal = 0
Rem
For j = 0 To glob_mpath_ptr(i).cnt - 2 ' ohne letzen punkt
x1 = glob_mpath(mptr + j).x1
y1 = glob_mpath(mptr + j).y1
x2 = glob_mpath(mptr + j + 1).x1
y2 = glob_mpath(mptr + j + 1).y1
glob_mpath(mptr + j).len1 = Sqr((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1))
glob_mpath_ptr(i).lentotal = glob_mpath_ptr(i).lentotal + glob_mpath(mptr + j).len1
Rem winkel...
dx = x2 - x1
dy = y2 - y1
Rem
n1 = Sqr(dx * dx + dy * dy)
If n1 > 0 Then
glob_mpath(mptr + j).vx = dx / n1
glob_mpath(mptr + j).vy = dy / n1 ' normierter vektor in pfadrichtung...
End If
Rem
phi = getwinkel(dx, dy)
glob_mpath(mptr + j).phi1 = phi '
Rem
Next j
Rem
Next i
Rem ********************* container cal **************************
For i = 0 To glob_ctpath_cnt - 1
glob_ctpath(i).x1 = glob_ctpath(i).x1 * calmul
glob_ctpath(i).y1 = glob_ctpath(i).y1 * calmul
Rem
Next i
Rem
For i = 0 To glob_ctpath_ptr_cnt - 1
Rem dann alle punkte durchlaufen laenge berechnen
Dim n2 As Double
mptr = glob_ctpath_ptr(i).mindex ' start in datenfeld...
glob_ctpath_ptr(i).lentotal = 0
Rem
For j = 0 To glob_ctpath_ptr(i).cnt - 2 ' ohne letzen punkt
x1 = glob_ctpath(mptr + j).x1
y1 = glob_ctpath(mptr + j).y1
x2 = glob_ctpath(mptr + j + 1).x1
y2 = glob_ctpath(mptr + j + 1).y1
glob_ctpath(mptr + j).len1 = Sqr((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1))
glob_ctpath_ptr(i).lentotal = glob_ctpath_ptr(i).lentotal + glob_ctpath(mptr + j).len1
Rem winkel..c
glob_ctpath_ptr(i).pos1 = glob_ctpath_ptr(i).lentotal * Rnd ' erst mal dort starten...
Rem startposition...
Rem und richtung
If Rnd < 0.5 Then
glob_ctpath_ptr(i).Dir1 = 1
Else
glob_ctpath_ptr(i).Dir1 = -1
End If
dx = x2 - x1
dy = y2 - y1
Rem
n2 = Sqr(dx * dx + dy * dy)
If n2 > 0 Then
glob_ctpath(mptr + j).vx = dx / n2
glob_ctpath(mptr + j).vy = dy / n2 ' normierter vektor in pfadrichtung...
End If
Rem
phi = getwinkel(dx, dy)
glob_ctpath(mptr + j).phi1 = phi '
Rem
Next j
Rem
Next i
Rem
Rem ******************** ASSETS
For i = 0 To glob_assets_data_cnt - 1
glob_assets_data(i).x1 = glob_assets_data(i).x1 * calmul
glob_assets_data(i).y1 = glob_assets_data(i).y1 * calmul
Next i
Rem dann ggf calibriern auf min.
Rem
Else
Err = 0
End If
End Sub

[Guest]

-- post deleted --

[rdklein]

yes I just give you all definitions with limitations,
we can of course change the numbers:


Global Const MAXPOLYF = 25000 ' einzelnen kanten
Global Const MAXPOLYS = 5000 ' ganze polygone

Rem Global ref_minx As Double
Rem Global ref_miny As Double ' fuer poylsprite min suchen !

Global g_ara1polyx(200) As Long
Global g_ara1polyy(200) As Long
Global g_ara1cnt As Long

Rem aras genaueres polygon in gen2d
Global g_araspolyx(200) As Long
Global g_araspolyy(200) As Long
Global g_arascnt As Long

Rem ********************* alle polylines und flaechen *** **************************

Rem koordinatenpaare direkt:
Global g_ara2polyx(MAXPOLYF) As Long ' inter braucht long
Global g_ara2polyy(MAXPOLYF) As Long


Global t_ara2x(MAXPOLYF) As Double ' fuer umrechung
Global t_ara2y(MAXPOLYF) As Double ' fuer umrechung

Global g_ara2cnt As Long ' alle poly zusammen (vertices)


Type ara2_str
minx As Double ' bounding rect pro Polygon fuer optimierung bei draw...
miny As Double
maxx As Double
maxy As Double
ara2ppolyart As Long ' art 1..n des polygons
ara2pcounters As Long ' anzahl der linien im polygon
ara2pointerxy As Long ' index in g_ara2polyxy
Rem
End Type

Global g_ara2ptrptr(MAXPOLYS) As ara2_str ' dort alle verweise unterbringen


Rem damit z.b. 3 fuer 3 points als poly 1 4 als poly 2 etc.
Rem ggf weitere liste mit offenen polys fuer collisiton checks.
Rem


Global g_ara2pcntcnt As Long ' count der counters zusammen

Rem ********************* alle polylines und flaechen END **************************


Rem alle schiffe auch als polyliste ablegen,
Rem 1,1,2,2,3,3,4,4,5,5,6,6...
Rem
Rem dabei rechteck zuerst dann komplexes polygon danach.
Rem rechteck als normierungsgrundlage verwenden fuer b und h
Rem da polygone kleiner sein koennen.
Rem
Rem werden dann aber uebertragen auf polyxy ara 1
Rem -0.5 .. 0.5 ist nach der normierung die ausdehnung des schiffs fuer x,y
Rem


Type ship_poly_str
px(60) As Double ' ABS MAX 60 poly per ship
py(60) As Double
pcnt As Integer ' anzahl polylines
rex(5) As Double
rey(5) As Double ' temp fuer normierung
End Type


Global g_ship_poly(20) As ship_poly_str ' ANZAHL SCHIFFE...
Global g_ship_polycnt As Integer

Rem ********************** anlege und einfahrstellen

Type berth_str
x1 As Double ' vector von (1) nach (2) nach oben ist wasser
y1 As Double
x2 As Double
y2 As Double ' definiert auch richtg
Rem abgeleitete werte
xm As Double ' mitte anlegesetel
ym As Double
phi As Double ' winkel anlegestelle
Rem spaeter auswerten ..
Length As Double ' berth max laenge (aus datenblatt)
depth As Double ' wassertiefe max
art1 As String ' schiffscode liner,tanker,bulk... fuer anlegestellenart.
Rem
berthnewphase As Integer ' ' neue phase anwaehlen
berthphasedelay As Double ' wartezeit bis wechsel...
berthphase As Integer ' phasen übergang 0..4
berthstate As Integer ' temp merken fuer scene 0=leer 1=eigenes 2=fremdes schiff liegt an
End Type


Rem schleusen...
Type lock_str
x1 As Double ' vector von (1) nach (2) nach oben ist wasser
y1 As Double
x2 As Double
y2 As Double ' definiert auch richtg
Rem
Length As Double
width As Double
Rem
Rem betriebsparameter
Rem

Rem oeffnungszustand...
Rem
Rem berechnete werte:
xm As Double ' mitte anlegesetel
ym As Double
vx As Double
vy As Double
phi As Double ' richtung...
Rem
px(10) As Double ' polygon oben,mitte unten...
py(10) As Double
Rem senkrechte polygons.
Rem nicht gedreht und min max normiert fuer abfrage...
npx(10) As Double ' polygon oben,mitte unten...
npy(10) As Double
Rem
shipa As Integer ' 1=ship in lock A
shipb As Integer ' 1=ship in lock B
shipl As Integer ' 1=ship in lock
Rem
lockState As Integer ' 0=both closed
Rem
winkela As Double ' 0=close 1=open ' speed /ms....
winkelb As Double ' 0=close 1=open ' speed /ms....
waterlevel As Double ' 0=down 1=up
Rem
End Type

Global glob_lock(100) As lock_str
Global glob_lock_cnt As Integer


Type fship_str
dib As Long
m_dib As Long
xres As Long
yres As Long
Rem
polyx(10) As Long ' rechteck normalerweise aussreichen
polyy(10) As Long ' umgerechnet aus aktueller position
polycnt As Long ' anzahl punkte (st 5) feste position bei fremdships
Rem
xpos As Double ' zur sicherheit merken.. ggf. vektor...
ypos As Double
Rem
art1 As Integer ' schiffsart
l1 As Double
b1 As Double ' dimension
phi As Double ' rot...
Rem
Rem
End Type
Rem

Global glob_fship(500) As fship_str
Rem auch netzwerk schiffe
Rem dann infos ship art fuer polygon, x,y,phi, laenge, breite ...
Rem
Global glob_fship_cnt As Integer ' fuer free memory. mit fremdship definition hochgezaehlt..


Global glob_berth(200) As berth_str
Global glob_berthcnt As Long
Global glob_road(10) As berth_str ' auch fuer einlaufstellen verwenden
Global glob_roadcnt As Long


Type bridge_str
x1 As Double ' vector von (1) nach (2) nach oben ist wasser
y1 As Double
x2 As Double
y2 As Double ' definiert auch richtg
xm As Double ' mitte anlegesetel
ym As Double
l1 As Double 'laenge in pixel
phi As Double ' winkel anlegestelle
End Type


Global glob_bridge(80) As bridge_str
Global glob_bridgecnt As Long

Type rail_str
stflg As Integer ' first flag
rcnt As Integer ' dann count merken...
x1 As Double
y1 As Double ' Railpoints
xs As Double ' Vektoren senkrecht, beim einlesen erstellen
ys As Double ' fuer schwellen etc.
len1 As Double ' laenge der linie fuer segmentierung
End Type

Global glob_rail(1000) As rail_str
Global glob_railcnt As Long

Rem ************************************************************************

Rem container system mit fahrenden kraenen
Rem

Type ctpath_str
x1 As Double
y1 As Double
vx As Double
vy As Double ' vektor in richtung pfad
phi1 As Double ' pfadrichtung...
len1 As Double ' laenge des pfad segments.
End Type

Global glob_ctpath(5000) As ctpath_str ' pfad segmente
Global glob_ctpath_cnt As Long

Type ctpath_ptr_str
mindex As Long
cnt As Long
lentotal As Double '
Rem spaeter hier auch bewegungen
pos1 As Double ' position des krans
Dir1 As Double ' +1 -1 richtung...
warte As Double ' verweilzeit des krans...
fahrz As Double ' fahrzeit...
Rem

End Type

Global glob_ctpath_ptr(500) As ctpath_ptr_str
Global glob_ctpath_ptr_cnt As Long



Rem ************************************************************************

Rem alle pfade...

Type mpath_str
x1 As Double ' eckpunkte
y1 As Double
vx As Double
vy As Double ' vektor in richtung pfad
phi1 As Double ' pfadrichtung...
len1 As Double ' laenge des pfad segments.
Rem
End Type

Global glob_mpath(6000) As mpath_str
Global glob_mpath_cnt As Long

Rem ************************************************************************


Type mpath_ptr_str
mindex As Long ' index auf mpath
cnt As Long ' anzahl punkte
lentotal As Double ' gesamtlaenge normiert in pixel
faehrenname As String ' name des fahrzeugs auch auto...
loopflg As Integer
overflg As Integer
speed As Double ' typ fahrgeschw in pixel/sek
wartedefault As Double
multiple As Long ' anzahl der schiffe auf der strecke... bei 2 und no loop faehrenbetrieb
Rem
currentpos As Double ' position von 0..lentotal - 2* breite vehicle...
direction As Double ' 1=vor -1=rueck
wartezeit As Double ' in sec ...
object_hdib As Long ' local speichern da dynamische zuweisung...
object_m_hdib As Long ' wichtig dann freigabe beei prog ende...
Rem
xres As Integer ' fuer die dibs
yres As Integer
End Type

Global glob_mpath_ptr(500) As mpath_ptr_str
Global glob_mpath_ptr_cnt As Long

Rem
Rem dynamische kollisionsstruktur verwenden ...
Rem hat wegen mutliple fahrzeuge ggf andere struktur
Type mpath_koll_str
polyx(5) As Long
polyy(5) As Long
polycnt As Long ' immer5
End Type

Global glob_mpath_koll_cnt As Long
Global glob_mpath_koll(1000) As mpath_koll_str


Rem ************************************************************************
Rem ************************** neues ASSET system **************************


Type asset_str
x1 As Integer
y1 As Integer
dx As Integer
dy As Integer
idx As Integer
name1 As String
valid As Integer ' 1=ok 0= deleted.
Rem
End Type

Rem nur als index verwendet .. fuer paste daten
Global glob_assets(1000) As asset_str

Rem dann liste der verwendeten assets

Type asset_pos_str
x1 As Double
y1 As Double
phi1 As Double
idx As Integer ' index of asset
Rem
name1 As String ' zur sicherheit...
Rem
Rem
End Type

Global glob_assets_data(4000) As asset_pos_str
Global glob_assets_data_cnt As Integer
Rem
Global current_assets_data_index As Integer

[Guest]

-- post deleted --

[rdklein]

its also ways good to place one berth outside which is large, it will get all larg ships automatically even if the type does not mach. You can use the type cargo gearless (has no cranes). as type (also for small berths where the cranes dont fit).

[Guest]

-- post deleted --

[Guest]

-- post deleted --

[Guest]

-- post deleted --

[Christian Todt]

how do i have to put the file in the game??
_________________
Navigare neccesse est