HOPKINS: Added new LinesManager class with lots of line methods

10 files changed, 2518 insertions, 898 deletions

diff --git a/engines/hopkins/globals.cpp b/engines/hopkins/globals.cpp
index a69a8be359..b7f5b51b5d 100644
--- a/engines/hopkins/globals.cpp
+++ b/engines/hopkins/globals.cpp
@@ -235,16 +235,16 @@ void Globals::clearAll() {
 	chemin = PTRNUL;
 
 	for (int idx = 0; idx < 400; ++idx) {
-		Ligne[idx].field0 = 0;
-		Ligne[idx].field2 = 0;
-		Ligne[idx].field4 = 0;
-		Ligne[idx].field6 = 0;
-		Ligne[idx].field8 = 0;
-		Ligne[idx].field12 = PTRNUL;
-
-		LigneZone[idx].field0 = 0;
-		LigneZone[idx].field2 = 0;
-		LigneZone[idx].field4 = PTRNUL;
+		_vm->_linesManager.Ligne[idx].field0 = 0;
+		_vm->_linesManager.Ligne[idx].field2 = 0;
+		_vm->_linesManager.Ligne[idx].field4 = 0;
+		_vm->_linesManager.Ligne[idx].field6 = 0;
+		_vm->_linesManager.Ligne[idx].field8 = 0;
+		_vm->_linesManager.Ligne[idx].field12 = PTRNUL;
+
+		_vm->_linesManager.LigneZone[idx].field0 = 0;
+		_vm->_linesManager.LigneZone[idx].field2 = 0;
+		_vm->_linesManager.LigneZone[idx].field4 = PTRNUL;
 	}
 
 	for (int idx = 0; idx < 100; ++idx) {
diff --git a/engines/hopkins/globals.h b/engines/hopkins/globals.h
index 057ce09da8..f2a27e3f88 100644
--- a/engines/hopkins/globals.h
+++ b/engines/hopkins/globals.h
@@ -47,22 +47,6 @@ struct ZonePItem {
 	int field16;
 };
 
-struct LigneItem {
-	int field0;
-	int field2;
-	int field4;
-	int field6;
-	int field8;
-	byte *fieldC;
-	byte *field12;
-};
-
-struct LigneZoneItem {
-	int field0;
-	int field2;
-	byte *field4;
-};
-
 struct CarreZoneItem {
 	int field0;
 	int field2;
@@ -332,8 +316,6 @@ public:
 	byte *BUF_ZONE;
 	byte *CACHE_BANQUE[6];
 	ZonePItem ZONEP[106];
-	LigneItem Ligne[400];
-	LigneZoneItem LigneZone[401];
 	CarreZoneItem CarreZone[101];
 	BqeAnimItem Bqe_Anim[35];
 	BankItem Bank[8];
@@ -432,6 +414,8 @@ public:
 	int ACTION_SENS;
 	int STOP_BUG;
 	int SegmentEnCours;
+	int NVPX;
+	int NVPY;
 
 	int force_to_data_0;
 	int oldzone_46;
diff --git a/engines/hopkins/graphics.cpp b/engines/hopkins/graphics.cpp
index b4810d3af2..76782cf4d8 100644
--- a/engines/hopkins/graphics.cpp
+++ b/engines/hopkins/graphics.cpp
@@ -2403,9 +2403,4 @@ void GraphicsManager::NB_SCREEN() {
 	DD_VBL();
 }
 
-int GraphicsManager::colision2_ligne(int a1, int a2, int *a3, int *a4, int a5, int a6) {
-	warning("TODO: colision2_ligne");
-	return 0;
-}
-
 } // End of namespace Hopkins
diff --git a/engines/hopkins/graphics.h b/engines/hopkins/graphics.h
index 4c76a7f15e..60c972957c 100644
--- a/engines/hopkins/graphics.h
+++ b/engines/hopkins/graphics.h
@@ -177,7 +177,6 @@ public:
 	void INI_ECRAN2(const Common::String &file);
 	void OPTI_INI(const Common::String &file, int a2);
 	void NB_SCREEN();
-	int colision2_ligne(int a1, int a2, int *a3, int *a4, int a5, int a6);
 };
 
 } // End of namespace Hopkins
diff --git a/engines/hopkins/hopkins.h b/engines/hopkins/hopkins.h
index 7930eae32b..9453966ff7 100644
--- a/engines/hopkins/hopkins.h
+++ b/engines/hopkins/hopkins.h
@@ -36,6 +36,7 @@
 #include "hopkins/font.h"
 #include "hopkins/globals.h"
 #include "hopkins/graphics.h"
+#include "hopkins/lines.h"
 #include "hopkins/menu.h"
 #include "hopkins/objects.h"
 #include "hopkins/sound.h"
@@ -101,6 +102,7 @@ public:
 	FontManager _fontManager;
 	Globals _globals;
 	GraphicsManager _graphicsManager;
+	LinesManager _linesManager;
 	MenuManager _menuManager;
 	ObjectsManager _objectsManager;
 	SoundManager _soundManager;
