Type tile
  Field image:TImage, action()
End Type
'...
Global tilemap:tile[][], mapwidth, mapheight
'laden
'wenn du die Tilemaps aus einem Array auslesen willst:
Global tilemaps:tile[][][]  'Dimensionen: 1. Tilemaps 2. Zeilen/Spalten 3.Tiles
'/wenn

'Beispiel für ein Aktions-Tile:
Local actiontile:tile = New tile
actiontile.image = teleporterImage
Function loadTilemap1()
  loadTilemap 1
End Function
actiontile.action = loadTilemap1

Function loadTimemap(index)
  Local dims% = tilemaps[index].dimensions()
  mapwidth = dims[0]
  mapheight = dims[1]
  tilemap = tilemap[..mapwidth]
  For x=0 To mapwidth-1
    tilemap[x] = tilemap[x][..mapheight]
    For y=0 To mapheight
      tilemap[x][y] = tilemaps[index][x][y]
    Next
  Next
End Function

'Mainloop
  Local t:tile = 'aktuelles Tile
  If t.action Then t.action
'/Mainloop

Type TEventTrigger
     Field onActivate(ev:TEventTrigger)
     Field data:Object

     Function Create:TEventTrigger(func(ev:TEventTrigger), obj:Object)
           Local trigger:TEventTrigger= New TEventTrigger
           trigger.onActivate = func
           trigger.data = obj
           Return trigger
     End Function
     Method Activate()
           Self.onActivate(Self)
     End Method
End Type

Function ChangeMap(ev:TEventTrigger)
     'die funktion kann nur auf einem mapchange trigger sein. Dh sie weiß, das das objekt-field ein String ist!
     Local zielMap:String = String(ev.data)
     LoadMap(zielMap)
End Function

Global Map%[40,40]
...
irgendTile = Map[x,y]

Global Map%[40,40] , ActionMap$[40,40]
...
irgendTile = Map[x,y,0]
Action= ActionMap[x,y]

Global Map[40,40,2]
...
irgendTile = Map[x,y,0]
Action= Map[x,y,1]

Function loadTilemap1()
  loadTilemap 1
End Function

Global map:Int[19, 19]
Global tileset:Int = LoadAnimImage("data\Tileset.png", 32, 32, 0, 40)
Global map_width:Int, map_height:Int
Global tilemap:TStream = ReadFile("data\map.tmd")

map_width = ReadInt(tilemap)
map_height = ReadInt(tilemap)

For x:Int = 0 To map_width
     For y:Int = 0 To map_height
          map[x, y] = ReadByte(tilemap)
          DrawImage tileset, x * 32, y * 32, map[x, y]
     Next
Next

Global Map:Feld[,] = New Feld[MapWidth,MapHeight]
Type Feld
  Field x:Int,y:Int,Begehbar:Byte
  Field Image:TImage
  Field MapLink:String

 Method Draw()
 ...
 End Method
End Type

Function GetFeld(X:Int,Y:Int)
 Return map[X/Tilesize,Y/Tilesize]
End Function

Function CheckMapLink(X:Int,Y:Int)
 If GetFeld/(x,y).maplink <> "" Then LoadMap(GetFeld/(x,y).maplink)
End Function

ActionMap:Int[19,19]
Global ActionMap:TStream = ReadFile("data\ActionMap.tmd")
....
For x:Int = 0 To map_width
     For y:Int = 0 To map_height
          ActionMap[x, y] = ReadByte(ActionMap)
     Next
Next
....
Select ActionMap[SpielerX , SpielerY]
      Case 0
            ' keine Action auf diesem Feld
      Case 1
            ' beispiel für Action: Betreten eines Hauses:
            NextMap ="MapHaus.tmd"
            NextActionMap= "ActionMapHaus.tmd"
            NeuSpielerX=10
            NeuSpielerY=10
            .... und was immer Du sonst noch regeln möchtest
      Case 2
            ' und wieder zurück ins freie:
            NextMap ="Map.tmd"
            NextActionMap= "ActionMap.tmd"
            NeuSpielerX=10
            NeuSpielerY=10
       Case 3
             .....
End Select    

Global Map:IN[19,19,2]

Map[X,Y,0]

Map[X,Y,1]

' Tile-Map:
DrawImage tileset, x * 32, y * 32, map[x, y,0]
....
'Action-Map:
Select Map[SpielerX , SpielerY,1]
....

Global ActionMap:TStream = ReadFile("data\ActionMap.tmd")
Global tilemap:TStream = ReadFile("data\map.tmd")
....
For x:Int = 0 To map_width
     For y:Int = 0 To map_height
          Map[x, y, 0] = ReadByte(TileMap)
          Map[x, y, 1] = ReadByte(ActionMap)
     Next
Next

Global ActionListe:TStream = ReadFile("data\ActionListe.txt")
Repeat   
     WoActionX = ReadLine(ActionListe)
     WoActionY = ReadLine(ActionListe)
     ActionID = ReadLine(ActionListe)
     Map[ WoActionX , WoActionY , 1] = ActionID
Until Eof(ActionListe) 