diff --git a/engines/hopkins/lines.cpp b/engines/hopkins/lines.cpp
new file mode 100644
index 0000000000..f25f068054
--- /dev/null
+++ b/engines/hopkins/lines.cpp
@@ -0,0 +1,2363 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "common/system.h"
+#include "common/textconsole.h"
+#include "hopkins/lines.h"
+#include "hopkins/graphics.h"
+#include "hopkins/hopkins.h"
+
+namespace Hopkins {
+
+void LinesManager::setParent(HopkinsEngine *vm) {
+	_vm = vm;
+}
+
+void LinesManager::CLEAR_ZONE() {
+	for (int idx = 0; idx < 400; ++idx)
+		RETIRE_LIGNE_ZONE(idx);
+
+	next_ligne = 0;
+}
+
+void LinesManager::RETIRE_LIGNE_ZONE(int idx) {
+	if (idx > 400)
+		error("Attempting to add a line obstacle > MAX_LIGNE.");
+	if (_vm->_linesManager.LigneZone[idx].field4 != PTRNUL)
+		_vm->_globals.dos_free2(_vm->_linesManager.LigneZone[idx].field4);
+
+	_vm->_linesManager.LigneZone[idx].field4 = PTRNUL;
+}
+
+
+void LinesManager::AJOUTE_LIGNE_ZONE(int idx, int a2, int a3, int a4, int a5, int a6) {
+	int v7; 
+	int v8; 
+	int v9; 
+	byte *v10;
+	int v11; 
+	byte *v12; 
+	int v13; 
+	int v14; 
+	byte *v15; 
+	int v16; 
+	int v17; 
+	int v18; 
+	int v19; 
+	int v20; 
+	int v21; 
+	int v22; 
+	int v23; 
+
+	if (a2 != a3 || a3 != a4 || a3 != a5) {
+		if (idx > 400)
+			error("Attempting to add a line obstacle > MAX_LIGNE.");
+		v7 = idx;
+		if (LigneZone[v7].field4 != PTRNUL)
+			LigneZone[v7].field4 = _vm->_globals.dos_free2(LigneZone[v7].field4);
+		v8 = a2 - a4;
+		if (a2 - a4 < 0)
+			v8 = -v8;
+		v19 = v8;
+		v9 = a3 - a5;
+		if (a3 - a5 < 0)
+			v9 = -v9;
+		v18 = v9;
+		if (v19 <= (int)v9)
+			v20 = v9 + 1;
+		else
+			v20 = v19 + 1;
+		v10 = _vm->_globals.dos_malloc2(4 * v20 + 8);
+		v11 = idx;
+		LigneZone[v11].field4 = v10;
+		if (PTRNUL == v10)
+			error("AJOUTE LIGNE ZONE");
+
+		v12 = LigneZone[v11].field4;
+		v23 = 1000 * v19 / v20;
+		v22 = 1000 * v18 / v20;
+		if (a4 < a2)
+			v23 = -v23;
+		if (a5 < a3)
+			v22 = -v22;
+		v13 = 1000 * a2;
+		v16 = 1000 * a3;
+		v17 = 1000 * a2 / 1000;
+		v21 = 1000 * a3 / 1000;
+		v14 = 0;
+		if (v20 > 0) {
+			do {
+				WRITE_LE_UINT16(v12, v17);
+				v15 = v12 + 2;
+				WRITE_LE_UINT16(v15, v21);
+				v12 = v15 + 2;
+				v13 += v23;
+				v16 += v22;
+				v17 = v13 / 1000;
+				v21 = v16 / 1000;
+				++v14;
+			} while (v20 > v14);
+		}
+		WRITE_LE_UINT16(v12, (uint16)-1);
+		WRITE_LE_UINT16(v12 + 2, (uint16)-1);
+		
+		LigneZone[idx].field0 = v20;
+		LigneZone[idx].field2 = a6;
+	} else {
+		_vm->_globals.BOBZONE_FLAG[idx] = 1;
+		_vm->_globals.BOBZONE[idx] = a3;
+	}
+}
+
+
+void LinesManager::RESET_OBSTACLE() {
+	for (int idx =0; idx < 400; ++idx) {
+		RETIRE_LIGNE(idx);
+		Ligne[idx].field0 = 0;
+		Ligne[idx].fieldC = PTRNUL;
+	}
+}
+
+void LinesManager::RETIRE_LIGNE(int idx) {
+	if (idx > 400)
+		error("Attempting to add a line obstacle > MAX_LIGNE.");
+	if (Ligne[idx].fieldC != PTRNUL)
+		_vm->_globals.dos_free2(Ligne[idx].fieldC);
+	Ligne[idx].fieldC = PTRNUL;
+}
+
+void LinesManager::AJOUTE_LIGNE(int idx, int a2, int a3, int a4, int a5, int a6, int a7) {
+	int v7; 
+	int v8; 
+	int v9; 
+	byte *v10; 
+	int v11; 
+	int v12;
+	int v13;
+	int v24;
+	int v25;
+	int v26;
+	byte *v27;
+	int v30;
+	int v31;
+	byte *v32;
+	int v33;
+	int v34;
+	int v35;
+	int v36;
+	int v37;
+	int v38;
+	int v39;
+	int v40;
+
+	if (idx > 400)
+		error("Attempting to add a line obstacle > MAX_LIGNE.");
+	if (TOTAL_LIGNES < idx)
+		TOTAL_LIGNES = idx;
+
+	if (Ligne[idx].fieldC != PTRNUL)
+		_vm->_globals.dos_free2(Ligne[idx].fieldC);
+	v7 = a3 - a5;
+	if (a3 - a5 < 0)
+		v7 = -v7;
+	v8 = v7 + 1;
+	v9 = a4 - a6;
+	if (a4 - a6 < 0)
+		v9 = -v9;
+	v34 = v9 + 1;
+	v33 = v9 + 1;
+	if (v8 > (int)(v9 + 1))
+		v34 = v8;
+	v10 = _vm->_globals.dos_malloc2(4 * v34 + 8);
+	Ligne[idx].fieldC = v10;
+	if (v10 == PTRNUL)
+		error("AJOUTE LIGNE OBSTACLE");
+	v32 = Ligne[idx].fieldC;
+	v36 = 1000 * v8;
+	v39 = 1000 * v8 / (v34 - 1);
+	v37 = 1000 * v33 / (v34 - 1);
+	if (a5 < a3)
+		v39 = -v39;
+	if (a6 < a4)
+		v37 = -v37;
+	v11 = (int)v39 / 1000;
+	v12 = (int)v37 / 1000;
+	v13 = (int)v37 / 1000;
+	if (!((int)v39 / 1000)) {
+		if (v12 == -1) {
+			Ligne[idx].field6 = 1;
+			Ligne[idx].field8 = 5;
+		}
+		if (v12 == 1) {
+			Ligne[idx].field6 = 5;
+			Ligne[idx].field8 = 1;
+		}
+	}
+	if (v11 == 1) {
+		if (v12 == -1) {
+			Ligne[idx].field6 = 2;
+			Ligne[idx].field8 = 6;
+		}
+		if (!v13) {
+			Ligne[idx].field6 = 3;
+			Ligne[idx].field8 = 7;
+		}
+		if (v13 == 1) {
+			Ligne[idx].field6 = 4;
+			Ligne[idx].field8 = 8;
+		}
+	}
+	if (v11 == -1) {
+		if (v13 == 1) {
+			Ligne[idx].field6 = 6;
+			Ligne[idx].field8 = 2;
+		}
+		if (!v13) {
+			Ligne[idx].field6 = 7;
+			Ligne[idx].field8 = 3;
+		}
+		if (v13 == -1) {
+			Ligne[idx].field6 = 8;
+			Ligne[idx].field8 = 4;
+		}
+	}
+	if (v11 == 1 && (unsigned int)(v37 - 251) <= 0x2EC) {
+		Ligne[idx].field6 = 4;
+		Ligne[idx].field8 = 8;
+	}
+	if (v11 == -1 && (unsigned int)(v37 - 251) <= 0x2EC) {
+		Ligne[idx].field6 = 6;
+		Ligne[idx].field8 = 2;
+	}
+	if (v11 == 1 && (unsigned int)(v37 + 999) <= 0x2EC) {
+		Ligne[idx].field6 = 2;
+		Ligne[idx].field8 = 6;
+	}
+	if (v11 == -1 && v37 <= 249 && v37 > 1000) {
+		Ligne[idx].field6 = 8;
+		Ligne[idx].field8 = 4;
+	}
+	v40 = v36 / v34;
+	v38 = 1000 * v33 / v34;
+	if (a5 < a3)
+		v40 = -v40;
+	if (a6 < a4)
+		v38 = -v38;
+	v24 = 1000 * a3;
+	v25 = 1000 * a4;
+	v31 = 1000 * a3 / 1000;
+	v30 = 1000 * a4 / 1000;
+	v35 = v34 - 1;
+	v26 = 0;
+	if (v35 > 0) {
+		do {
+			WRITE_LE_UINT16(v32, v31);
+			WRITE_LE_UINT16(v32 + 2, v30);
+			v32 += 4;
+			v24 += v40;
+			v25 += v38;
+			v31 = v24 / 1000;
+			v30 = v25 / 1000;
+			++v26;
+		} while (v35 > v26);
+	}
+	WRITE_LE_UINT16(v32, a5);
+	WRITE_LE_UINT16(v32 + 2, a6);
+	v27 = v32 + 4;
+	WRITE_LE_UINT16(v27, (uint16)-1);
+	WRITE_LE_UINT16(v27 + 2, (uint16)-1);
+	
+	Ligne[idx].field0 = v35 + 1;
+	Ligne[idx].field2 = a7;
+	Ligne[idx].field4 = a2;
+}
+
+int LinesManager::colision2_ligne(int a1, int a2, int *a3, int *a4, int a5, int a6) {
+	int v6; 
+	byte *v7; 
+	int v8;
+	int v9;
+	int v10;
+	int v11;
+	int v12;
+	byte *v13; 
+	int v14;
+	int result; 
+	int v16; 
+	int v17; 
+	int v18; 
+	int v19; 
+	int v20; 
+	int v21; 
+	int v22; 
+	int v23; 
+	int v24; 
+
+	v24 = a5;
+	v6 = a5;
+	if (a5 >= a6 + 1) {
+LABEL_29:
+		result = 0;
+	} else {
+		v22 = a1 + 4;
+		v21 = a1 - 4;
+		v20 = a2 + 4;
+		v19 = a2 - 4;
+		while (1) {
+			v7 = Ligne[v6].fieldC;
+			if (v7 != PTRNUL) {
+				v23 = 1;
+				v8 = 2 * Ligne[v6].field0;
+				v9 = READ_LE_UINT16(v7);
+				v16 = READ_LE_UINT16(v7 + 2);
+				v10 = READ_LE_UINT16(v7 + 2 * v8 - 4);
+				v18 = READ_LE_UINT16(v7 + 2 * v8 - 2);
+				if (READ_LE_UINT16(v7) >= v10)
+					goto LABEL_32;
+				if (v22 < v9 || v21 > v10)
+					v23 = 0;
+				if (v9 >= v10) {
+LABEL_32:
+					if (v21 > v9 || v22 < v10)
+						v23 = 0;
+				}
+				if (v16 >= v18)
+					goto LABEL_33;
+				if (v20 < v16 || v19 > v18)
+					v23 = 0;
+				if (v16 >= v18) {
+LABEL_33:
+					if (v19 > v16 || v20 < v18)
+						v23 = 0;
+				}
+				if (v23 == 1) {
+					v11 = 0;
+					v17 = Ligne[v24].field0;
+					if (v17 > 0)
+						break;
+				}
+			}
+LABEL_28:
+			++v24;
+			v6 = v24;
+			if (v24 >= a6 + 1)
+				goto LABEL_29;
+		}
+		while (1) {
+			v12 = READ_LE_UINT16(v7);
+			v13 = v7 + 2;
+			v14 = READ_LE_UINT16(v13);
+			v7 = v13 + 2;
+			if (a1 == v12 || a1 + 1 == v12) {
+				if (a2 == v14 || a2 + 1 == v14)
+					break;
+			}
+			++v11;
+			if (v17 <= v11)
+				goto LABEL_28;
+		}
+		*a3 = v11;
+		*a4 = v24;
+		result = 1;
+	}
+	return result;
+}
+
+int LinesManager::Scolision2_ligne(int a1, int a2, int *a3, int *a4, int a5, int a6) {
+	int v6; 
+	byte *v7; 
+	int v8; 
+	int v9; 
+	int v10;
+	int v11;
+	int v12;
+	byte *v13;
+	int result;
+	int v15; 
+	int v16; 
+	int v17; 
+	int v18; 
+	int v19; 
+	int v20; 
+	int v21; 
+	int v22; 
+	int v23; 
+	int v24; 
+
+	v24 = a5;
+	v6 = a5;
+	if (a5 >= a6 + 1) {
+LABEL_47:
+		result = 0;
+	} else {
+		v22 = a1 + 10;
+		v21 = a1 - 10;
+		v20 = a2 + 10;
+		v19 = a2 - 10;
+		while (1) {
+			v7 = Ligne[v6].fieldC;
+			if (PTRNUL != v7) {
+				v23 = 1;
+				v8 = 2 * Ligne[v6].field0;
+				v9 = READ_LE_UINT16(v7);
+				v15 = READ_LE_UINT16(v7 + 2);
+				v10 = READ_LE_UINT16(v7 + 2 * v8 - 4);
+				v17 = READ_LE_UINT16(v7 + 2 * v8 - 2);
+				if (READ_LE_UINT16(v7) >= v10)
+					goto LABEL_50;
+				if (v22 < v9 || v21 > v10)
+					v23 = 0;
+				if (v9 >= v10) {
+LABEL_50:
+					if (v21 > v9 || v22 < v10)
+						v23 = 0;
+				}
+				if (v15 >= v17)
+					goto LABEL_51;
+				if (v20 < v15 || v19 > v17)
+					v23 = 0;
+				if (v15 >= v17) {
+LABEL_51:
+					if (v19 > v15 || v20 < v17)
+						v23 = 0;
+				}
+				if (v23 == 1) {
+					v11 = 0;
+					v18 = Ligne[v24].field0;
+					if (v18 > 0)
+						break;
+				}
+			}
+LABEL_46:
+			++v24;
+			v6 = v24;
+			if (v24 >= a6 + 1)
+				goto LABEL_47;
+		}
+		while (1) {
+			v12 = READ_LE_UINT16(v7);
+			v13 = v7 + 2;
+			v16 = READ_LE_UINT16(v13);
+			v7 = v13 + 2;
+			if (a1 == v12
+			        || v12 == a1 + 1
+			        || v12 == a1 + 2
+			        || v12 == a1 + 3
+			        || v12 == a1 + 4
+			        || v12 == a1 + 5
+			        || v12 == a1 + 6
+			        || v12 == a1 + 7
+			        || v12 == a1 + 8
+			        || v12 == a1 + 9
+			        || a1 + 10 == v12) {
+				if (v16 == a2
+				        || v16 == a2 + 1
+				        || v16 == a2 + 2
+				        || v16 == a2 + 3
+				        || v16 == a2 + 4
+				        || v16 == a2 + 5
+				        || v16 == a2 + 6
+				        || v16 == a2 + 7
+				        || v16 == a2 + 8
+				        || v16 == a2 + 9
+				        || a2 + 10 == v16)
+					break;
+			}
+			++v11;
+			if (v18 <= v11)
+				goto LABEL_46;
+		}
+		*a3 = v11;
+		*a4 = v24;
+		result = 1;
+	}
+	return result;
+}
+
+void LinesManager::INIPARCOURS() {
+	int v0; 
+	int v1; 
+	int v2; 
+	byte *v3; 
+	int v4; 
+	int v5; 
+	int v6; 
+	byte *v7; 
+	int v8; 
+	int v9; 
+	int v11;
+	int v12;
+	int v13;
+	int v14;
+	int v15;
+
+	v15 = READ_LE_UINT16(Ligne[0].fieldC);
+	v14 = READ_LE_UINT16(Ligne[0].fieldC + 2);
+
+	v0 = 1;
+	v1 = 0;
+	do {
+		v2 = Ligne[v0].field0;
+		v3 = Ligne[v0].fieldC;
+		v4 = READ_LE_UINT16(v3 + 4 * v2 - 4);
+		v5 = READ_LE_UINT16(v3 + 4 * v2 - 2);
+		if (_vm->_graphicsManager.max_x == v4 || _vm->_graphicsManager.max_y == v5 || _vm->_graphicsManager.min_x == v4 
+				|| _vm->_graphicsManager.min_y == v5)
+			v1 = 1;
+		if (v15 == v4 && v14 == v5)
+			v1 = 1;
+		if (v0 == 400) {
+			v6 = v1;
+			error("ERROR - LAST LINE NOT FOUND");
+			v1 = v6;
+		}
+		v7 = Ligne[v0 + 1].fieldC;
+		if (READ_LE_UINT16(v7) != v4 && READ_LE_UINT16(v7 + 2) != v5)
+			v1 = 1;
+		if (!v1)
+			++v0;
+	} while (v1 != 1);
+
+	_vm->_objectsManager.DERLIGNE = v0;
+	v8 = 1;
+	v13 = _vm->_globals.Max_Ligne_Long;
+	v9 = _vm->_objectsManager.DERLIGNE + 1;
+	do {
+		v11 = v8;
+		if (Ligne[v11].field0 < v13) {
+			if (v8 != v9) {
+				v12 = v8 - 1;
+				Ligne[v11].field6 = Ligne[v12].field6;
+				Ligne[v11].field8 = Ligne[v12].field8;
+			}
+		}
+		++v8;
+	} while (v8 != 400);
+}
+
+int LinesManager::CONTOURNE(int a1, int a2, int a3, int a4, int a5, byte *a6, int a7) {
+	int v7; 
+	int v8; 
+	int i; 
+	byte *v10;
+	int v11;
+	int v12;
+	int v13;
+	byte *v14;
+	int v15;
+	int v16;
+	int j; 
+	byte *v18;
+	int v19;
+	int v20;
+	int k; 
+	byte *v22;
+	int v23; 
+	int v24; 
+	int v25; 
+	byte *v26; 
+	int v27; 
+	int v28; 
+	int v29; 
+	byte *v30; 
+	int v31; 
+	int v32; 
+	int v34; 
+	int v35; 
+	int v36; 
+	int v50;
+
+	v36 = a1;
+	v7 = a2;
+	v8 = a3;
+	if (a1 < a4) {
+		for (i = a2; Ligne[a1].field0 > i; ++i) {
+			v10 = Ligne[a1].fieldC;
+			v11 = READ_LE_UINT16(v10 + 4 * i);
+			v50 = READ_LE_UINT16(v10 + 4 * i + 2);
+			v12 = v8;
+			WRITE_LE_UINT16(a6 + 2 * v12, v11);
+			WRITE_LE_UINT16(a6 + 2 * v12 + 2, v50);
+			WRITE_LE_UINT16(a6 + 2 * v12 + 4, Ligne[a1].field6);
+			v8 += a7;
+		}
+		v34 = a1 + 1;
+		if ((int)(a1 + 1) < a4) {
+			do {
+				v13 = 0;
+				if (Ligne[v34].field0 > 0) {
+					do {
+						v14 = Ligne[v34].fieldC;
+						v15 = READ_LE_UINT16(v14 + 4 * v13);
+						v50 = READ_LE_UINT16(v14 + 4 * v13 + 2);
+						v16 = v8;
+						WRITE_LE_UINT16(a6 + 2 * v16, v15);
+						WRITE_LE_UINT16(a6 + 2 * v16 + 2, v50);
+						WRITE_LE_UINT16(a6 + 2 * v16 + 4, Ligne[v34].field6);
+						v8 += a7;
+						++v13;
+					} while (Ligne[v34].field0 > v13);
+				}
+				++v34;
+			} while (v34 < a4);
+		}
+		v7 = 0;
+		v36 = a4;
+	}
+	if (v36 > a4) {
+		for (j = v7; j > 0; --j) {
+			v18 = Ligne[v36].fieldC;
+			v19 = READ_LE_UINT16(v18 + 4 * j);
+			v50 = READ_LE_UINT16(v18 + 4 * j + 2);
+			v20 = v8;
+			WRITE_LE_UINT16(a6 + 2 * v20, v19);
+			WRITE_LE_UINT16(a6 + 2 * v20 + 2, v50);
+			WRITE_LE_UINT16(a6 + 2 * v20 + 4, Ligne[v36].field8);
+			v8 += a7;
+		}
+		v35 = v36 - 1;
+		if ((int)(v36 - 1) > a4) {
+			do {
+				for (k = Ligne[v35].field0 - 1; k > 0; --k) {
+					v22 = Ligne[v35].fieldC;
+					v23 = READ_LE_UINT16(v22 + 4 * k);
+					v50 = READ_LE_UINT16(v22 + 4 * k + 2);
+					v24 = v8;
+					WRITE_LE_UINT16(a6 + 2 * v24, v23);
+					WRITE_LE_UINT16(a6 + 2 * v24 + 2, v50);
+					WRITE_LE_UINT16(a6 + 2 * v24 + 4, Ligne[v35].field8);
+					v8 += a7;
+				}
+				--v35;
+			} while (v35 > a4);
+		}
+		v7 = Ligne[a4].field0 - 1;
+		v36 = a4;
+	}
+	if (v36 == a4) {
+		if (a5 >= v7) {
+			if (a5 > v7) {
+				v29 = v7;
+				do {
+					v30 = Ligne[a4].fieldC;
+					v31 = READ_LE_UINT16(v30 + 4 * v29);
+					v50 = READ_LE_UINT16(v30 + 4 * v29 + 2);
+					v32 = v8;
+					WRITE_LE_UINT16(a6 + 2 * v32, v31);
+					WRITE_LE_UINT16(a6 + 2 * v32 + 2, v50);
+					WRITE_LE_UINT16(a6 + 2 * v32 + 4, Ligne[a4].field6);
+					v8 += a7;
+					++v29;
+				} while (a5 > v29);
+			}
+		} else {
+			v25 = v7;
+			do {
+				v26 = Ligne[a4].fieldC;
+				v27 = READ_LE_UINT16(v26 + 4 * v25);
+				v50 = READ_LE_UINT16(v26 + 4 * v25 + 2);
+				v28 = v8;
+				WRITE_LE_UINT16(a6 + 2 * v28, v27);
+				WRITE_LE_UINT16(a6 + 2 * v28 + 2, v50);
+				WRITE_LE_UINT16(a6 + 2 * v28 + 4, Ligne[a4].field8);
+				v8 += a7;
+				--v25;
+			} while (a5 < v25);
+		}
+	}
+	return v8;
+}
+
+int LinesManager::CONTOURNE1(int a1, int a2, int a3, int a4, int a5, byte *a6, int a7, int a8, int a9) {
+	int v9; 
+	int v10;
+	int i; 
+	byte *v12;
+	int v13;
+	int v14;
+	int v15;
+	int v16;
+	byte *v17;
+	int v18;
+	int v19;
+	int j; 
+	byte *v21;
+	int v22;
+	int v23;
+	int v24; 
+	int k; 
+	byte *v26;
+	int v27;
+	int v28;
+	int v29;
+	byte *v30;
+	int v31;
+	int v32;
+	int v33;
+	byte *v34;
+	int v35;
+	int v36;
+	int v38;
+	int v39;
+	int v40;
+	int v50;
+
+	v9 = a1;
+	v10 = a2;
+	v40 = a3;
+	if (a4 < a1) {
+		for (i = a2; Ligne[a1].field0 > i; ++i) {
+			v12 = Ligne[a1].fieldC;
+			v13 = READ_LE_UINT16(v12 + 4 * i);
+			v50 = READ_LE_UINT16(v12 + 4 * i + 2);
+			v14 = v40;
+			WRITE_LE_UINT16(a6 + 2 * v14, v13);
+			WRITE_LE_UINT16(a6 + 2 * v14 + 2, v50);
+			WRITE_LE_UINT16(a6 + 2 * v14 + 4, Ligne[a1].field6);
+			v40 += a7;
+		}
+		v15 = a1 + 1;
+		if ((int)(a1 + 1) == a9 + 1)
+			v15 = a8;
+		while (a4 != v15) {
+			v16 = 0;
+			if (Ligne[v15].field0 > 0) {
+				do {
+					v17 = Ligne[v15].fieldC;
+					v18 = READ_LE_UINT16(v17 + 4 * v16);
+					v50 = READ_LE_UINT16(v17 + 4 * v16 + 2);
+					v19 = v40;
+					WRITE_LE_UINT16(a6 + 2 * v19, v18);
+					WRITE_LE_UINT16(a6 + 2 * v19 + 2, v50);
+					WRITE_LE_UINT16(a6 + 2 * v19 + 4, Ligne[v15].field6);
+					v40 += a7;
+					++v16;
+				} while (Ligne[v15].field0 > v16);
+			}
+			++v15;
+			if (a9 + 1 == v15)
+				v15 = a8;
+		}
+		v10 = 0;
+		v9 = a4;
+	}
+	if (a4 > v9) {
+		for (j = v10; j > 0; --j) {
+			v21 = Ligne[v9].fieldC;;
+			v22 = READ_LE_UINT16(v21 + 4 * j);
+			v50 = READ_LE_UINT16(v21 + 4 * j + 2);
+			v23 = v40;
+			WRITE_LE_UINT16(a6 + 2 * v23, v22);
+			WRITE_LE_UINT16(a6 + 2 * v23 + 2, v50);
+			WRITE_LE_UINT16(a6 + 2 * v23 + 4, Ligne[v9].field8);
+			v40 += a7;
+		}
+		v24 = v9 - 1;
+		if (v24 == a8 - 1)
+			v24 = a9;
+		while (a4 != v24) {
+			for (k = Ligne[v24].field0 - 1; k > 0; --k) {
+				v26 = Ligne[v24].fieldC;
+				v27 = READ_LE_UINT16(v26 + 4 * k);
+				v50 = READ_LE_UINT16(v26 + 4 * k + 2);
+				v28 = v40;
+				WRITE_LE_UINT16(a6 + 2 * v28, v27);
+				WRITE_LE_UINT16(a6 + 2 * v28 + 2, v50);
+				WRITE_LE_UINT16(a6 + 2 * v28 + 4, Ligne[v24].field8);
+				v40 += a7;
+			}
+			--v24;
+			if (a8 - 1 == v24)
+				v24 = a9;
+		}
+		v10 = Ligne[a4].field0 - 1;
+		v9 = a4;
+	}
+	if (a4 == v9) {
+		if (a5 >= v10) {
+			if (a5 > v10) {
+				v33 = v10;
+				v39 = a4;
+				do {
+					v34 = Ligne[v39].fieldC;
+					v35 = READ_LE_UINT16(v34 + 4 * v33);
+					v50 = READ_LE_UINT16(v34 + 4 * v33 + 2);
+					v36 = v40;
+					WRITE_LE_UINT16(a6 + 2 * v36, v35);
+					WRITE_LE_UINT16(a6 + 2 * v36 + 2, v50);
+					WRITE_LE_UINT16(a6 + 2 * v36 + 4, Ligne[v39].field6);
+					v40 += a7;
+					++v33;
+				} while (a5 > v33);
+			}
+		} else {
+			v29 = v10;
+			v38 = a4;
+			do {
+				v30 = Ligne[v38].fieldC;
+				v31 = READ_LE_UINT16(v30 + 4 * v29);
+				v50 = READ_LE_UINT16(v30 + 4 * v29 + 2);
+				v32 = v40;
+				WRITE_LE_UINT16(a6 + 2 * v32, v31);
+				WRITE_LE_UINT16(a6 + 2 * v32 + 2, v50);
+				WRITE_LE_UINT16(a6 + 2 * v32 + 4, Ligne[v38].field8);
+				v40 += a7;
+				--v29;
+			} while (a5 < v29);
+		}
+	}
+	return v40;
+}
+
+int LinesManager::MIRACLE(int a1, int a2, int a3, int a4, int a5) {
+	int v5; 
+	int v6; 
+	int v7; 
+	int v8; 
+	int v9; 
+	int v10;
+	int i; 
+	int v12;
+	int v13;
+	int j; 
+	int v15;
+	int v16;
+	int k; 
+	int v18;
+	int v19;
+	int l; 
+	int v21;
+	int v22; 
+	int v23; 
+	int v24; 
+	int v25;
+	int v26;
+	int v27; 
+	int v28;
+	int v29;
+	int v30; 
+	int v31;
+	int v32;
+	int v33; 
+	int v35; 
+	int v36; 
+	int v37; 
+	int v38; 
+	int v39; 
+	int v40; 
+	int v41; 
+	int v42; 
+	int v43; 
+	int v44; 
+	int v45; 
+	int v46; 
+	int v47; 
+	int v48; 
+	int v49; 
+	int v50; 
+	int v51; 
+
+	v5 = a1;
+	v6 = a2;
+	v50 = a3;
+	v7 = a5;
+	if (colision2_ligne(a1, a2, &v51, &v50, 0, TOTAL_LIGNES) == 1) {
+		v8 = Ligne[v50].field4;
+		if (v8 == 1)
+			v6 = a2 - 2;
+		if (v8 == 2) {
+			v6 -= 2;
+			v5 = a1 + 2;
+		}
+		if (v8 == 3)
+			v5 += 2;
+		if (v8 == 4) {
+			v6 += 2;
+			v5 += 2;
+		}
+		if (v8 == 5)
+			v6 += 2;
+		if (v8 == 6) {
+			v6 += 2;
+			v5 -= 2;
+		}
+		if (v8 == 7)
+			v5 -= 2;
+		if (v8 == 8) {
+			v6 -= 2;
+			v5 -= 2;
+		}
+	}
+	v41 = v5;
+	v40 = v6;
+	v9 = 0;
+	v10 = v40;
+	for (i = v40; v40 + 200 > v10; i = v10) {
+		if (colision2_ligne(v41, i, &v49, &v48, 0, _vm->_objectsManager.DERLIGNE) == 1 && v48 <= _vm->_objectsManager.DERLIGNE)
+			break;
+		v49 = 0;
+		v48 = -1;
+		++v9;
+		++v10;
+	}
+	v37 = v9;
+	v12 = 0;
+	v13 = v40;
+	for (j = v40; v40 - 200 < v13; j = v13) {
+		if (colision2_ligne(v41, j, &v47, &v46, 0, _vm->_objectsManager.DERLIGNE) == 1 && v46 <= _vm->_objectsManager.DERLIGNE)
+			break;
+		v47 = 0;
+		v46 = -1;
+		++v12;
+		--v13;
+	}
+	v39 = v12;
+	v15 = 0;
+	v16 = v41;
+	for (k = v41; v41 + 200 > v16; k = v16) {
+		if (colision2_ligne(k, v40, &v45, &v44, 0, _vm->_objectsManager.DERLIGNE) == 1 && v44 <= _vm->_objectsManager.DERLIGNE)
+			break;
+		v45 = 0;
+		v44 = -1;
+		++v15;
+		++v16;
+	}
+	v38 = v15;
+	v18 = 0;
+	v19 = v41;
+	for (l = v41; v41 - 200 < v19; l = v19) {
+		if (colision2_ligne(l, v40, &v43, &v42, 0, _vm->_objectsManager.DERLIGNE) == 1 && v42 <= _vm->_objectsManager.DERLIGNE)
+			break;
+		v43 = 0;
+		v42 = -1;
+		++v18;
+		--v19;
+	}
+	if (a4 > v50) {
+		if (v46 != -1 && v46 <= v50)
+			v46 = -1;
+		if (v44 != -1 && v50 >= v44)
+			v44 = -1;
+		if (v48 != -1 && v50 >= v48)
+			v48 = -1;
+		if (v42 != -1 && v50 >= v42)
+			v42 = -1;
+		if (v46 != -1 && a4 < v46)
+			v46 = -1;
+		if (v44 != -1 && a4 < v44)
+			v44 = -1;
+		if (v48 != -1 && a4 < v48)
+			v48 = -1;
+		if (v42 != -1 && a4 < v42)
+			v42 = -1;
+	}
+	if (a4 < v50) {
+		if (v46 != -1 && v46 >= v50)
+			v46 = -1;
+		if (v44 != -1 && v50 <= v44)
+			v44 = -1;
+		if (v48 != -1 && v50 <= v48)
+			v48 = -1;
+		if (v42 != -1 && v50 <= v42)
+			v42 = -1;
+		if (v46 != -1 && a4 > v46)
+			v46 = -1;
+		if (v44 != -1 && a4 > v44)
+			v44 = -1;
+		if (v48 != -1 && a4 > v48)
+			v48 = -1;
+		if (v42 != -1 && a4 > v42)
+			v42 = -1;
+	}
+	if (v46 != -1 || v44 != -1 || v48 != -1 || v42 != -1) {
+		v21 = 0;
+		if (a4 > v50) {
+			if (v48 <= v46 && v44 <= v46 && v42 <= v46 && v46 > v50)
+				v21 = 1;
+			if (v48 <= v44 && v46 <= v44 && v42 <= v44 && v50 < v44)
+				v21 = 3;
+			if (v46 <= v48 && v44 <= v48 && v42 <= v48 && v50 < v48)
+				v21 = 5;
+			if (v48 <= v42 && v44 <= v42 && v46 <= v42 && v50 < v42)
+				v21 = 7;
+		}
+		if (a4 < v50) {
+			if (v46 == -1)
+				v46 = 1300;
+			if (v44 == -1)
+				v44 = 1300;
+			if (v48 == -1)
+				v48 = 1300;
+			if (v42 == -1)
+				v42 = 1300;
+			if (v46 != 1300 && v48 >= v46 && v44 >= v46 && v42 >= v46 && v46 < v50)
+				v21 = 1;
+			if (v44 != 1300 && v48 >= v44 && v46 >= v44 && v42 >= v44 && v50 > v44)
+				v21 = 3;
+			if (v48 != 1300 && v46 >= v48 && v44 >= v48 && v42 >= v48 && v50 > v48)
+				v21 = 5;
+			if (v42 != 1300 && v48 >= v42 && v44 >= v42 && v46 >= v42 && v50 > v42)
+				v21 = 7;
+		}
+		if (v21) {
+			if (v21 == 1) {
+				v36 = v46;
+				v35 = v47;
+			}
+			if (v21 == 3) {
+				v36 = v44;
+				v35 = v45;
+			}
+			if (v21 == 5) {
+				v36 = v48;
+				v35 = v49;
+			}
+			if (v21 == 7) {
+				v36 = v42;
+				v35 = v43;
+			}
+			if (v21 == 1) {
+				v22 = 0;
+				if (v39 > 0) {
+					do {
+						if (colision2_ligne(v41, v40 - v22, &v47, &v46, _vm->_objectsManager.DERLIGNE + 1, TOTAL_LIGNES) == 1
+						        && _vm->_objectsManager.DERLIGNE < v46) {
+									v23 = GENIAL(v46, v47, v41, v40 - v22, v41, v40 - v39, v7, (byte *)&_vm->_globals.super_parcours[0], 4);
+							if (v23 == -1)
+								return 0;
+							v7 = v23;
+							if (_vm->_globals.NVPY != -1)
+								v22 = _vm->_globals.NVPY - v40;
+						}
+						v24 = v7;
+						_vm->_globals.super_parcours[v24] = v41;
+						_vm->_globals.super_parcours[v24 + 1] = v40 - v22;
+						_vm->_globals.super_parcours[v24 + 2] = 1;
+						_vm->_globals.super_parcours[v24 + 3] = 0;
+						v7 += 4;
+						++v22;
+					} while (v39 > v22);
+				}
+LABEL_186:
+				NV_LIGNEDEP = v36;
+				NV_LIGNEOFS = v35;
+				NV_POSI = v7;
+				return 1;
+			}
+			if (v21 == 5) {
+				v25 = 0;
+				if (v37 > 0) {
+					do {
+						if (colision2_ligne(v41, v25 + v40, &v47, &v46, _vm->_objectsManager.DERLIGNE + 1, TOTAL_LIGNES) == 1
+						        && _vm->_objectsManager.DERLIGNE < v46) {
+							v26 = GENIAL(v46, v47, v41, v25 + v40, v41, v37 + v40, v7, (byte *)&_vm->_globals.super_parcours[0], 4);
+							if (v26 == -1)
+								return 0;
+							v7 = v26;
+							if (_vm->_globals.NVPY != -1)
+								v25 = v40 - _vm->_globals.NVPY;
+						}
+						v27 = v7;
+						_vm->_globals.super_parcours[v27] = v41;
+						_vm->_globals.super_parcours[v27 + 1] = v25 + v40;
+						_vm->_globals.super_parcours[v27 + 2] = 5;
+						_vm->_globals.super_parcours[v27 + 3] = 0;
+						v7 += 4;
+						++v25;
+					} while (v37 > v25);
+				}
+				goto LABEL_186;
+			}
+			if (v21 == 7) {
+				v28 = 0;
+				if (v18 > 0) {
+					do {
+						if (colision2_ligne(v41 - v28, v40, &v47, &v46, _vm->_objectsManager.DERLIGNE + 1, TOTAL_LIGNES) == 1
+						        && _vm->_objectsManager.DERLIGNE < v46) {
+							v29 = GENIAL(v46, v47, v41 - v28, v40, v41 - v18, v40, v7, (byte *)&_vm->_globals.super_parcours[0], 4);
+							if (v29 == -1)
+								return 0;
+							v7 = v29;
+							if (_vm->_globals.NVPX != -1)
+								v28 = v41 - _vm->_globals.NVPX;
+						}
+						v30 = v7;
+						_vm->_globals.super_parcours[v30] = v41 - v28;
+						_vm->_globals.super_parcours[v30 + 1] = v40;
+						_vm->_globals.super_parcours[v30 + 2] = 7;
+						_vm->_globals.super_parcours[v30 + 3] = 0;
+						v7 += 4;
+						++v28;
+					} while (v18 > v28);
+				}
+				goto LABEL_186;
+			}
+			if (v21 == 3) {
+				v31 = 0;
+				if (v38 > 0) {
+					do {
+						if (colision2_ligne(v31 + v41, v40, &v47, &v46, _vm->_objectsManager.DERLIGNE + 1, TOTAL_LIGNES) == 1
+						        && _vm->_objectsManager.DERLIGNE < v46) {
+							v32 = GENIAL(v46, v47, v31 + v41, v40, v38 + v41, v40, v7, (byte *)&_vm->_globals.super_parcours[0], 4);
+							if (v32 == -1)
+								return 0;
+							v7 = v32;
+							if (_vm->_globals.NVPX != -1)
+								v31 = _vm->_globals.NVPX - v41;
+						}
+						v33 = v7;
+						_vm->_globals.super_parcours[v33] = v31 + v41;
+						_vm->_globals.super_parcours[v33 + 1] = v40;
+						_vm->_globals.super_parcours[v33 + 2] = 3;
+						_vm->_globals.super_parcours[v33 + 3] = 0;
+						v7 += 4;
+						++v31;
+					} while (v38 > v31);
+				}
+				goto LABEL_186;
+			}
+		}
+	}
+	return 0;
+}
+
+int LinesManager::GENIAL(int a1, int a2, int a3, int a4, int a5, int a6, int a7, byte *a8, int a9) {
+	int v9; 
+	byte *v10;
+	int v11; 
+	byte *v12; 
+	byte *v13; 
+	int v14; 
+	int v15;
+	byte *v16; 
+	int v17;
+	int v18; 
+	int v19; 
+	int v20;
+	int v21;
+	int v22;
+	int v23; 
+	int v24; 
+	int v25;
+	int v26;
+	int v27; 
+	byte *v28; 
+	int v29;
+	int v30;
+	int v31; 
+	int v32;
+	int v33;
+	int v34;
+	int v35 = 0;
+	int v36 = 0;
+	int v37;
+	int v38;
+	int v40; 
+	int v41;
+	int v42 = 0;
+	int v43 = 0;
+	int v44 = 0; 
+	int v45 = 0; 
+	int v46 = 0;
+	int v47 = 0;
+	int v48 = 0;
+	int v49 = 0; 
+	int v50; 
+	void *v51;
+	int v52; 
+	int v53; 
+	int v54; 
+	int v55; 
+	int v56; 
+	int v57; 
+	int v58;
+	int v59;
+	int v60; 
+	int v61; 
+	int v62; 
+	int v63; 
+	int v64; 
+	int v65; 
+	int v66 = 0;
+	int v67;
+	int v68 = 0;
+	int v69;
+	int v70 = 0;
+	int v71;
+	int v72 = 0;
+	int v73;
+	int v74;
+	int v75;
+	int v76;
+	int v77 = 0; 
+	int v78 = 0; 
+	int v79 = 0; 
+	int v80; 
+	int v81; 
+	int v82; 
+	int v83; 
+	int v84; 
+	int v85;
+	int v86; 
+	int v87; 
+	int v88; 
+	int v89; 
+	int i; 
+	int v91;
+	int v92;
+	int v93;
+	int v94;
+	int v95;
+	int v96;
+	int v97;
+	int v98;
+	int v99;
+	int v100;
+	int v101;
+
+	v99 = a7;
+	v80 = -1;
+	++_vm->_globals.STOP_BUG;
+	if (_vm->_globals.STOP_BUG > 10) {
+		v9 = a7;
+LABEL_112:
+		WRITE_LE_UINT16(a8 + 2 * v9, (uint16)-1);
+		WRITE_LE_UINT16(a8 + 2 * v9 + 2, (uint16)-1);
+		WRITE_LE_UINT16(a8 + 2 * v9 + 4, (uint16)-1);
+		return -1;
+	}
+	v10 = Ligne[a1].fieldC;
+	v98 = READ_LE_UINT16(v10);
+	v97 = READ_LE_UINT16(v10 + 2);
+	v92 = a1;
+
+	while (1) {
+		v86 = v92 - 1;
+		v11 = 2 * Ligne[v92 - 1].field0;
+		v12 = Ligne[v92 - 1].fieldC;
+		if (v12 == PTRNUL)
+			break;
+		while (READ_LE_UINT16(v12 + 2 * v11 - 4) != v98 || v97 != READ_LE_UINT16(v12 + 2 * v11 - 2)) {
+			--v86;
+			if (_vm->_objectsManager.DERLIGNE - 1 != v86) {
+				v11 = 2 * Ligne[v86].field0;
+				v12 = Ligne[v86].fieldC;
+				if (v12 != PTRNUL)
+					continue;
+			}
+			goto LABEL_11;
+		}
+		v92 = v86;
+		v98 = READ_LE_UINT16(v12);
+		v97 = READ_LE_UINT16(v12 + 2);
+	}
+LABEL_11:
+	v13 = Ligne[a1].fieldC;
+	v14 = 2 * Ligne[a1].field0;
+	v95 = READ_LE_UINT16(v13 + 2 * v14 - 4);
+	v93 = READ_LE_UINT16(v13 + 2 * v14 - 2);
+	v91 = a1;
+	while (1) {
+		v87 = v91 + 1;
+		v15 = 2 * Ligne[v91 + 1].field0;
+		v16 = Ligne[v91 + 1].fieldC;
+		if (PTRNUL == v16)
+			break;
+		while (1) {
+			v65 = v15;
+			v17 = READ_LE_UINT16(v16 + 2 * v15 - 4);
+			if (READ_LE_UINT16(v16) == v95) {
+				if (v93 == READ_LE_UINT16(v16 + 2))
+					break;
+			}
+			++v87;
+			if (v87 != TOTAL_LIGNES + 1) {
+				v15 = 2 * Ligne[v87].field0;
+				v16 = Ligne[v87].fieldC;
+				if (v16 != PTRNUL)
+					continue;
+			}
+			goto LABEL_17;
+		}
+		v91 = v87;
+		v95 = v17;
+		v93 = READ_LE_UINT16(v16 + 2 * v65 - 2);
+	}
+LABEL_17:
+	v18 = a3 - a5;
+	if (a3 - a5 < 0)
+		v18 = -v18;
+	v58 = v18 + 1;
+	v19 = a4 - a6;
+	if (a4 - a6 < 0)
+		v19 = -v19;
+	v85 = v19 + 1;
+	v20 = v19 + 1;
+	if (v58 > v20)
+		v85 = v18 + 1;
+	v84 = 1000 * v58 / v85;
+	v83 = 1000 * v20 / v85;
+	v21 = 1000 * a3;
+	v22 = 1000 * a4;
+	v82 = v21 / 1000;
+	v81 = v22 / 1000;
+	if (a5 < a3)
+		v84 = -v84;
+	if (a6 < a4)
+		v83 = -v83;
+	if (v85 > 800)
+		v85 = 800;
+	memset(_vm->_globals.BufLig, 0, 0x7D0u);
+	v23 = 0;
+	v88 = 0;
+	if (v85 + 1 > 0) {
+		v51 = _vm->_globals.BufLig;
+		do {
+			v24 = v23;
+			*((uint16 *)v51 + v24) = v82;
+			*((uint16 *)v51 + v24 + 1) = v81;
+			v21 += v84;
+			v22 += v83;
+			v82 = v21 / 1000;
+			v81 = v22 / 1000;
+			v23 += 2;
+			++v88;
+		} while (v88 < v85 + 1);
+	}
+	v25 = v23 - 2;
+	v26 = 0;
+	v89 = v85 + 1;
+	if ((int)(v85 + 1) > 0) {
+		do {
+			v96 = READ_LE_UINT16((uint16 *)_vm->_globals.BufLig + v25);
+			v94 = READ_LE_UINT16((uint16 *)_vm->_globals.BufLig + v25 + 1);
+			if (colision2_ligne(v96, v94, &v101, &v100, v92, v91) == 1 && _vm->_objectsManager.DERLIGNE < v100) {
+				v80 = v100;
+				v77 = v101;
+				v78 = v96;
+				v79 = v94;
+				v26 = 1;
+			}
+			if (v26 == 1)
+				break;
+			v25 -= 2;
+			--v89;
+		} while (v89 > 0);
+	}
+	for (i = v92; i < v91 + 1; ++i) {
+		v27 = 2 * Ligne[i].field0;
+		v28 = Ligne[i].fieldC;
+		if (PTRNUL == v28)
+			error("erreur dans da routine genial");
+		v29 = *(uint16 *)v28;
+		v30 = READ_LE_UINT16(v28 + 2);
+		v59 = READ_LE_UINT16(v28 + 2);
+		v31 = v27;
+		v32 = READ_LE_UINT16(v28 + 2 * v27 - 4);
+		v33 = READ_LE_UINT16(v28 + 2 * v31 - 2);
+		if (i == v92) {
+			v72 = v33;
+			if (v30 <= v33)
+				v72 = v30;
+			v70 = v33;
+			if (v59 >= v33)
+				v70 = v59;
+			v68 = v32;
+			if (v29 <= v32)
+				v68 = v29;
+			v66 = v32;
+			if (v29 >= v32)
+				v66 = v29;
+		} else {
+			if (v59 < v33 && v59 < v72)
+				v72 = v59;
+			if (v33 < v59 && v33 < v72)
+				v72 = v33;
+			if (v59 > v33 && v59 > v70)
+				v70 = v59;
+			if (v33 > v59 && v33 > v70)
+				v70 = v33;
+			if (v29 < v32 && v68 > v29)
+				v68 = v29;
+			if (v32 < v29 && v68 > v32)
+				v68 = v32;
+			if (v29 > v32 && v66 < v29)
+				v66 = v29;
+			if (v32 > v29 && v66 < v32)
+				v66 = v32;
+		}
+	}
+	v69 = v68 - 2;
+	v73 = v72 - 2;
+	v67 = v66 + 2;
+	v71 = v70 + 2;
+	if (a5 >= v69 && a5 <= v67 && a6 >= v73 && a6 <= v71) {
+		v34 = a6;
+		v76 = -1;
+		do {
+			--v34;
+			v60 = colision2_ligne(a5, v34, &v101, &v100, v92, v91);
+			if (v60 == 1)
+				v76 = v100;
+			if (!v34 || v73 > v34)
+				v60 = 1;
+		} while (v60 != 1);
+		v35 = a6;
+		v75 = -1;
+		do {
+			++v35;
+			v61 = colision2_ligne(a5, v35, &v101, &v100, v92, v91);
+			if (v61 == 1)
+				v75 = v100;
+			if (_vm->_globals.Max_Perso_Y <= v35 || v71 <= v35)
+				v61 = 1;
+		} while (v61 != 1);
+		v36 = a5;
+		v74 = -1;
+		do {
+			++v36;
+			v62 = colision2_ligne(v36, a6, &v101, &v100, v92, v91);
+			if (v62 == 1)
+				v74 = v100;
+			if (_vm->_graphicsManager.max_x <= v36 || v67 <= v36)
+				v62 = 1;
+		} while (v62 != 1);
+		v37 = a5;
+		v38 = -1;
+		do {
+			--v37;
+			v63 = colision2_ligne(v37, a6, &v101, &v100, v92, v91);
+			if (v63 == 1)
+				v38 = v100;
+			if (v37 <= 0 || v69 >= v37)
+				v63 = 1;
+		} while (v63 != 1);
+		if (v74 != -1 && v38 != -1 && v76 != -1 && v75 != -1) {
+			v9 = a7;
+			goto LABEL_112;
+		}
+	}
+	if (v78 < a3 - 1 || v78 > a3 + 1 || v79 < a4 - 1 || v79 > a4 + 1) {
+		_vm->_globals.NVPX = v78;
+		_vm->_globals.NVPY = v79;
+		if (a1 < v80) {
+			v40 = v80 - a1;
+			if (v80 - a1 < 0)
+				v40 = -v40;
+			v41 = v40;
+			v42 = a1;
+			v43 = 0;
+			v52 = v92 - 1;
+			do {
+				if (v52 == v42)
+					v42 = v91;
+				++v43;
+				--v42;
+				if (v52 == v42)
+					v42 = v91;
+			} while (v80 != v42);
+			if (v41 == v43) {
+				v44 = Ligne[a1].field0 / 2;
+				v54 = Ligne[a1].field0 / 2;
+				if (v44 < 0)
+					v54 = -v44;
+				if (a2 > v54) {
+					v55 = Ligne[a1].field0 / 2;
+					if (v44 < 0)
+						v55 = -v44;
+					if (a2 >= v55)
+						v99 = CONTOURNE(a1, a2, a7, v80, v77, a8, a9);
+				} else {
+					v99 = CONTOURNE1(a1, a2, a7, v80, v77, a8, a9, v92, v91);
+				}
+			}
+			if (v41 < v43)
+				v99 = CONTOURNE(a1, a2, v99, v80, v77, a8, a9);
+			if (v43 < v41)
+				v99 = CONTOURNE1(a1, a2, v99, v80, v77, a8, a9, v92, v91);
+		}
+		if (a1 > v80) {
+			v45 = a1 - v80;
+			if (a1 - v80 < 0)
+				v45 = -v45;
+			v46 = v45;
+			v47 = a1;
+			v48 = 0;
+			v53 = v91 + 1;
+			do {
+				if (v53 == v47)
+					v47 = v92;
+				++v48;
+				++v47;
+				if (v53 == v47)
+					v47 = v92;
+			} while (v80 != v47);
+			if (v46 == v48) {
+				v49 = Ligne[a1].field0 / 2;
+				v56 = Ligne[a1].field0 / 2;
+				if (v49 < 0)
+					v56 = -v49;
+				if (a2 > v56) {
+					v57 = Ligne[a1].field0 / 2;
+					if (v49 < 0)
+						v57 = -v49;
+					if (a2 >= v57)
+						v99 = CONTOURNE1(a1, a2, v99, v80, v77, a8, a9, v92, v91);
+				} else {
+					v99 = CONTOURNE(a1, a2, v99, v80, v77, a8, a9);
+				}
+			}
+			if (v46 < v48)
+				v99 = CONTOURNE(a1, a2, v99, v80, v77, a8, a9);
+			if (v48 < v46)
+				v99 = CONTOURNE1(a1, a2, v99, v80, v77, a8, a9, v92, v91);
+		}
+		if (a1 == v80)
+			v99 = CONTOURNE(a1, a2, v99, a1, v77, a8, a9);
+		do {
+			v64 = colision2_ligne(_vm->_globals.NVPX, _vm->_globals.NVPY, &v101, &v100, _vm->_objectsManager.DERLIGNE + 1, TOTAL_LIGNES);
+			if (v64 == 1) {
+				v50 = 16 * v100;
+				if (*(uint16 *)&Ligne[v50 + 4] == 1)
+					--_vm->_globals.NVPY;
+				if (*(uint16 *)&Ligne[v50 + 4] == 2) {
+					--_vm->_globals.NVPY;
+					++_vm->_globals.NVPX;
+				}
+				if (*(uint16 *)&Ligne[v50 + 4] == 3)
+					++_vm->_globals.NVPX;
+				if (*(uint16 *)&Ligne[v50 + 4] == 4) {
+					++_vm->_globals.NVPY;
+					++_vm->_globals.NVPX;
+				}
+				if (*(uint16 *)&Ligne[v50 + 4] == 5)
+					++_vm->_globals.NVPY;
+				if (*(uint16 *)&Ligne[v50 + 4] == 6) {
+					++_vm->_globals.NVPY;
+					--_vm->_globals.NVPX;
+				}
+				if (*(uint16 *)&Ligne[v50 + 4] == 7)
+					--_vm->_globals.NVPX;
+				if (*(uint16 *)&Ligne[v50 + 4] == 8) {
+					--_vm->_globals.NVPY;
+					--_vm->_globals.NVPX;
+				}
+			}
+		} while (v64);
+	} else {
+		_vm->_globals.NVPX = -1;
+		_vm->_globals.NVPY = -1;
+	}
+	return v99;
+}
+
+// TODO: method casting int arrays as byte pointers. Double-check later whether
+// we can convert the return to a uint16 *
+byte *LinesManager::PARCOURS2(int a1, int a2, int a3, int a4) {
+	int v4; 
+	int v5; 
+	int v6; 
+	int v7; 
+	int v8; 
+	int v9; 
+	int v10;
+	int v11; 
+	int v12; 
+	int v13; 
+	int v14; 
+	int v15; 
+	int v16; 
+	int v17; 
+	int v18; 
+	int v19; 
+	int v20;
+	int v21; 
+	int v22;
+	int v23; 
+	int v24; 
+	int v25; 
+	int v26;
+	int v27; 
+	int v28; 
+	int v29; 
+	int v31;
+	int v32; 
+	int v33; 
+	int v34; 
+	int v35; 
+	int v36;
+	int v37;
+	int v38;
+	int v39;
+	int v40; 
+	int v41; 
+	int v42;
+	int v43; 
+	int v44; 
+	int v45; 
+	int v46;
+	int v47;
+	int v48; 
+	int v49; 
+	int v50; 
+	int v51;
+	int v52; 
+	int v53; 
+	int v54; 
+	int v55;
+	int v56;
+	int v57; 
+	int v58;
+	int v59; 
+	int v60;
+	int v61; 
+	int v62; 
+	int v63;
+	int v64; 
+	int v65; 
+	int v66; 
+	int v67;
+	int v68;
+	int i;
+	byte *v70; 
+	int v71; 
+	int v72; 
+	int j; 
+	byte *v74;
+	int v75; 
+	int v76;
+	int v77; 
+	int v78; 
+	int v79; 
+	int v80;
+	byte *v81; 
+	int v82; 
+	int v83; 
+	byte *v84;
+	int v85; 
+	int v86;
+	int v87; 
+	int v88; 
+	int v89; 
+	int v90; 
+	byte *v91; 
+	int v92; 
+	int v93; 
+	int v94;
+	byte *v95; 
+	int v96; 
+	int v97;
+	int v98; 
+	int v99; 
+	int v100; 
+	int v101; 
+	int v102; 
+	int v103; 
+	int v104;
+	int v105; 
+	int v106; 
+	int v107; 
+	int v108;
+	int v109;
+	int v110; 
+	int v111; 
+	int v112; 
+	int v113; 
+	int v114; 
+	int v115; 
+	int v116;
+	int v117; 
+	int v118 = 0; 
+	int v119 = 0; 
+	int v120; 
+	int v121; 
+	int v122;
+	int v123; 
+	int v124; 
+	int v125;
+	int v126; 
+	int v127 = 0;
+	int v128 = 0; 
+	int v129 = 0; 
+	int v130 = 0; 
+	int v131; 
+	int v132; 
+	int v133; 
+	int v134; 
+	int v135;
+	int v136; 
+	int v137 = 0; 
+	int v138 = 0;
+	int v139 = 0;
+	int v140 = 0;
+	int v141; 
+	int v142 = 0;
+	int v143 = 0; 
+	int v144 = 0; 
+	int v145 = 0; 
+
+	v123 = a3;
+	v122 = a4;
+	v121 = 0;
+	v120 = 0;
+	v115 = 0;
+	v114 = 0;
+	v113 = 0;
+	v111 = 0;
+	if (a4 <= 24)
+		v122 = 25;
+	if (!_vm->_globals.NOT_VERIF) {
+		v4 = a1 - _vm->_globals.old_x1_65;
+		if (v4 < 0)
+			v4 = -v4;
+		if (v4 <= 4) {
+			v5 = a2 - _vm->_globals.old_y1_66;
+			if (v5 < 0)
+				v5 = -v5;
+			if (v5 <= 4) {
+				v6 = _vm->_globals.old_x2_67 - a3;
+				if (v6 < 0)
+					v6 = -v6;
+				if (v6 <= 4) {
+					v7 = _vm->_globals.old_y2_68 - v122;
+					if (v7 < 0)
+						v7 = -v7;
+					if (v7 <= 4)
+						return PTRNUL;
+				}
+			}
+		}
+		v8 = a1 - a3;
+		if (v8 < 0)
+			v8 = -v8;
+		if (v8 <= 4) {
+			v9 = a2 - v122;
+			if (v9 < 0)
+				v9 = -v9;
+			if (v9 <= 4)
+				return PTRNUL;
+		}
+		if (_vm->_globals.old_z_69 > 0 && _vm->_objectsManager.NUMZONE > 0 && _vm->_globals.old_z_69 == _vm->_objectsManager.NUMZONE)
+			return PTRNUL;
+	}
+	_vm->_globals.NOT_VERIF = 0;
+	_vm->_globals.old_z_69 = _vm->_objectsManager.NUMZONE;
+	_vm->_globals.old_x1_65 = a1;
+	_vm->_globals.old_x2_67 = a3;
+	_vm->_globals.old_y1_66 = a2;
+	_vm->_globals.old_y2_68 = v122;
+	_vm->_globals.STOP_BUG = 0;
+	v112 = 0;
+	if (a3 <= 19)
+		v123 = 20;
+	if (v122 <= 19)
+		v122 = 20;
+	if (v123 > _vm->_graphicsManager.max_x - 10)
+		v123 = _vm->_graphicsManager.max_x - 10;
+	if (v122 > _vm->_globals.Max_Perso_Y)
+		v122 = _vm->_globals.Max_Perso_Y;
+	v10 = a1 - v123;
+	if (v10 < 0)
+		v10 = -v10;
+	if (v10 <= 3) {
+		v11 = a2 - v122;
+		if (v11 < 0)
+			v11 = -v11;
+		if (v11 <= 3)
+			return PTRNUL;
+	}
+	v12 = 0;
+error("TODO: Fix v141/v136 - they look like arrays, not a single int");
+	do {
+		v13 = v12;
+		*(&v141 + v13) = -1;
+		*(&v136 + v13) = 0;
+		*(&v131 + v13) = 1300;
+		*(&v126 + v13) = 1300;
+		++v12;
+	} while (v12 <= 8);
+	if (PARC_PERS(a1, a2, v123, v122, -1, -1, 0) != 1) {
+		v14 = 0;
+		v15 = v122;
+		if (_vm->_graphicsManager.max_y > v122) {
+			v16 = 5;
+			do {
+				v101 = v16;
+				v17 = colision2_ligne(v123, v15, &v139, &v144, 0, _vm->_objectsManager.DERLIGNE);
+				v16 = v101;
+				if (v17 == 1 && *(&v141 + v101) <= _vm->_objectsManager.DERLIGNE)
+					break;
+				*(&v136 + v101) = 0;
+				*(&v141 + v101) = -1;
+				++v14;
+				++v15;
+			} while (_vm->_graphicsManager.max_y > v15);
+		}
+		v134 = v14;
+		v18 = 0;
+		v19 = v122;
+		if (_vm->_graphicsManager.min_y < v122) {
+			v20 = 1;
+			do {
+				v102 = v20;
+				v21 = colision2_ligne(v123, v19, &v137, &v142, 0, _vm->_objectsManager.DERLIGNE);
+				v20 = v102;
+				if (v21 == 1 && *(&v141 + v102) <= _vm->_objectsManager.DERLIGNE)
+					break;
+				*(&v136 + v102) = 0;
+				*(&v141 + v102) = -1;
+				if (v134 < v18) {
+					if (v144 != -1)
+						break;
+				}
+				++v18;
+				--v19;
+			} while (_vm->_graphicsManager.min_y < v19);
+		}
+		v132 = v18;
+		v22 = 0;
+		v23 = v123;
+		if (_vm->_graphicsManager.max_x > v123) {
+			v24 = 3;
+			do {
+				v103 = v24;
+				v25 = colision2_ligne(v23, v122, &v138, &v143, 0, _vm->_objectsManager.DERLIGNE);
+				v24 = v103;
+				if (v25 == 1 && *(&v141 + v103) <= _vm->_objectsManager.DERLIGNE)
+					break;
+				*(&v136 + v103) = 0;
+				*(&v141 + v103) = -1;
+				++v22;
+				if (v132 < v22) {
+					if (v142 != -1)
+						break;
+				}
+				if (v134 < v22 && v144 != -1)
+					break;
+				++v23;
+			} while (_vm->_graphicsManager.max_x > v23);
+		}
+		v133 = v22;
+		v26 = 0;
+		v27 = v123;
+		if (_vm->_graphicsManager.min_x < v123) {
+			v28 = 7;
+			do {
+				v104 = v28;
+				v29 = colision2_ligne(v27, v122, &v140, &v145, 0, _vm->_objectsManager.DERLIGNE);
+				v28 = v104;
+				if (v29 == 1 && *(&v141 + v104) <= _vm->_objectsManager.DERLIGNE)
+					break;
+				*(&v136 + v104) = 0;
+				*(&v141 + v104) = -1;
+				++v26;
+				if (v132 < v26) {
+					if (v142 != -1)
+						break;
+				}
+				if (v134 < v26 && v144 != -1)
+					break;
+				if (v133 < v26 && v143 != -1)
+					break;
+				--v27;
+			} while (_vm->_graphicsManager.min_x < v27);
+		}
+		v135 = v26;
+		if (v142 < 0 || _vm->_objectsManager.DERLIGNE < v142)
+			v142 = -1;
+		if (v143 < 0 || _vm->_objectsManager.DERLIGNE < v143)
+			v143 = -1;
+		if (v144 < 0 || _vm->_objectsManager.DERLIGNE < v144)
+			v144 = -1;
+		if (v145 < 0 || _vm->_objectsManager.DERLIGNE < v145)
+			v145 = -1;
+		if (v142 < 0)
+			v132 = 1300;
+		if (v143 < 0)
+			v133 = 1300;
+		if (v144 < 0)
+			v134 = 1300;
+		if (v145 < 0)
+			v135 = 1300;
+		if (v142 == -1 && v143 == -1 && v144 == -1 && v145 == -1)
+			return PTRNUL;
+		v31 = 0;
+		if (v144 != -1 && v132 >= v134 && v133 >= v134 && v135 >= v134) {
+			v121 = v144;
+			v120 = v139;
+			v31 = 1;
+		}
+		if (v142 != -1 && !v31 && v134 >= v132 && v133 >= v132 && v135 >= v132) {
+			v121 = v142;
+			v120 = v137;
+			v31 = 1;
+		}
+		if (v143 != -1 && !v31 && v132 >= v133 && v134 >= v133 && v135 >= v133) {
+			v121 = v143;
+			v120 = v138;
+			v31 = 1;
+		}
+		if (v145 != -1 && !v31 && v134 >= v135 && v133 >= v135 && v132 >= v135) {
+			v121 = v145;
+			v120 = v140;
+		}
+		v32 = 0;
+		do {
+			v33 = v32;
+			*(&v141 + v33) = -1;
+			*(&v136 + v33) = 0;
+			*(&v131 + v33) = 1300;
+			*(&v126 + v33) = 1300;
+			++v32;
+		} while (v32 <= 8);
+		v34 = 0;
+		v35 = a2;
+		if (_vm->_graphicsManager.max_y > a2) {
+			v36 = 5;
+			do {
+				v105 = v36;
+				v37 = colision2_ligne(a1, v35, &v139, &v144, 0, _vm->_objectsManager.DERLIGNE);
+				v36 = v105;
+				if (v37 == 1 && *(&v141 + v105) <= _vm->_objectsManager.DERLIGNE)
+					break;
+				*(&v136 + v105) = 0;
+				*(&v141 + v105) = -1;
+				++v34;
+				++v35;
+			} while (_vm->_graphicsManager.max_y > v35);
+		}
+		v134 = v34 + 1;
+		v38 = 0;
+		v39 = a2;
+		if (_vm->_graphicsManager.min_y < a2) {
+			v40 = 1;
+			do {
+				v106 = v40;
+				v41 = colision2_ligne(a1, v39, &v137, &v142, 0, _vm->_objectsManager.DERLIGNE);
+				v40 = v106;
+				if (v41 == 1 && *(&v141 + v106) <= _vm->_objectsManager.DERLIGNE)
+					break;
+				*(&v136 + v106) = 0;
+				*(&v141 + v106) = -1;
+				++v38;
+				if (v144 != -1) {
+					if (v38 > 80)
+						break;
+				}
+				--v39;
+			} while (_vm->_graphicsManager.min_y < v39);
+		}
+		v132 = v38 + 1;
+		v42 = 0;
+		v43 = a1;
+		if (_vm->_graphicsManager.max_x > a1) {
+			v44 = 3;
+			do {
+				v107 = v44;
+				v45 = colision2_ligne(v43, a2, &v138, &v143, 0, _vm->_objectsManager.DERLIGNE);
+				v44 = v107;
+				if (v45 == 1 && *(&v141 + v107) <= _vm->_objectsManager.DERLIGNE)
+					break;
+				*(&v136 + v107) = 0;
+				*(&v141 + v107) = -1;
+				++v42;
+				if (v144 != -1 || v142 != -1) {
+					if (v42 > 100)
+						break;
+				}
+				++v43;
+			} while (_vm->_graphicsManager.max_x > v43);
+		}
+		v133 = v42 + 1;
+		v46 = 0;
+		v47 = a1;
+		if (_vm->_graphicsManager.min_x < a1) {
+			v48 = 7;
+			do {
+				v108 = v48;
+				v49 = colision2_ligne(v47, a2, &v140, &v145, 0, _vm->_objectsManager.DERLIGNE);
+				v48 = v108;
+				if (v49 == 1 && *(&v141 + v108) <= _vm->_objectsManager.DERLIGNE)
+					break;
+				*(&v136 + v108) = 0;
+				*(&v141 + v108) = -1;
+				++v46;
+				if (v144 != -1 || v142 != -1 || v143 != -1) {
+					if (v46 > 100)
+						break;
+				}
+				--v47;
+			} while (_vm->_graphicsManager.min_x < v47);
+		}
+		v135 = v46 + 1;
+		if (v142 != -1) {
+			v50 = v142 - v121;
+			if (v50 < 0)
+				v50 = -v50;
+			v127 = v50;
+		}
+		if (v143 != -1) {
+			v51 = v143 - v121;
+			if (v51 < 0)
+				v51 = -v51;
+			v128 = v51;
+		}
+		if (v144 != -1) {
+			v52 = v144 - v121;
+			if (v52 < 0)
+				v52 = -v52;
+			v129 = v52;
+		}
+		if (v145 != -1) {
+			v53 = v145 - v121;
+			if (v53 < 0)
+				v53 = -v53;
+			v130 = v53;
+		}
+		if (v142 == -1 && v143 == -1 && v144 == -1 && v145 == -1)
+			error("ERREUR POINT PLUS PROCHE Du perso NON TROUVE");
+		v54 = 0;
+		if (v142 != -1 && v128 >= v127 && v129 >= v127 && v130 >= v127) {
+			v54 = 1;
+			v115 = v142;
+			v111 = v132;
+			v113 = 1;
+			v114 = v137;
+		}
+		if (!v54) {
+			if (v144 != -1 && v128 >= v129 && v127 >= v129 && v130 >= v129) {
+				v54 = 1;
+				v115 = v144;
+				v111 = v134;
+				v113 = 5;
+				v114 = v139;
+			}
+			if (!v54) {
+				if (v143 != -1 && v127 >= v128 && v129 >= v128 && v130 >= v128) {
+					v54 = 1;
+					v115 = v143;
+					v111 = v133;
+					v113 = 3;
+					v114 = v138;
+				}
+				if (!v54 && v145 != -1 && v127 >= v130 && v129 >= v130 && v128 >= v130) {
+					v115 = v145;
+					v111 = v135;
+					v113 = 7;
+					v114 = v140;
+				}
+			}
+		}
+		v55 = PARC_PERS(a1, a2, v123, v122, v115, v121, 0);
+		if (v55 != 1) {
+			if (v55 == 2) {
+LABEL_201:
+				v115 = NV_LIGNEDEP;
+				v114 = NV_LIGNEOFS;
+				v112 = NV_POSI;
+			} else {
+				if (v113 == 1) {
+					v56 = 0;
+					if (v111 > 0) {
+						do {
+							if ((uint16)colision2_ligne(a1, a2 - v56, &v125, &v124, _vm->_objectsManager.DERLIGNE + 1, TOTAL_LIGNES) == 1
+							        && _vm->_objectsManager.DERLIGNE < v124) {
+								v57 = v112;
+								v58 = GENIAL(v124, v125, a1, a2 - v56, a1, a2 - v111, v112, (byte *)&_vm->_globals.super_parcours[0], 4);
+								if (v58 == -1)
+									goto LABEL_282;
+								v112 = v58;
+								if (_vm->_globals.NVPY != -1)
+									v56 = a2 - _vm->_globals.NVPY;
+							}
+							v59 = v112;
+							_vm->_globals.super_parcours[v59] = a1;
+							_vm->_globals.super_parcours[v59 + 1] = a2 - v56;
+							_vm->_globals.super_parcours[v59 + 2] = 1;
+							_vm->_globals.super_parcours[v59 + 3] = 0;
+							v112 += 4;
+							++v56;
+						} while (v111 > v56);
+					}
+				}
+				if (v113 == 5) {
+					v60 = 0;
+					if (v111 > 0) {
+						do {
+							if ((uint16)colision2_ligne(a1, v60 + a2, &v125, &v124, _vm->_objectsManager.DERLIGNE + 1, TOTAL_LIGNES) == 1
+							        && _vm->_objectsManager.DERLIGNE < v124) {
+								v57 = v112;
+								v61 = GENIAL(v124, v125, a1, v60 + a2, a1, v111 + a2, v112, (byte *)&_vm->_globals.super_parcours[0], 4);
+								if (v61 == -1)
+									goto LABEL_282;
+								v112 = v61;
+								if (_vm->_globals.NVPY != -1)
+									v60 = _vm->_globals.NVPY - a2;
+							}
+							v62 = v112;
+							_vm->_globals.super_parcours[v62] = a1;
+							_vm->_globals.super_parcours[v62 + 1] = v60 + a2;
+							_vm->_globals.super_parcours[v62 + 2] = 5;
+							_vm->_globals.super_parcours[v62 + 3] = 0;
+							v112 += 4;
+							++v60;
+						} while (v111 > v60);
+					}
+				}
+				if (v113 == 7) {
+					v63 = 0;
+					if (v111 > 0) {
+						do {
+							if ((uint16)colision2_ligne(a1 - v63, a2, &v125, &v124, _vm->_objectsManager.DERLIGNE + 1, TOTAL_LIGNES) == 1
+							        && _vm->_objectsManager.DERLIGNE < v124) {
+								v57 = v112;
+								v64 = GENIAL(v124, v125, a1 - v63, a2, a1 - v111, a2, v112, (byte *)&_vm->_globals.super_parcours[0], 4);
+								if (v64 == -1)
+									goto LABEL_282;
+								v112 = v64;
+								if (_vm->_globals.NVPX != -1)
+									v63 = a1 - _vm->_globals.NVPX;
+							}
+							v65 = v112;
+							_vm->_globals.super_parcours[v65] = a1 - v63;
+							_vm->_globals.super_parcours[v65 + 1] = a2;
+							_vm->_globals.super_parcours[v65 + 2] = 7;
+							_vm->_globals.super_parcours[v65 + 3] = 0;
+							v112 += 4;
+							++v63;
+						} while (v111 > v63);
+					}
+				}
+				if (v113 == 3) {
+					v66 = 0;
+					if (v111 > 0) {
+						do {
+							if ((uint16)colision2_ligne(v66 + a1, a2, &v125, &v124, _vm->_objectsManager.DERLIGNE + 1, TOTAL_LIGNES) == 1
+							        && _vm->_objectsManager.DERLIGNE < v124) {
+								v57 = v112;
+								v67 = GENIAL(v124, v125, v66 + a1, a2, v111 + a1, a2, v112, (byte *)&_vm->_globals.super_parcours[0], 4);
+								if (v67 == -1)
+									goto LABEL_282;
+								v112 = v67;
+								if (_vm->_globals.NVPX != -1)
+									v66 = _vm->_globals.NVPX - a1;
+							}
+							v68 = v112;
+							_vm->_globals.super_parcours[v68] = v66 + a1;
+							_vm->_globals.super_parcours[v68 + 1] = a2;
+							_vm->_globals.super_parcours[v68 + 2] = 3;
+							_vm->_globals.super_parcours[v68 + 3] = 0;
+							v112 += 4;
+							++v66;
+						} while (v111 > v66);
+					}
+				}
+			}
+LABEL_234:
+			if (v115 < v121) {
+				for (i = v114; Ligne[v115].field0 > i; ++i) {
+					v70 = Ligne[v115].fieldC;
+					v119 = READ_LE_UINT16(v70 + 4 * i);
+					v118 = READ_LE_UINT16(v70 + 4 * i + 2);
+					v71 = v112;
+					_vm->_globals.super_parcours[v71] = v119;
+					_vm->_globals.super_parcours[v71 + 1] = v118;
+					_vm->_globals.super_parcours[v71 + 2] = Ligne[v115].field6;
+					_vm->_globals.super_parcours[v71 + 3] = 0;
+					v112 += 4;
+				}
+				v116 = v115 + 1;
+				if ((v115 + 1) < v121) {
+					do {
+						v72 = 0;
+						v110 = v116;
+						for (j = v116; Ligne[j].field0 > v72; j = v116) {
+							v74 = Ligne[v110].fieldC;
+							v119 = READ_LE_UINT16(v74 + 4 * v72);
+							v118 = READ_LE_UINT16(v74 + 4 * v72 + 2);
+							v75 = v112;
+							_vm->_globals.super_parcours[v75] = v119;
+							_vm->_globals.super_parcours[v75 + 1] = v118;
+							_vm->_globals.super_parcours[v75 + 2] = Ligne[v110].field6;
+							_vm->_globals.super_parcours[v75 + 3] = 0;
+							v112 += 4;
+							v76 = Ligne[v110].field0;
+							if (v76 > 30) {
+								v77 = v76 / 2;
+								if (v77 < 0)
+									v77 = -v77;
+								if (v72 == v77) {
+									v78 = PARC_PERS(v119, v118, v123, v122, v110, v121, v112);
+									if (v78 == 1)
+										return (byte *)&_vm->_globals.super_parcours[0];
+									if (v78 == 2)
+										goto LABEL_200;
+									if (MIRACLE(v119, v118, v110, v121, v112) == 1)
+										goto LABEL_201;
+								}
+							}
+							++v72;
+							v110 = v116;
+						}
+						v79 = PARC_PERS(v119, v118, v123, v122, v116, v121, v112);
+						if (v79 == 1)
+							return (byte *)&_vm->_globals.super_parcours[0];
+						if (v79 == 2) {
+LABEL_200:
+							v115 = NV_LIGNEDEP;
+							v114 = NV_LIGNEOFS;
+							v112 = NV_POSI;
+							goto LABEL_234;
+						}
+						if (MIRACLE(v119, v118, v116, v121, v112) == 1)
+							goto LABEL_201;
+						++v116;
+					} while (v116 < v121);
+				}
+				v114 = 0;
+				v115 = v121;
+			}
+			if (v115 > v121) {
+				v80 = v114;
+				if (v114 > 0) {
+					v98 = 16 * v115;
+					do {
+						v81 = Ligne[v98].fieldC;
+						v119 = READ_LE_UINT16(v81 + 4 * v80);
+						v118 = READ_LE_UINT16(v81 + 4 * v80 + 2);
+						v82 = v112;
+						_vm->_globals.super_parcours[v82] = v119;
+						_vm->_globals.super_parcours[v82 + 1] = v118;
+						_vm->_globals.super_parcours[v82 + 2] = Ligne[v98].field8;
+						_vm->_globals.super_parcours[v82 + 3] = 0;
+						v112 += 4;
+						--v80;
+					} while (v80 > 0);
+				}
+				v117 = v115 - 1;
+				if ((v115 - 1) > v121) {
+					do {
+						v83 = Ligne[v117].field0 - 1;
+						if (v83 > -1) {
+							v109 = 16 * v117;
+							do {
+								v84 = Ligne[v109].fieldC;
+								v119 = READ_LE_UINT16(v84 + 4 * v83);
+								v118 = READ_LE_UINT16(v84 + 4 * v83 + 2);
+								v85 = v112;
+								_vm->_globals.super_parcours[v85] = v119;
+								_vm->_globals.super_parcours[v85 + 1] = v118;
+								_vm->_globals.super_parcours[v85 + 2] = Ligne[v109].field8;
+								_vm->_globals.super_parcours[v85 + 3] = 0;
+								v112 += 4;
+								v86 = Ligne[v109].field0;
+								if (v86 > 30) {
+									v87 = v86 / 2;
+									if (v87 < 0)
+										v87 = -v87;
+									if (v83 == v87) {
+										v88 = PARC_PERS(v119, v118, v123, v122, v117, v121, v112);
+										if (v88 == 1)
+											return (byte *)&_vm->_globals.super_parcours[0];
+										if (v88 == 2)
+											goto LABEL_200;
+										if (MIRACLE(v119, v118, v117, v121, v112) == 1)
+											goto LABEL_201;
+									}
+								}
+								--v83;
+							} while (v83 > -1);
+						}
+						v89 = PARC_PERS(v119, v118, v123, v122, v117, v121, v112);
+						if (v89 == 1)
+							return (byte *)&_vm->_globals.super_parcours[0];
+						if (v89 == 2)
+							goto LABEL_200;
+						if (MIRACLE(v119, v118, v117, v121, v112) == 1)
+							goto LABEL_201;
+						--v117;
+					} while (v117 > v121);
+				}
+				v114 = Ligne[v121].field0 - 1;
+				v115 = v121;
+			}
+			if (v115 == v121) {
+				if (v114 <= v120) {
+					if (v114 < v120) {
+						v94 = v114;
+						v100 = 16 * v121;
+						do {
+							v95 = Ligne[v100].fieldC;;
+							v96 = READ_LE_UINT16(v95 + 4 * v94 + 2);
+							v97 = v112;
+							_vm->_globals.super_parcours[v97] = READ_LE_UINT16(v95 + 4 * v94);
+							_vm->_globals.super_parcours[v97 + 1] = v96;
+							_vm->_globals.super_parcours[v97 + 2] = Ligne[v100].field6;
+							_vm->_globals.super_parcours[v97 + 3] = 0;
+							v112 += 4;
+							++v94;
+						} while (v120 > v94);
+					}
+				} else {
+					v90 = v114;
+					v99 = 16 * v121;
+					do {
+						v91 = Ligne[v99].fieldC;
+						v92 = READ_LE_UINT16(v91 + 4 * v90 + 2);
+						v93 = v112;
+						_vm->_globals.super_parcours[v93] = READ_LE_UINT16(v91 + 4 * v90);
+						_vm->_globals.super_parcours[v93 + 1] = v92;
+						_vm->_globals.super_parcours[v93 + 2] = Ligne[v99].field8;
+						_vm->_globals.super_parcours[v93 + 3] = 0;
+						v112 += 4;
+						--v90;
+					} while (v120 < v90);
+				}
+			}
+			v57 = v112;
+			if (PARC_PERS(
+			            _vm->_globals.Param[v112 + 4192 / 2],
+			            _vm->_globals.Param[v112 + 4194 / 2],
+			            v123,
+			            v122,
+			            -1,
+			            -1,
+			            v112) != 1) {
+LABEL_282:
+				_vm->_globals.super_parcours[v57] = -1;
+				_vm->_globals.super_parcours[v57 + 1] = -1;
+				_vm->_globals.super_parcours[v57 + 2] = -1;
+				_vm->_globals.super_parcours[v57 + 3] = -1;
+			}
+			return (byte *)&_vm->_globals.super_parcours[0];
+		}
+	}
+	return (byte *)&_vm->_globals.super_parcours[0];
+}
+
+int LinesManager::PARC_PERS(int a1, int a2, int a3, int a4, int a5, int a6, int a7) {
+	warning("TODO: PARC_PERS");
+	return 0;
+}
+
+
+} // End of namespace Hopkins
diff --git a/engines/hopkins/lines.h b/engines/hopkins/lines.h
new file mode 100644
index 0000000000..8cbae6ba08
--- /dev/null
+++ b/engines/hopkins/lines.h
@@ -0,0 +1,82 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef HOPKINS_LINES_H
+#define HOPKINS_LINES_H
+
+#include "common/scummsys.h"
+#include "common/str.h"
+
+namespace Hopkins {
+
+class HopkinsEngine;
+
+struct LigneZoneItem {
+	int field0;
+	int field2;
+	byte *field4;
+};
+
+struct LigneItem {
+	int field0;
+	int field2;
+	int field4;
+	int field6;
+	int field8;
+	byte *fieldC;
+	byte *field12;
+};
+
+class LinesManager {
+private:
+	HopkinsEngine *_vm;
+public:
+	LigneZoneItem LigneZone[401];
+	LigneItem Ligne[400];
+	int next_ligne;
+	int TOTAL_LIGNES;
+	int NV_LIGNEDEP;
+	int NV_LIGNEOFS;
+	int NV_POSI;
+public:
+	void setParent(HopkinsEngine *vm);
+
+	void CLEAR_ZONE();
+	void RETIRE_LIGNE_ZONE(int idx);
+	void AJOUTE_LIGNE_ZONE(int idx, int a2, int a3, int a4, int a5, int a6);
+	void RESET_OBSTACLE();
+	void RETIRE_LIGNE(int idx);
+	void AJOUTE_LIGNE(int idx, int a2, int a3, int a4, int a5, int a6, int a7);
+	int colision2_ligne(int a1, int a2, int *a3, int *a4, int a5, int a6);
+	int Scolision2_ligne(int a1, int a2, int *a3, int *a4, int a5, int a6);
+	void INIPARCOURS();
+	int CONTOURNE1(int a1, int a2, int a3, int a4, int a5, byte *a6, int a7, int a8, int a9);
+	int CONTOURNE(int a1, int a2, int a3, int a4, int a5, byte *a6, int a7);
+	int MIRACLE(int a1, int a2, int a3, int a4, int a5);
+	int GENIAL(int a1, int a2, int a3, int a4, int a5, int a6, int a7, byte *a8, int a9);
+	byte *PARCOURS2(int a1, int a2, int a3, int a4);
+	int PARC_PERS(int a1, int a2, int a3, int a4, int a5, int a6, int a7);
+};
+
+} // End of namespace Hopkins
+
+#endif /* HOPKINS_FONT_H */
diff --git a/engines/hopkins/module.mk b/engines/hopkins/module.mk
index 49b7c5fbca..7fc92c5ea1 100644
--- a/engines/hopkins/module.mk
+++ b/engines/hopkins/module.mk
@@ -10,6 +10,7 @@ MODULE_OBJS := \
 	graphics.o \
 	globals.o \
 	hopkins.o \
+	lines.o \
 	menu.o \
 	objects.o \
 	sound.o \
diff --git a/engines/hopkins/objects.cpp b/engines/hopkins/objects.cpp
index 5309df0a89..6771f24958 100644
--- a/engines/hopkins/objects.cpp
+++ b/engines/hopkins/objects.cpp
@@ -2078,7 +2078,7 @@ LABEL_38:
 			v10 = XSPR(0);
 			v11 = YSPR(0);
 			v12 = XSPR(0);
-			v13 = PARCOURS2(v12, v11, v10, 390);
+			v13 = _vm->_linesManager.PARCOURS2(v12, v11, v10, 390);
 			_vm->_globals.chemin = v13;
 			if (PTRNUL != v13)
 				PACOURS_PROPRE(v13);
@@ -2106,7 +2106,7 @@ LABEL_64:
 		if (!_vm->_globals.PLAN_FLAG) {
 			v14 = YSPR(0);
 			v15 = XSPR(0);
-			v16 = PARCOURS2(v15, v14, v19, v0);
+			v16 = _vm->_linesManager.PARCOURS2(v15, v14, v19, v0);
 			_vm->_globals.chemin = v16;
 			if (PTRNUL != v16)
 				PACOURS_PROPRE(v16);
@@ -2274,7 +2274,7 @@ void ObjectsManager::CLEAR_ECRAN() {
 	_vm->_fontManager.TEXTE_OFF(9);
 	_vm->_globals.CLEAR_VBOB();
 	_vm->_animationManager.CLEAR_ANIM();
-	CLEAR_ZONE();
+	_vm->_linesManager.CLEAR_ZONE();
 	RESET_OBSTACLE();
 	_vm->_globals.RESET_CACHE();
 
@@ -2295,7 +2295,7 @@ void ObjectsManager::CLEAR_ECRAN() {
 	SPEED_Y = 0;
 	SPEED_IMAGE = 0;
 	FORCEZONE = 1;
-	TOTAL_LIGNES = 0;
+	_vm->_linesManager.TOTAL_LIGNES = 0;
 	DERLIGNE = 0;
 	_vm->_globals.chemin = PTRNUL;
 	if (_vm->_globals.COUCOU != PTRNUL)
@@ -2618,789 +2618,6 @@ LABEL_9:
 	}
 }
 
-// TODO: method casting int arrays as byte pointers. Double-check later whether
-// we can convert the return to a uint16 *
-byte *ObjectsManager::PARCOURS2(int a1, int a2, int a3, int a4) {
-	int v4; 
-	int v5; 
-	int v6; 
-	int v7; 
-	int v8; 
-	int v9; 
-	int v10;
-	int v11; 
-	int v12; 
-	int v13; 
-	int v14; 
-	int v15; 
-	int v16; 
-	int v17; 
-	int v18; 
-	int v19; 
-	int v20;
-	int v21; 
-	int v22;
-	int v23; 
-	int v24; 
-	int v25; 
-	int v26;
-	int v27; 
-	int v28; 
-	int v29; 
-	int v31;
-	int v32; 
-	int v33; 
-	int v34; 
-	int v35; 
-	int v36;
-	int v37;
-	int v38;
-	int v39;
-	int v40; 
-	int v41; 
-	int v42;
-	int v43; 
-	int v44; 
-	int v45; 
-	int v46;
-	int v47;
-	int v48; 
-	int v49; 
-	int v50; 
-	int v51;
-	int v52; 
-	int v53; 
-	int v54; 
-	int v55;
-	int v56;
-	int v57; 
-	int v58;
-	int v59; 
-	int v60;
-	int v61; 
-	int v62; 
-	int v63;
-	int v64; 
-	int v65; 
-	int v66; 
-	int v67;
-	int v68;
-	int i;
-	byte *v70; 
-	int v71; 
-	int v72; 
-	int j; 
-	byte *v74;
-	int v75; 
-	int v76;
-	int v77; 
-	int v78; 
-	int v79; 
-	int v80;
-	byte *v81; 
-	int v82; 
-	int v83; 
-	byte *v84;
-	int v85; 
-	int v86;
-	int v87; 
-	int v88; 
-	int v89; 
-	int v90; 
-	byte *v91; 
-	int v92; 
-	int v93; 
-	int v94;
-	byte *v95; 
-	int v96; 
-	int v97;
-	int v98; 
-	int v99; 
-	int v100; 
-	int v101; 
-	int v102; 
-	int v103; 
-	int v104;
-	int v105; 
-	int v106; 
-	int v107; 
-	int v108;
-	int v109;
-	int v110; 
-	int v111; 
-	int v112; 
-	int v113; 
-	int v114; 
-	int v115; 
-	int v116;
-	int v117; 
-	int v118 = 0; 
-	int v119 = 0; 
-	int v120; 
-	int v121; 
-	int v122;
-	int v123; 
-	int v124; 
-	int v125;
-	int v126; 
-	int v127 = 0;
-	int v128 = 0; 
-	int v129 = 0; 
-	int v130 = 0; 
-	int v131; 
-	int v132; 
-	int v133; 
-	int v134; 
-	int v135;
-	int v136; 
-	int v137 = 0; 
-	int v138 = 0;
-	int v139 = 0;
-	int v140 = 0;
-	int v141; 
-	int v142 = 0;
-	int v143 = 0; 
-	int v144 = 0; 
-	int v145 = 0; 
-
-	v123 = a3;
-	v122 = a4;
-	v121 = 0;
-	v120 = 0;
-	v115 = 0;
-	v114 = 0;
-	v113 = 0;
-	v111 = 0;
-	if (a4 <= 24)
-		v122 = 25;
-	if (!_vm->_globals.NOT_VERIF) {
-		v4 = a1 - _vm->_globals.old_x1_65;
-		if (v4 < 0)
-			v4 = -v4;
-		if (v4 <= 4) {
-			v5 = a2 - _vm->_globals.old_y1_66;
-			if (v5 < 0)
-				v5 = -v5;
-			if (v5 <= 4) {
-				v6 = _vm->_globals.old_x2_67 - a3;
-				if (v6 < 0)
-					v6 = -v6;
-				if (v6 <= 4) {
-					v7 = _vm->_globals.old_y2_68 - v122;
-					if (v7 < 0)
-						v7 = -v7;
-					if (v7 <= 4)
-						return PTRNUL;
-				}
-			}
-		}
-		v8 = a1 - a3;
-		if (v8 < 0)
-			v8 = -v8;
-		if (v8 <= 4) {
-			v9 = a2 - v122;
-			if (v9 < 0)
-				v9 = -v9;
-			if (v9 <= 4)
-				return PTRNUL;
-		}
-		if (_vm->_globals.old_z_69 > 0 && _vm->_objectsManager.NUMZONE > 0 && _vm->_globals.old_z_69 == _vm->_objectsManager.NUMZONE)
-			return PTRNUL;
-	}
-	_vm->_globals.NOT_VERIF = 0;
-	_vm->_globals.old_z_69 = _vm->_objectsManager.NUMZONE;
-	_vm->_globals.old_x1_65 = a1;
-	_vm->_globals.old_x2_67 = a3;
-	_vm->_globals.old_y1_66 = a2;
-	_vm->_globals.old_y2_68 = v122;
-	_vm->_globals.STOP_BUG = 0;
-	v112 = 0;
-	if (a3 <= 19)
-		v123 = 20;
-	if (v122 <= 19)
-		v122 = 20;
-	if (v123 > _vm->_graphicsManager.max_x - 10)
-		v123 = _vm->_graphicsManager.max_x - 10;
-	if (v122 > _vm->_globals.Max_Perso_Y)
-		v122 = _vm->_globals.Max_Perso_Y;
-	v10 = a1 - v123;
-	if (v10 < 0)
-		v10 = -v10;
-	if (v10 <= 3) {
-		v11 = a2 - v122;
-		if (v11 < 0)
-			v11 = -v11;
-		if (v11 <= 3)
-			return PTRNUL;
-	}
-	v12 = 0;
-	do {
-		v13 = v12;
-		*(&v141 + v13) = -1;
-		*(&v136 + v13) = 0;
-		*(&v131 + v13) = 1300;
-		*(&v126 + v13) = 1300;
-		++v12;
-	} while (v12 <= 8);
-	if (PARC_PERS(a1, a2, v123, v122, -1, -1, 0) != 1) {
-		v14 = 0;
-		v15 = v122;
-		if (_vm->_graphicsManager.max_y > v122) {
-			v16 = 5;
-			do {
-				v101 = v16;
-				v17 = _vm->_graphicsManager.colision2_ligne(v123, v15, &v139, &v144, 0, _vm->_objectsManager.DERLIGNE);
-				v16 = v101;
-				if (v17 == 1 && *(&v141 + v101) <= _vm->_objectsManager.DERLIGNE)
-					break;
-				*(&v136 + v101) = 0;
-				*(&v141 + v101) = -1;
-				++v14;
-				++v15;
-			} while (_vm->_graphicsManager.max_y > v15);
-		}
-		v134 = v14;
-		v18 = 0;
-		v19 = v122;
-		if (_vm->_graphicsManager.min_y < v122) {
-			v20 = 1;
-			do {
-				v102 = v20;
-				v21 = _vm->_graphicsManager.colision2_ligne(v123, v19, &v137, &v142, 0, _vm->_objectsManager.DERLIGNE);
-				v20 = v102;
-				if (v21 == 1 && *(&v141 + v102) <= _vm->_objectsManager.DERLIGNE)
-					break;
-				*(&v136 + v102) = 0;
-				*(&v141 + v102) = -1;
-				if (v134 < v18) {
-					if (v144 != -1)
-						break;
-				}
-				++v18;
-				--v19;
-			} while (_vm->_graphicsManager.min_y < v19);
-		}
-		v132 = v18;
-		v22 = 0;
-		v23 = v123;
-		if (_vm->_graphicsManager.max_x > v123) {
-			v24 = 3;
-			do {
-				v103 = v24;
-				v25 = _vm->_graphicsManager.colision2_ligne(v23, v122, &v138, &v143, 0, _vm->_objectsManager.DERLIGNE);
-				v24 = v103;
-				if (v25 == 1 && *(&v141 + v103) <= _vm->_objectsManager.DERLIGNE)
-					break;
-				*(&v136 + v103) = 0;
-				*(&v141 + v103) = -1;
-				++v22;
-				if (v132 < v22) {
-					if (v142 != -1)
-						break;
-				}
-				if (v134 < v22 && v144 != -1)
-					break;
-				++v23;
-			} while (_vm->_graphicsManager.max_x > v23);
-		}
-		v133 = v22;
-		v26 = 0;
-		v27 = v123;
-		if (_vm->_graphicsManager.min_x < v123) {
-			v28 = 7;
-			do {
-				v104 = v28;
-				v29 = _vm->_graphicsManager.colision2_ligne(v27, v122, &v140, &v145, 0, _vm->_objectsManager.DERLIGNE);
-				v28 = v104;
-				if (v29 == 1 && *(&v141 + v104) <= _vm->_objectsManager.DERLIGNE)
-					break;
-				*(&v136 + v104) = 0;
-				*(&v141 + v104) = -1;
-				++v26;
-				if (v132 < v26) {
-					if (v142 != -1)
-						break;
-				}
-				if (v134 < v26 && v144 != -1)
-					break;
-				if (v133 < v26 && v143 != -1)
-					break;
-				--v27;
-			} while (_vm->_graphicsManager.min_x < v27);
-		}
-		v135 = v26;
-		if (v142 < 0 || _vm->_objectsManager.DERLIGNE < v142)
-			v142 = -1;
-		if (v143 < 0 || _vm->_objectsManager.DERLIGNE < v143)
-			v143 = -1;
-		if (v144 < 0 || _vm->_objectsManager.DERLIGNE < v144)
-			v144 = -1;
-		if (v145 < 0 || _vm->_objectsManager.DERLIGNE < v145)
-			v145 = -1;
-		if (v142 < 0)
-			v132 = 1300;
-		if (v143 < 0)
-			v133 = 1300;
-		if (v144 < 0)
-			v134 = 1300;
-		if (v145 < 0)
-			v135 = 1300;
-		if (v142 == -1 && v143 == -1 && v144 == -1 && v145 == -1)
-			return PTRNUL;
-		v31 = 0;
-		if (v144 != -1 && v132 >= v134 && v133 >= v134 && v135 >= v134) {
-			v121 = v144;
-			v120 = v139;
-			v31 = 1;
-		}
-		if (v142 != -1 && !v31 && v134 >= v132 && v133 >= v132 && v135 >= v132) {
-			v121 = v142;
-			v120 = v137;
-			v31 = 1;
-		}
-		if (v143 != -1 && !v31 && v132 >= v133 && v134 >= v133 && v135 >= v133) {
-			v121 = v143;
-			v120 = v138;
-			v31 = 1;
-		}
-		if (v145 != -1 && !v31 && v134 >= v135 && v133 >= v135 && v132 >= v135) {
-			v121 = v145;
-			v120 = v140;
-		}
-		v32 = 0;
-		do {
-			v33 = v32;
-			*(&v141 + v33) = -1;
-			*(&v136 + v33) = 0;
-			*(&v131 + v33) = 1300;
-			*(&v126 + v33) = 1300;
-			++v32;
-		} while (v32 <= 8);
-		v34 = 0;
-		v35 = a2;
-		if (_vm->_graphicsManager.max_y > a2) {
-			v36 = 5;
-			do {
-				v105 = v36;
-				v37 = _vm->_graphicsManager.colision2_ligne(a1, v35, &v139, &v144, 0, _vm->_objectsManager.DERLIGNE);
-				v36 = v105;
-				if (v37 == 1 && *(&v141 + v105) <= _vm->_objectsManager.DERLIGNE)
-					break;
-				*(&v136 + v105) = 0;
-				*(&v141 + v105) = -1;
-				++v34;
-				++v35;
-			} while (_vm->_graphicsManager.max_y > v35);
-		}
-		v134 = v34 + 1;
-		v38 = 0;
-		v39 = a2;
-		if (_vm->_graphicsManager.min_y < a2) {
-			v40 = 1;
-			do {
-				v106 = v40;
-				v41 = _vm->_graphicsManager.colision2_ligne(a1, v39, &v137, &v142, 0, _vm->_objectsManager.DERLIGNE);
-				v40 = v106;
-				if (v41 == 1 && *(&v141 + v106) <= _vm->_objectsManager.DERLIGNE)
-					break;
-				*(&v136 + v106) = 0;
-				*(&v141 + v106) = -1;
-				++v38;
-				if (v144 != -1) {
-					if (v38 > 80)
-						break;
-				}
-				--v39;
-			} while (_vm->_graphicsManager.min_y < v39);
-		}
-		v132 = v38 + 1;
-		v42 = 0;
-		v43 = a1;
-		if (_vm->_graphicsManager.max_x > a1) {
-			v44 = 3;
-			do {
-				v107 = v44;
-				v45 = _vm->_graphicsManager.colision2_ligne(v43, a2, &v138, &v143, 0, _vm->_objectsManager.DERLIGNE);
-				v44 = v107;
-				if (v45 == 1 && *(&v141 + v107) <= _vm->_objectsManager.DERLIGNE)
-					break;
-				*(&v136 + v107) = 0;
-				*(&v141 + v107) = -1;
-				++v42;
-				if (v144 != -1 || v142 != -1) {
-					if (v42 > 100)
-						break;
-				}
-				++v43;
-			} while (_vm->_graphicsManager.max_x > v43);
-		}
-		v133 = v42 + 1;
-		v46 = 0;
-		v47 = a1;
-		if (_vm->_graphicsManager.min_x < a1) {
-			v48 = 7;
-			do {
-				v108 = v48;
-				v49 = _vm->_graphicsManager.colision2_ligne(v47, a2, &v140, &v145, 0, _vm->_objectsManager.DERLIGNE);
-				v48 = v108;
-				if (v49 == 1 && *(&v141 + v108) <= _vm->_objectsManager.DERLIGNE)
-					break;
-				*(&v136 + v108) = 0;
-				*(&v141 + v108) = -1;
-				++v46;
-				if (v144 != -1 || v142 != -1 || v143 != -1) {
-					if (v46 > 100)
-						break;
-				}
-				--v47;
-			} while (_vm->_graphicsManager.min_x < v47);
-		}
-		v135 = v46 + 1;
-		if (v142 != -1) {
-			v50 = v142 - v121;
-			if (v50 < 0)
-				v50 = -v50;
-			v127 = v50;
-		}
-		if (v143 != -1) {
-			v51 = v143 - v121;
-			if (v51 < 0)
-				v51 = -v51;
-			v128 = v51;
-		}
-		if (v144 != -1) {
-			v52 = v144 - v121;
-			if (v52 < 0)
-				v52 = -v52;
-			v129 = v52;
-		}
-		if (v145 != -1) {
-			v53 = v145 - v121;
-			if (v53 < 0)
-				v53 = -v53;
-			v130 = v53;
-		}
-		if (v142 == -1 && v143 == -1 && v144 == -1 && v145 == -1)
-			error("ERREUR POINT PLUS PROCHE Du perso NON TROUVE");
-		v54 = 0;
-		if (v142 != -1 && v128 >= v127 && v129 >= v127 && v130 >= v127) {
-			v54 = 1;
-			v115 = v142;
-			v111 = v132;
-			v113 = 1;
-			v114 = v137;
-		}
-		if (!v54) {
-			if (v144 != -1 && v128 >= v129 && v127 >= v129 && v130 >= v129) {
-				v54 = 1;
-				v115 = v144;
-				v111 = v134;
-				v113 = 5;
-				v114 = v139;
-			}
-			if (!v54) {
-				if (v143 != -1 && v127 >= v128 && v129 >= v128 && v130 >= v128) {
-					v54 = 1;
-					v115 = v143;
-					v111 = v133;
-					v113 = 3;
-					v114 = v138;
-				}
-				if (!v54 && v145 != -1 && v127 >= v130 && v129 >= v130 && v128 >= v130) {
-					v115 = v145;
-					v111 = v135;
-					v113 = 7;
-					v114 = v140;
-				}
-			}
-		}
-		v55 = PARC_PERS(a1, a2, v123, v122, v115, v121, 0);
-		if (v55 != 1) {
-			if (v55 == 2) {
-LABEL_201:
-				v115 = NV_LIGNEDEP;
-				v114 = NV_LIGNEOFS;
-				v112 = NV_POSI;
-			} else {
-				if (v113 == 1) {
-					v56 = 0;
-					if (v111 > 0) {
-						do {
-							if ((uint16)_vm->_graphicsManager.colision2_ligne(a1, a2 - v56, &v125, &v124, _vm->_objectsManager.DERLIGNE + 1, TOTAL_LIGNES) == 1
-							        && _vm->_objectsManager.DERLIGNE < v124) {
-								v57 = v112;
-								v58 = GENIAL(v124, v125, a1, a2 - v56, a1, a2 - v111, v112, _vm->_globals.super_parcours, 4);
-								if (v58 == -1)
-									goto LABEL_282;
-								v112 = v58;
-								if (NVPY != -1)
-									v56 = a2 - NVPY;
-							}
-							v59 = v112;
-							_vm->_globals.super_parcours[v59] = a1;
-							_vm->_globals.super_parcours[v59 + 1] = a2 - v56;
-							_vm->_globals.super_parcours[v59 + 2] = 1;
-							_vm->_globals.super_parcours[v59 + 3] = 0;
-							v112 += 4;
-							++v56;
-						} while (v111 > v56);
-					}
-				}
-				if (v113 == 5) {
-					v60 = 0;
-					if (v111 > 0) {
-						do {
-							if ((uint16)_vm->_graphicsManager.colision2_ligne(a1, v60 + a2, &v125, &v124, _vm->_objectsManager.DERLIGNE + 1, TOTAL_LIGNES) == 1
-							        && _vm->_objectsManager.DERLIGNE < v124) {
-								v57 = v112;
-								v61 = GENIAL(v124, v125, a1, v60 + a2, a1, v111 + a2, v112, _vm->_globals.super_parcours, 4);
-								if (v61 == -1)
-									goto LABEL_282;
-								v112 = v61;
-								if (NVPY != -1)
-									v60 = NVPY - a2;
-							}
-							v62 = v112;
-							_vm->_globals.super_parcours[v62] = a1;
-							_vm->_globals.super_parcours[v62 + 1] = v60 + a2;
-							_vm->_globals.super_parcours[v62 + 2] = 5;
-							_vm->_globals.super_parcours[v62 + 3] = 0;
-							v112 += 4;
-							++v60;
-						} while (v111 > v60);
-					}
-				}
-				if (v113 == 7) {
-					v63 = 0;
-					if (v111 > 0) {
-						do {
-							if ((uint16)_vm->_graphicsManager.colision2_ligne(a1 - v63, a2, &v125, &v124, _vm->_objectsManager.DERLIGNE + 1, TOTAL_LIGNES) == 1
-							        && _vm->_objectsManager.DERLIGNE < v124) {
-								v57 = v112;
-								v64 = GENIAL(v124, v125, a1 - v63, a2, a1 - v111, a2, v112, _vm->_globals.super_parcours, 4);
-								if (v64 == -1)
-									goto LABEL_282;
-								v112 = v64;
-								if (NVPX != -1)
-									v63 = a1 - NVPX;
-							}
-							v65 = v112;
-							_vm->_globals.super_parcours[v65] = a1 - v63;
-							_vm->_globals.super_parcours[v65 + 1] = a2;
-							_vm->_globals.super_parcours[v65 + 2] = 7;
-							_vm->_globals.super_parcours[v65 + 3] = 0;
-							v112 += 4;
-							++v63;
-						} while (v111 > v63);
-					}
-				}
-				if (v113 == 3) {
-					v66 = 0;
-					if (v111 > 0) {
-						do {
-							if ((uint16)_vm->_graphicsManager.colision2_ligne(v66 + a1, a2, &v125, &v124, _vm->_objectsManager.DERLIGNE + 1, TOTAL_LIGNES) == 1
-							        && _vm->_objectsManager.DERLIGNE < v124) {
-								v57 = v112;
-								v67 = GENIAL(v124, v125, v66 + a1, a2, v111 + a1, a2, v112, _vm->_globals.super_parcours, 4);
-								if (v67 == -1)
-									goto LABEL_282;
-								v112 = v67;
-								if (NVPX != -1)
-									v66 = NVPX - a1;
-							}
-							v68 = v112;
-							_vm->_globals.super_parcours[v68] = v66 + a1;
-							_vm->_globals.super_parcours[v68 + 1] = a2;
-							_vm->_globals.super_parcours[v68 + 2] = 3;
-							_vm->_globals.super_parcours[v68 + 3] = 0;
-							v112 += 4;
-							++v66;
-						} while (v111 > v66);
-					}
-				}
-			}
-LABEL_234:
-			if (v115 < v121) {
-				for (i = v114; _vm->_globals.Ligne[v115].field0 > i; ++i) {
-					v70 = _vm->_globals.Ligne[v115].fieldC;
-					v119 = READ_LE_UINT16(v70 + 4 * i);
-					v118 = READ_LE_UINT16(v70 + 4 * i + 2);
-					v71 = v112;
-					_vm->_globals.super_parcours[v71] = v119;
-					_vm->_globals.super_parcours[v71 + 1] = v118;
-					_vm->_globals.super_parcours[v71 + 2] = _vm->_globals.Ligne[v115].field6;
-					_vm->_globals.super_parcours[v71 + 3] = 0;
-					v112 += 4;
-				}
-				v116 = v115 + 1;
-				if ((v115 + 1) < v121) {
-					do {
-						v72 = 0;
-						v110 = v116;
-						for (j = v116; _vm->_globals.Ligne[j].field0 > v72; j = v116) {
-							v74 = _vm->_globals.Ligne[v110].fieldC;
-							v119 = READ_LE_UINT16(v74 + 4 * v72);
-							v118 = READ_LE_UINT16(v74 + 4 * v72 + 2);
-							v75 = v112;
-							_vm->_globals.super_parcours[v75] = v119;
-							_vm->_globals.super_parcours[v75 + 1] = v118;
-							_vm->_globals.super_parcours[v75 + 2] = _vm->_globals.Ligne[v110].field6;
-							_vm->_globals.super_parcours[v75 + 3] = 0;
-							v112 += 4;
-							v76 = _vm->_globals.Ligne[v110].field0;
-							if (v76 > 30) {
-								v77 = v76 / 2;
-								if (v77 < 0)
-									v77 = -v77;
-								if (v72 == v77) {
-									v78 = PARC_PERS(v119, v118, v123, v122, v110, v121, v112);
-									if (v78 == 1)
-										return (byte *)&_vm->_globals.super_parcours[0];
-									if (v78 == 2)
-										goto LABEL_200;
-									if (MIRACLE(v119, v118, v110, v121, v112) == 1)
-										goto LABEL_201;
-								}
-							}
-							++v72;
-							v110 = v116;
-						}
-						v79 = PARC_PERS(v119, v118, v123, v122, v116, v121, v112);
-						if (v79 == 1)
-							return (byte *)&_vm->_globals.super_parcours[0];
-						if (v79 == 2) {
-LABEL_200:
-							v115 = NV_LIGNEDEP;
-							v114 = NV_LIGNEOFS;
-							v112 = NV_POSI;
-							goto LABEL_234;
-						}
-						if (MIRACLE(v119, v118, v116, v121, v112) == 1)
-							goto LABEL_201;
-						++v116;
-					} while (v116 < v121);
-				}
-				v114 = 0;
-				v115 = v121;
-			}
-			if (v115 > v121) {
-				v80 = v114;
-				if (v114 > 0) {
-					v98 = 16 * v115;
-					do {
-						v81 = _vm->_globals.Ligne[v98].fieldC;
-						v119 = READ_LE_UINT16(v81 + 4 * v80);
-						v118 = READ_LE_UINT16(v81 + 4 * v80 + 2);
-						v82 = v112;
-						_vm->_globals.super_parcours[v82] = v119;
-						_vm->_globals.super_parcours[v82 + 1] = v118;
-						_vm->_globals.super_parcours[v82 + 2] = _vm->_globals.Ligne[v98].field8;
-						_vm->_globals.super_parcours[v82 + 3] = 0;
-						v112 += 4;
-						--v80;
-					} while (v80 > 0);
-				}
-				v117 = v115 - 1;
-				if ((v115 - 1) > v121) {
-					do {
-						v83 = _vm->_globals.Ligne[v117].field0 - 1;
-						if (v83 > -1) {
-							v109 = 16 * v117;
-							do {
-								v84 = _vm->_globals.Ligne[v109].fieldC;
-								v119 = READ_LE_UINT16(v84 + 4 * v83);
-								v118 = READ_LE_UINT16(v84 + 4 * v83 + 2);
-								v85 = v112;
-								_vm->_globals.super_parcours[v85] = v119;
-								_vm->_globals.super_parcours[v85 + 1] = v118;
-								_vm->_globals.super_parcours[v85 + 2] = _vm->_globals.Ligne[v109].field8;
-								_vm->_globals.super_parcours[v85 + 3] = 0;
-								v112 += 4;
-								v86 = _vm->_globals.Ligne[v109].field0;
-								if (v86 > 30) {
-									v87 = v86 / 2;
-									if (v87 < 0)
-										v87 = -v87;
-									if (v83 == v87) {
-										v88 = PARC_PERS(v119, v118, v123, v122, v117, v121, v112);
-										if (v88 == 1)
-											return (byte *)&_vm->_globals.super_parcours[0];
-										if (v88 == 2)
-											goto LABEL_200;
-										if (MIRACLE(v119, v118, v117, v121, v112) == 1)
-											goto LABEL_201;
-									}
-								}
-								--v83;
-							} while (v83 > -1);
-						}
-						v89 = PARC_PERS(v119, v118, v123, v122, v117, v121, v112);
-						if (v89 == 1)
-							return (byte *)&_vm->_globals.super_parcours[0];
-						if (v89 == 2)
-							goto LABEL_200;
-						if (MIRACLE(v119, v118, v117, v121, v112) == 1)
-							goto LABEL_201;
-						--v117;
-					} while (v117 > v121);
-				}
-				v114 = _vm->_globals.Ligne[v121].field0 - 1;
-				v115 = v121;
-			}
-			if (v115 == v121) {
-				if (v114 <= v120) {
-					if (v114 < v120) {
-						v94 = v114;
-						v100 = 16 * v121;
-						do {
-							v95 = _vm->_globals.Ligne[v100].fieldC;;
-							v96 = READ_LE_UINT16(v95 + 4 * v94 + 2);
-							v97 = v112;
-							_vm->_globals.super_parcours[v97] = READ_LE_UINT16(v95 + 4 * v94);
-							_vm->_globals.super_parcours[v97 + 1] = v96;
-							_vm->_globals.super_parcours[v97 + 2] = _vm->_globals.Ligne[v100].field6;
-							_vm->_globals.super_parcours[v97 + 3] = 0;
-							v112 += 4;
-							++v94;
-						} while (v120 > v94);
-					}
-				} else {
-					v90 = v114;
-					v99 = 16 * v121;
-					do {
-						v91 = _vm->_globals.Ligne[v99].fieldC;
-						v92 = READ_LE_UINT16(v91 + 4 * v90 + 2);
-						v93 = v112;
-						_vm->_globals.super_parcours[v93] = READ_LE_UINT16(v91 + 4 * v90);
-						_vm->_globals.super_parcours[v93 + 1] = v92;
-						_vm->_globals.super_parcours[v93 + 2] = _vm->_globals.Ligne[v99].field8;
-						_vm->_globals.super_parcours[v93 + 3] = 0;
-						v112 += 4;
-						--v90;
-					} while (v120 < v90);
-				}
-			}
-			v57 = v112;
-			if (PARC_PERS(
-			            _vm->_globals.Param[v112 + 4192 / 2],
-			            _vm->_globals.Param[v112 + 4194 / 2],
-			            v123,
-			            v122,
-			            -1,
-			            -1,
-			            v112) != 1) {
-LABEL_282:
-				_vm->_globals.super_parcours[v57] = -1;
-				_vm->_globals.super_parcours[v57 + 1] = -1;
-				_vm->_globals.super_parcours[v57 + 2] = -1;
-				_vm->_globals.super_parcours[v57 + 3] = -1;
-			}
-			return (byte *)&_vm->_globals.super_parcours[0];
-		}
-	}
-	return (byte *)&_vm->_globals.super_parcours[0];
-}
-
 void ObjectsManager::VERIFTAILLE() {
 	int v0; 
 	int v1; 
@@ -3604,7 +2821,7 @@ byte *ObjectsManager::PARC_VOITURE(int a1, int a2, int a3, int a4) {
 		v8 = 5;
 		do {
 			v62 = v8;
-			v9 = _vm->_graphicsManager.colision2_ligne(v75, v7, &v85, &v90, 0, _vm->_objectsManager.DERLIGNE);
+			v9 = _vm->_linesManager.colision2_ligne(v75, v7, &v85, &v90, 0, _vm->_objectsManager.DERLIGNE);
 			v8 = v62;
 			if (v9 == 1 && *(&v87 + v62) <= _vm->_objectsManager.DERLIGNE)
 				break;
@@ -3621,7 +2838,7 @@ byte *ObjectsManager::PARC_VOITURE(int a1, int a2, int a3, int a4) {
 		v12 = 1;
 		do {
 			v63 = v12;
-			v13 = _vm->_graphicsManager.colision2_ligne(v75, v11, &v83, &v88, 0, _vm->_objectsManager.DERLIGNE);
+			v13 = _vm->_linesManager.colision2_ligne(v75, v11, &v83, &v88, 0, _vm->_objectsManager.DERLIGNE);
 			v12 = v63;
 			if (v13 == 1 && *(&v87 + v63) <= _vm->_objectsManager.DERLIGNE)
 				break;
@@ -3642,7 +2859,7 @@ byte *ObjectsManager::PARC_VOITURE(int a1, int a2, int a3, int a4) {
 		v16 = 3;
 		do {
 			v64 = v16;
-			v17 = _vm->_graphicsManager.colision2_ligne(v15, v74, &v84, &v89, 0, _vm->_objectsManager.DERLIGNE);
+			v17 = _vm->_linesManager.colision2_ligne(v15, v74, &v84, &v89, 0, _vm->_objectsManager.DERLIGNE);
 			v16 = v64;
 			if (v17 == 1 && *(&v87 + v64) <= _vm->_objectsManager.DERLIGNE)
 				break;
@@ -3665,7 +2882,7 @@ byte *ObjectsManager::PARC_VOITURE(int a1, int a2, int a3, int a4) {
 		v20 = 7;
 		do {
 			v65 = v20;
-			v21 = _vm->_graphicsManager.colision2_ligne(v19, v74, &v86, &v91, 0, _vm->_objectsManager.DERLIGNE);
+			v21 = _vm->_linesManager.colision2_ligne(v19, v74, &v86, &v91, 0, _vm->_objectsManager.DERLIGNE);
 			v20 = v65;
 			if (v21 == 1 && *(&v87 + v65) <= _vm->_objectsManager.DERLIGNE)
 				break;
@@ -3722,13 +2939,13 @@ byte *ObjectsManager::PARC_VOITURE(int a1, int a2, int a3, int a4) {
 			v76[v25] = 1300;
 			++v24;
 		} while (v24 <= 8);
-		v26 = _vm->_graphicsManager.colision2_ligne(a1, a2, &v83, &v88, 0, _vm->_objectsManager.DERLIGNE);
+		v26 = _vm->_linesManager.colision2_ligne(a1, a2, &v83, &v88, 0, _vm->_objectsManager.DERLIGNE);
 		if (v26 == 1) {
 			v69 = v88;
 			v68 = v83;
 		}
 		if (!v26) {
-			if (_vm->_graphicsManager.colision2_ligne(a1, a2, &v83, &v88, 0, TOTAL_LIGNES) == 1) {
+			if (_vm->_linesManager.colision2_ligne(a1, a2, &v83, &v88, 0, _vm->_linesManager.TOTAL_LIGNES) == 1) {
 				v27 = 0;
 				while (1) {
 					v28 = READ_LE_UINT16(_vm->_globals.essai2 + 2 * (signed __int16)v27);
@@ -3736,7 +2953,7 @@ byte *ObjectsManager::PARC_VOITURE(int a1, int a2, int a3, int a4) {
 					v66 = READ_LE_UINT16(_vm->_globals.essai2 + 2 * (signed __int16)v27 + 4);
 					v27 = v27 + 4;
 					v30 = v27;
-					v31 = _vm->_graphicsManager.colision2_ligne(v28, v29, &v83, &v88, 0, _vm->_objectsManager.DERLIGNE);
+					v31 = _vm->_linesManager.colision2_ligne(v28, v29, &v83, &v88, 0, _vm->_objectsManager.DERLIGNE);
 					v27 = v30;
 					if (v31)
 						break;
@@ -3766,14 +2983,14 @@ LABEL_90:
 		if (v69 < v73) {
 			v34 = v68;
 			v35 = v68;
-			for (i = _vm->_globals.Ligne[v69].field0; v35 < (i - 2); i = _vm->_globals.Ligne[v69].field0) {
-				v37 = _vm->_globals.Ligne[v69].fieldC;
+			for (i = _vm->_linesManager.Ligne[v69].field0; v35 < (i - 2); i = _vm->_linesManager.Ligne[v69].field0) {
+				v37 = _vm->_linesManager.Ligne[v69].fieldC;
 				v38 = READ_LE_UINT16(v37 + 4 * v35);
 				int v37_2 = READ_LE_UINT16(v37 + 4 * v35 + 2);
 				v39 = v67;
 				_vm->_globals.super_parcours[v39] = v38;
 				_vm->_globals.super_parcours[v39 + 1] = v37_2;
-				_vm->_globals.super_parcours[v39 + 2] = _vm->_globals.Ligne[v69].field6;
+				_vm->_globals.super_parcours[v39 + 2] = _vm->_linesManager.Ligne[v69].field6;
 				_vm->_globals.super_parcours[v39 + 3] = 0;
 				v67 += 4;
 				++v34;
@@ -3781,32 +2998,33 @@ LABEL_90:
 			}
 			for (j = v69 + 1; j < v73; ++j) {
 				if (PLAN_TEST(
-						_vm->_globals.Ligne[j].fieldC,
-						READ_LE_UINT16(_vm->_globals.Ligne[j].fieldC + 2),
+						_vm->_linesManager.Ligne[j].fieldC,
+						READ_LE_UINT16(_vm->_linesManager.Ligne[j].fieldC + 2),
 				        v67,
 				        j,
 				        v73,
 				        0) == 1) {
 LABEL_88:
-					v69 = NV_LIGNEDEP;
-					v68 = NV_LIGNEOFS;
-					v67 = NV_POSI;
-					goto LABEL_90;
+							v69 = _vm->_linesManager.NV_LIGNEDEP;
+							v68 = _vm->_linesManager.NV_LIGNEOFS;
+							v67 = _vm->_linesManager.NV_POSI;
+							goto LABEL_90;
 				}
+
 				v40 = 0;
-				if (_vm->_globals.Ligne[j].field0 - 2 > 0) {
+				if (_vm->_linesManager.Ligne[j].field0 - 2 > 0) {
 					do {
-						v41 = _vm->_globals.Ligne[j].fieldC;
+						v41 = _vm->_linesManager.Ligne[j].fieldC;
 						v42 = READ_LE_UINT16(v41 + 4 * v40);
 						int v41_2 = READ_LE_UINT16(v41 + 4 * v40 + 2);
 						v43 = v67;
 						_vm->_globals.super_parcours[v43] = v42;
 						_vm->_globals.super_parcours[v43 + 1] = v41_2;
-						_vm->_globals.super_parcours[v43 + 2] = _vm->_globals.Ligne[j].field6;
+						_vm->_globals.super_parcours[v43 + 2] = _vm->_linesManager.Ligne[j].field6;
 						_vm->_globals.super_parcours[v43 + 3] = 0;
 						v67 += 4;
 						++v40;
-					} while (v40 < _vm->_globals.Ligne[j].field0 - 2);
+					} while (v40 < _vm->_linesManager.Ligne[j].field0 - 2);
 				}
 			}
 			v68 = 0;
@@ -3814,43 +3032,43 @@ LABEL_88:
 		}
 		if (v69 > v73) {
 			for (k = v68; k > 0; --k) {
-				v45 = _vm->_globals.Ligne[v69].fieldC;
+				v45 = _vm->_linesManager.Ligne[v69].fieldC;
 				v46 = READ_LE_UINT16(v45 + 4 * k);
 				int v45_2 = READ_LE_UINT16(v45 + 4 * k + 2);
 				v47 = v67;
 				_vm->_globals.super_parcours[v47] = v46;
 				_vm->_globals.super_parcours[v47 + 1] = v45_2;
-				_vm->_globals.super_parcours[v47 + 2] = _vm->_globals.Ligne[v69].field8;
+				_vm->_globals.super_parcours[v47 + 2] = _vm->_linesManager.Ligne[v69].field8;
 				_vm->_globals.super_parcours[v47 + 3] = 0;
 				v67 += 4;
 			}
 			for (l = v69 - 1; l > v73; --l) {
 				v48 = l;
 				if (PLAN_TEST(
-						_vm->_globals.Ligne[l].fieldC + 4 * _vm->_globals.Ligne[v48].field0 - 4,
-						READ_LE_UINT16(_vm->_globals.Ligne[l].fieldC + 4 * _vm->_globals.Ligne[v48].field0 - 2),
+						_vm->_linesManager.Ligne[l].fieldC + 4 * _vm->_linesManager.Ligne[v48].field0 - 4,
+						READ_LE_UINT16(_vm->_linesManager.Ligne[l].fieldC + 4 * _vm->_linesManager.Ligne[v48].field0 - 2),
 				        v67,
 				        l,
 				        v73,
 				        0) == 1)
 					goto LABEL_88;
-				v49 = _vm->_globals.Ligne[v48].field0 - 2;
-				if ((_vm->_globals.Ligne[v48].field0 - 2) > 0) {
+				v49 = _vm->_linesManager.Ligne[v48].field0 - 2;
+				if ((_vm->_linesManager.Ligne[v48].field0 - 2) > 0) {
 					do {
-						v50 = _vm->_globals.Ligne[l].fieldC;
+						v50 = _vm->_linesManager.Ligne[l].fieldC;
 						v51 = READ_LE_UINT16(v50 + 4 * v49);
 						int v50_2 = READ_LE_UINT16(v50 + 4 * v49 + 2);
 						v52 = v67;
 						_vm->_globals.super_parcours[v52] = v51;
 						_vm->_globals.super_parcours[v52 + 1] = v50_2;
-						_vm->_globals.super_parcours[v52 + 2] = _vm->_globals.Ligne[l].field8;
+						_vm->_globals.super_parcours[v52 + 2] = _vm->_linesManager.Ligne[l].field8;
 						_vm->_globals.super_parcours[v52 + 3] = 0;
 						v67 += 4;
 						--v49;
 					} while (v49 > 0);
 				}
 			}
-			v68 = _vm->_globals.Ligne[v73].field0 - 1;
+			v68 = _vm->_linesManager.Ligne[v73].field0 - 1;
 			v69 = v73;
 		}
 		if (v69 == v73) {
@@ -3858,13 +3076,13 @@ LABEL_88:
 				if (v68 < v72) {
 					v57 = v68;
 					do {
-						v58 = _vm->_globals.Ligne[v73].fieldC;
+						v58 = _vm->_linesManager.Ligne[v73].fieldC;
 						v59 = READ_LE_UINT16(v58 + 4 * v57);
 						int v58_2 = READ_LE_UINT16(v58 + 4 * v57 + 2);
 						v60 = v67;
 						_vm->_globals.super_parcours[v60] = v59;
 						_vm->_globals.super_parcours[v60 + 1] = v58_2;
-						_vm->_globals.super_parcours[v60 + 2] = _vm->_globals.Ligne[v73].field6;
+						_vm->_globals.super_parcours[v60 + 2] = _vm->_linesManager.Ligne[v73].field6;
 						_vm->_globals.super_parcours[v60 + 3] = 0;
 						v67 += 4;
 						++v57;
@@ -3873,13 +3091,13 @@ LABEL_88:
 			} else {
 				v53 = v68;
 				do {
-					v54 = _vm->_globals.Ligne[v73].fieldC;
+					v54 = _vm->_linesManager.Ligne[v73].fieldC;
 					v55 = READ_LE_UINT16(v54 + 4 * v53);
 					int v54_2 = READ_LE_UINT16(v54 + 4 * v53 + 2);
 					v56 = v67;
 					_vm->_globals.super_parcours[2 * v56] = v55;
 					_vm->_globals.super_parcours[2 * v56 + 1] = v54_2;
-					_vm->_globals.super_parcours[2 * v56 + 2] = _vm->_globals.Ligne[v73].field8;
+					_vm->_globals.super_parcours[2 * v56 + 2] = _vm->_linesManager.Ligne[v73].field8;
 					_vm->_globals.super_parcours[2 * v56 + 3] = 0;
 					v67 += 4;
 					--v53;
@@ -4190,7 +3408,7 @@ int ObjectsManager::MZONE() {
 					        && _vm->_globals.CarreZone[v7].field6 <= v20
 					        && _vm->_globals.CarreZone[v7].field8 >= v20) {
 								if (_vm->_globals.CarreZone[v7].fieldE == 1) {
-									_vm->_globals.oldzone_46 = _vm->_globals.LigneZone[_vm->_globals.CarreZone[v7].fieldA].field2;
+									_vm->_globals.oldzone_46 = _vm->_linesManager.LigneZone[_vm->_globals.CarreZone[v7].fieldA].field2;
 							return _vm->_globals.oldzone_46;
 						}
 						v9 = _vm->_globals.SegmentEnCours;
@@ -4245,10 +3463,6 @@ LABEL_58:
 	return result;
 }
 
-void ObjectsManager::CLEAR_ZONE() {
-	warning("TODO: CLEAR_ZONE");
-}
-
 void ObjectsManager::RESET_OBSTACLE() {
 	warning("TODO: CLEAR_ZONE");
 }
@@ -5120,7 +4334,7 @@ LABEL_1141:
 			_vm->_globals.chemin = PTRNUL;
 			v13 = YSPR(0);
 			v14 = XSPR(0);
-			_vm->_globals.chemin = PARCOURS2(v14, v13, 564, 420);
+			_vm->_globals.chemin = _vm->_linesManager.PARCOURS2(v14, v13, 564, 420);
 			_vm->_objectsManager.NUMZONE = -1;
 			do {
 				GOHOME();
@@ -5191,7 +4405,7 @@ LABEL_1141:
 			_vm->_globals.chemin = PTRNUL;
 			v16 = YSPR(0);
 			v17 = XSPR(0);
-			_vm->_globals.chemin = PARCOURS2(v17, v16, 445, 332);
+			_vm->_globals.chemin = _vm->_linesManager.PARCOURS2(v17, v16, 445, 332);
 			_vm->_globals.NOT_VERIF = 1;
 			do {
 				GOHOME();
@@ -5311,7 +4525,7 @@ LABEL_1141:
 			_vm->_globals.chemin = PTRNUL;
 			v22 = YSPR(0);
 			v23 = XSPR(0);
-			_vm->_globals.chemin = PARCOURS2(v23, v22, 119, 268);
+			_vm->_globals.chemin = _vm->_linesManager.PARCOURS2(v23, v22, 119, 268);
 			_vm->_globals.NOT_VERIF = 1;
 			do {
 				GOHOME();
@@ -5534,17 +4748,17 @@ LABEL_1141:
 			if (_vm->_globals.SAUVEGARDE->data[svField253] == 1) {
 				v27 = YSPR(0);
 				v28 = XSPR(0);
-				_vm->_globals.chemin = PARCOURS2(v28, v27, 201, 294);
+				_vm->_globals.chemin = _vm->_linesManager.PARCOURS2(v28, v27, 201, 294);
 			}
 			if (_vm->_globals.SAUVEGARDE->data[svField253] == 2) {
 				v29 = YSPR(0);
 				v30 = XSPR(0);
-				_vm->_globals.chemin = PARCOURS2(v30, v29, 158, 338);
+				_vm->_globals.chemin = _vm->_linesManager.PARCOURS2(v30, v29, 158, 338);
 			}
 			if (_vm->_globals.SAUVEGARDE->data[svField253] > 2) {
 				v31 = YSPR(0);
 				v32 = XSPR(0);
-				_vm->_globals.chemin = PARCOURS2(v32, v31, 211, 393);
+				_vm->_globals.chemin = _vm->_linesManager.PARCOURS2(v32, v31, 211, 393);
 			}
 			_vm->_globals.NOT_VERIF = 1;
 			do {
@@ -5741,7 +4955,7 @@ LABEL_1141:
 			_vm->_globals.chemin = PTRNUL;
 			v37 = YSPR(0);
 			v38 = XSPR(0);
-			_vm->_globals.chemin = PARCOURS2(v38, v37, 330, 418);
+			_vm->_globals.chemin = _vm->_linesManager.PARCOURS2(v38, v37, 330, 418);
 			_vm->_globals.NOT_VERIF = 1;
 			_vm->_objectsManager.NUMZONE = 0;
 			do {
@@ -5767,7 +4981,7 @@ LABEL_1141:
 			_vm->_globals.NOT_VERIF = 1;
 			v39 = YSPR(0);
 			v40 = XSPR(0);
-			_vm->_globals.chemin = PARCOURS2(v40, v39, 330, 314);
+			_vm->_globals.chemin = _vm->_linesManager.PARCOURS2(v40, v39, 330, 314);
 			_vm->_objectsManager.NUMZONE = 0;
 			_vm->_globals.NOT_VERIF = 1;
 			do {
@@ -5891,7 +5105,7 @@ LABEL_1141:
 			_vm->_globals.NOT_VERIF = 1;
 			v43 = YSPR(0);
 			v44 = XSPR(0);
-			_vm->_globals.chemin = PARCOURS2(v44, v43, 488, 280);
+			_vm->_globals.chemin = _vm->_linesManager.PARCOURS2(v44, v43, 488, 280);
 			_vm->_globals.NOT_VERIF = 1;
 			do {
 				GOHOME();
@@ -6378,7 +5592,7 @@ LABEL_1141:
 			_vm->_globals.NOT_VERIF = 1;
 			v55 = YSPR(0);
 			v56 = XSPR(0);
-			_vm->_globals.chemin = PARCOURS2(v56, v55, 361, 325);
+			_vm->_globals.chemin = _vm->_linesManager.PARCOURS2(v56, v55, 361, 325);
 			_vm->_globals.NOT_VERIF = 1;
 			_vm->_objectsManager.NUMZONE = -1;
 			do {
@@ -6399,7 +5613,7 @@ LABEL_1141:
 			_vm->_globals.NOT_VERIF = 1;
 			v57 = YSPR(0);
 			v58 = XSPR(0);
-			_vm->_globals.chemin = PARCOURS2(v58, v57, 361, 325);
+			_vm->_globals.chemin = _vm->_linesManager.PARCOURS2(v58, v57, 361, 325);
 			_vm->_globals.NOT_VERIF = 1;
 			_vm->_objectsManager.NUMZONE = -1;
 			do {
@@ -6579,16 +5793,6 @@ void ObjectsManager::VERBE_ON(int a1, int a2) {
 	warning("TODO: VERBE_ON");
 }
 
-int ObjectsManager::PARC_PERS(int a1, int a2, int a3, int a4, int a5, int a6, int a7) {
-	warning("TODO: PARC_PERS");
-	return 0;
-}
-
-int ObjectsManager::MIRACLE(int a1, int a2, int a3, int a4, int a5) {
-	warning("TODO: MIRACLE");
-	return 0;
-}
-
 int ObjectsManager::GENIAL(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int16 *a8, int a9) {
 	warning("TODO: GENIAL");
 	return 0;
@@ -6646,13 +5850,13 @@ int ObjectsManager::colision(int a1, int a2) {
 		int v9 = v3 + 1;
 
 		do {
-			byte *srcP = _vm->_globals.LigneZone[v8].field4;
+			byte *srcP = _vm->_linesManager.LigneZone[v8].field4;
 			if (srcP != PTRNUL) {
 				bool flag = true;
-				int v11 = READ_LE_UINT16(srcP + _vm->_globals.LigneZone[v8].field0 * 2);
-				int dataV2 = READ_LE_UINT16(srcP + _vm->_globals.LigneZone[v8].field0 * 2 + 2);
-				int v12 = READ_LE_UINT16(srcP + _vm->_globals.LigneZone[v8].field0 * 4 - 4);
-				int v13 = READ_LE_UINT16(srcP + _vm->_globals.LigneZone[v8].field0 * 4 - 2);
+				int v11 = READ_LE_UINT16(srcP + _vm->_linesManager.LigneZone[v8].field0 * 2);
+				int dataV2 = READ_LE_UINT16(srcP + _vm->_linesManager.LigneZone[v8].field0 * 2 + 2);
+				int v12 = READ_LE_UINT16(srcP + _vm->_linesManager.LigneZone[v8].field0 * 4 - 4);
+				int v13 = READ_LE_UINT16(srcP + _vm->_linesManager.LigneZone[v8].field0 * 4 - 2);
 				int v10 = v13;
 
 				if (v11 < v12 && v4 >= v11 && v5 > v13)
@@ -6666,14 +5870,14 @@ int ObjectsManager::colision(int a1, int a2) {
 
 
 				if (!flag) {
-					if (v11 < _vm->_globals.LigneZone[v8].field0) {
-						for (; v11 < _vm->_globals.LigneZone[v8].field0; ++idx) {
+					if (v11 < _vm->_linesManager.LigneZone[v8].field0) {
+						for (; v11 < _vm->_linesManager.LigneZone[v8].field0; ++idx) {
 							int v11 = READ_LE_UINT16(srcP);
 							int v12 = READ_LE_UINT16(srcP + 2);
 							srcP += 4;
 							
 							if ((v2 == v11 || v9 == v11) && a2 == v12)
-								return _vm->_globals.LigneZone[v8].field2;
+								return _vm->_linesManager.LigneZone[v8].field2;
 						}
 					}
 				}
diff --git a/engines/hopkins/objects.h b/engines/hopkins/objects.h
index bb88d08c12..1f79283215 100644
--- a/engines/hopkins/objects.h
+++ b/engines/hopkins/objects.h
@@ -93,7 +93,6 @@ public:
 	int CHANGEVERBE;
 	int verbe;
 	int Vold_taille;
-	int TOTAL_LIGNES;
 	bool SPEED_FLAG;
 	int SPEED_X, SPEED_Y;
 	int SPEED_IMAGE;
@@ -122,11 +121,6 @@ public:
 	int OBSSEUL;
 	int NVVERBE;
 	int NVZONE;
-	int NV_LIGNEDEP;
-	int NV_LIGNEOFS;
-	int NV_POSI;
-	int NVPX;
-	int NVPY;
 public:
 	ObjectsManager();
 	void setParent(HopkinsEngine *vm);
@@ -202,14 +196,12 @@ public:
 	
 	void INVENT();
 	void CHANGE_TETE(int a1, int a2);
-	byte *PARCOURS2(int a1, int a2, int a3, int a4);
 	void VERIFTAILLE();
 	void PACOURS_PROPRE(byte *a1);
 	byte *PARC_VOITURE(int a1, int a2, int a3, int a4);
 	void VERBEPLUS();
 	void BTDROITE();
 	int MZONE();
-	void CLEAR_ZONE();
 	void RESET_OBSTACLE();
 	int ZONE_OBJET(int a1, int a2);
 	void PARAMCADRE(int a1);
@@ -242,8 +234,6 @@ public:
 	int Control_If(const byte *dataP, int a2);
 	void VERBE_OFF(int a1, int a2);
 	void VERBE_ON(int a1, int a2);
-	int PARC_PERS(int a1, int a2, int a3, int a4, int a5, int a6, int a7);
-	int MIRACLE(int a1, int a2, int a3, int a4, int a5);
 	int GENIAL(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int16 *a8, int a9);
 	int CALC_PROPRE(int idx);
 	int PLAN_TEST(byte *a1, int a2, int a3, int a4, int a5, int a6);