Type Feld
     Field X:Int , Y: Int , ID:Int 
     Field TileSet:Int
     Field Begehbar:Int , Action:Int
     ....usw
End Type 

'Zeichnen:
          DrawImage tileset, x * 32, y * 32, map[x, y].TileSet
' Action herausfinden:
ActionHier = Map[SpielerX, SpielerY].Action

Field onActivate(ev:TEventTrigger)

SuperStrict '-> Superstrict muss immer sein, zwingt zum ordentlichen Programmieren.

'<=============================================
'----- Anfang Programm



'Wir erstellen in der variable 'test' eine neue instanz von dem Typ 'TTest'
Local test:TTest = New TTest

'Und wir schreiben gleich mal eine funktion in das Feld 'onActivate' rein -> TestFunktion1!
test.onActivate = TestFunktion1

'nun führen wir das ganze einmal aus, und schauen was passiert..
test.Activate()
test.Activate()

test.Activate()
test.Activate()

test.Activate()
test.Activate()


Print "Der Test ist abgeschlossen. unserere Variable Test hat nun folgende werte:"
Print "Aufrufe der funktion 'TestFunktion1' -> " + test.Aufrufe1
Print "Aufrufe der funktion 'TestFunktion2' -> " + test.Aufrufe2

'---- Ende programm
'==============================================>

Type TTest
	Field onActivate(abc:TTest) '=> Unserer 'Hyperlink'
	
	Field Aufrufe1:Int = 0 'ein testWert- soll zählen, wie oft TestFunktion1 aufgerufen wurde!
	Field Aufrufe2:Int = 0 'ein testWert- soll zählen, wie oft TestFunktion2 aufgerufen wurde!
	
	Method Activate()
		Self.onActivate(Self)
	End Method
End Type


Function TestFunktion1(efg:TTest)
	'Hier mal ein simples printen um nachzuvollziehen, was da passiert.
	Print "TestFunktion1 wurde aufgerufen."
	
	'und gleich mal das feld 'Aufrufe1' hochzählen!
	efg.Aufrufe1 = efg.Aufrufe1 + 1 'den letzten inhalt + 1 -> hochzählen.
	
	'Hier mal etwas komisches: nach ausführen der funktion soll der 'Hyperlink' geändert werden.
	efg.onActivate = TestFunktion2
End Function

Function TestFunktion2(hij:TTest)
	Print "TestFunktion2 wurde aufgerufen. "
	
	'hochzählen von 'Aufrufe2'
	hij.Aufrufe2 = hij.Aufrufe2 + 1
	
	'wieder eine änderung..
	hij.onActivate = TestFunktion1
End Function

Type TTile
	Field id:Byte
End Type

Type TLandschaft
	Field tileset:TImage 'das alte TileSet!
	Field width:Int 'map_width!
	Field Height:Int 'map_height
	
	Field tile:TTile[,]
	
	Function LoadMap:TLandschaft(tileSetPfad:String, tileMapPfad:String)
		'hier kommt deine laderoutine rein.
		
		'da dies eine FUNKTION innerhalb eines Types ist, müssen wir ersteinmal die Instanz erstellen.
		Local map:TLandschaft = New TLandschaft
		'anmerkung: map ist wieder nur variable gewählt-
		
		map.tileset = LoadAnimImage(tileSetPfad, 32, 32, 0, 40)
		
		Local stream:TStream = ReadFile(tileMapPFad) 'entspricht "tilemap:TStream = ReadFile("data\map.tmd")"
		
		map.width = ReadInt(stream) 'die beiden werte, gewohnt wie vorher, auslesen.
		map.Height = ReadInt(stream)
		
		'hier was anderes: ersteinmal den Array 'tile' vorbereiten.
		map.tile = New TTile[map.width + 1, map.Height + 1] '+1 habe ich deshalb genommen, da du mit "von 0 BIS map_width" etc durchgehst - aber evtl ist es auch OHNE +1 richtig!
		
		For Local x:Int = 0 To map.width
			For Local y:Int = 0 To map.Height
				map.tile[x, y] = New TTile 'da auch hier wieder eine Instanz erstellt werden muss, tun wir das dochmal. :)
				
				map.tile[x, y].id = ReadByte(stream) 'und wie gewohnt: Den stream auslesen.
			Next
		Next
		
		'Wir sind fertig? Okay, stream wieder schließen.
		CloseStream(stream)
		
		'finally: die map zurückgeben.
		Return map
	End Function
	
End Type

Global map:TLandschaft = TLandschaft.LoadMap("data\Tileset.png", "data\map.tmd")

map.draw()

Aber bitte bitte bitte! Tausch nicht einfach etwas aus! Schau hier drüber, wenn du es verstehst kann ich mirn Keks freuen - ich konnte einmal was erklären. Wenn nicht - nicht einfach austesten! Das ist schon eine größere änderung an deinem Code und könnte mit Restlichen teilen nichtmehr Kompatibel sein.
Wenn du ein solches System einbauen möchtest, ersteinmal sicherheitskopie anfertigen und bei jedem Detail nachfragen, was unklar ist. Erst wenn du den umgang verstanden hast, übernehmen