Revert "Merge branch 'lcs' of https://github.com/GTAmodding/re3 into lcs"

This reverts commit d63e3f1559, reversing changes made to ec17355056.
2024-11-29 12:23:43 +00:00 · 2021-01-13 23:15:33 +03:00 · 2021-01-13 23:15:33 +03:00 · 97c9a4a02c
commit 97c9a4a02c
parent d63e3f1559
40 changed files with 542 additions and 707 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,82 +1,44 @@
 cmake_minimum_required(VERSION 3.8)

-set(EXECUTABLE reLCS)
-set(PROJECT RELCS)
-
-project(${EXECUTABLE} C CXX)
+project(reVC C CXX)
 list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake")

 if(WIN32)
-    set(${PROJECT}_AUDIOS "OAL" "MSS")
+    set(REVC_AUDIOS "NULL" "OAL" "MSS")
 else()
-    set(${PROJECT}_AUDIOS "OAL")
+    set(REVC_AUDIOS "NULL" "OAL")
 endif()

-set(${PROJECT}_AUDIO "OAL" CACHE STRING "Audio")
+set(REVC_AUDIO "OAL" CACHE STRING "Audio")

-option(${PROJECT}_WITH_OPUS "Build ${EXECUTABLE} with opus support" OFF)
-option(${PROJECT}_WITH_LIBSNDFILE "Build ${EXECUTABLE} with libsndfile (instead of internal decoder)" OFF)
-
-set_property(CACHE ${PROJECT}_AUDIO PROPERTY STRINGS ${${PROJECT}_AUDIOS})
-message(STATUS "${PROJECT}_AUDIO = ${${PROJECT}_AUDIO} (choices=${${PROJECT}_AUDIOS})")
-set("${PROJECT}_AUDIO_${${PROJECT}_AUDIO}" ON)
-if(NOT ${PROJECT}_AUDIO IN_LIST ${PROJECT}_AUDIOS)
-    message(FATAL_ERROR "Illegal ${PROJECT}_AUDIO=${${PROJECT}_AUDIO}")
+set_property(CACHE REVC_AUDIO PROPERTY STRINGS ${REVC_AUDIOS})
+message(STATUS "REVC_AUDIO = ${REVC_AUDIO} (choices=${REVC_AUDIOS})")
+set("REVC_AUDIO_${REVC_AUDIO}" ON)
+if(NOT REVC_AUDIO IN_LIST REVC_AUDIOS)
+    message(FATAL_ERROR "Illegal REVC_AUDIO=${REVC_AUDIO}")
 endif()

-option(${PROJECT}_VENDORED_LIBRW "Use vendored librw" ON)
-if(${PROJECT}_VENDORED_LIBRW)
-    add_subdirectory(vendor/librw)
-else()
-    find_package(librw REQUIRED)
+if(REVC_INSTALL)
+    include(GNUInstallDirs)
+    set(REVC_INSTALL_INCLUDEDIR "${CMAKE_INSTALL_INCLUDEDIR}/reVC")
 endif()
+
+add_subdirectory("vendor/librw")
 add_subdirectory(src)

-if(${PROJECT}_INSTALL)
-    install(DIRECTORY gamefiles/ DESTINATION ".")
-    if(LIBRW_PLATFORM_NULL)
-        set(platform "-null")
-    elseif(LIBRW_PLATFORM_PS2)
-        set(platform "-ps2")
-    elseif(LIBRW_PLATFORM_GL3)
-        if(LIBRW_GL3_GFXLIB STREQUAL "GLFW")
-            set(platform "-gl3-glfw")
-        else()
-            set(platform "-gl3-sdl2")
-        endif()
-    elseif(LIBRW_PLATFORM_D3D9)
-        set(platform "-d3d9")
-    endif()
-    if(${PROJECT}_AUDIO_OAL)
-        set(audio "-oal")
-    elseif(${PROJECT}_AUDIO_MSS)
-        set(audio "-mss")
-    endif()
-    if(${PROJECT}_WITH_OPUS)
-        set(audio "${audio}-opus")
-    endif()
-    if(NOT LIBRW_PLATFORM_PS2)
-        if(WIN32)
-            set(os "-win")
-        elseif(APPLE)
-            set(os "-apple")
-        elseif(UNIX)
-            set(os "-linux")
-        else()
-            set(compiler "-UNK")
-            message(WARNING "Unknown os. Created cpack package will be wrong. (override using cpack -P)")
-        endif()
-    endif()
+if(REVC_INSTALL)
+    include(CMakePackageConfigHelpers)
+    configure_package_config_file(reVC-config.cmake.in reVC-config.cmake
+        INSTALL_DESTINATION "${CMAKE_INSTALL_PREFIX}"
+        )
+    install(
+        FILES "${CMAKE_CURRENT_BINARY_DIR}/reVC-config.cmake"
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
+        )
+    install(
+        EXPORT reVC-targets
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
+        )

-    set(CPACK_PACKAGE_NAME "${PROJECT_NAME}${platform}${audio}${os}${compiler}")
-    set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "GTA III reversed")
-    set(CPACK_PACKAGE_VENDOR "GTAModding")
-    # FIXME: missing license (https://github.com/GTAmodding/re3/issues/794)
-    # set(CPACK_PACKAGE_DESCRIPTION_FILE "${PROJECT_SOURCE_DIR}/LICENSE")
-    # set(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/LICENSE")
-    set(CPACK_PACKAGE_INSTALL_DIRECTORY "${CPACK_PACKAGE_NAME}")
-    set(CPACK_SOURCE_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}")
-    set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}")
-    set(CPACK_GENERATOR "TXZ")
-    include(CPack)
+    include(CMakeCPack.cmake)
 endif()
--- a/README.md
+++ b/README.md
@ -35,13 +35,6 @@ There are various settings at the very bottom of [config.h](https://github.com/G
 ## Contributing
 Please read the [Coding Style](https://github.com/GTAmodding/re3/blob/master/CODING_STYLE.md) Document

-### Unreversed / incomplete classes  
-
-PS2/Mobile stuff:
-
-	src/core/Pad.cpp
-	src/core/main.cpp
-	src/core/Frontend_PS2.cpp
-	src/core/FrontEndControls.cpp
-	src/save/MemoryCard.cpp
+### Unreversed / incomplete classes (at least the ones we know)
+See [VC todo list](https://github.com/GTAmodding/re3/wiki/VC-todo)

--- a/cmake/FindMPG123.cmake
+++ b/cmake/FindMPG123.cmake
@ -0,0 +1,28 @@
+# - Find mpg123
+# Find the native mpg123 includes and library
+#
+#  MPG123_INCLUDE_DIR - where to find mpg123.h
+#  MPG123_LIBRARIES   - List of libraries when using mpg123.
+#  MPG123_FOUND       - True if mpg123 found.
+
+IF(MPG123_INCLUDE_DIR AND MPG123_LIBRARIES)
+  # Already in cache, be silent
+  SET(MPG123_FIND_QUIETLY TRUE)
+ENDIF(MPG123_INCLUDE_DIR AND MPG123_LIBRARIES)
+
+FIND_PATH(MPG123_INCLUDE_DIR mpg123.h
+          PATHS "${MPG123_DIR}"
+          PATH_SUFFIXES include
+          )
+
+FIND_LIBRARY(MPG123_LIBRARIES NAMES mpg123 mpg123-0
+             PATHS "${MPG123_DIR}"
+             PATH_SUFFIXES lib
+             )
+
+# MARK_AS_ADVANCED(MPG123_LIBRARIES MPG123_INCLUDE_DIR)
+
+# handle the QUIETLY and REQUIRED arguments and set MPG123_FOUND to TRUE if
+# all listed variables are TRUE
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(MPG123 DEFAULT_MSG MPG123_LIBRARIES MPG123_INCLUDE_DIR)
--- a/cmake/FindSndFile.cmake
+++ b/cmake/FindSndFile.cmake
@ -4,11 +4,9 @@
 # 
 # Once done this will define
 #
-#  SNDFILE_FOUND        - system has libsndfile
+#  SNDFILE_FOUND - system has libsndfile
 #  SNDFILE_INCLUDE_DIRS - the libsndfile include directory
-#  SNDFILE_LIBRARIES    - Link these to use libsndfile
-#  SNDFILE_CFLAGS       - Compile options to use libsndfile
-#  SndFile::SndFile     - Imported library of libsndfile
+#  SNDFILE_LIBRARIES - Link these to use libsndfile
 #
 #  Copyright (C) 2006  Wengo
 #
@ -17,51 +15,53 @@
 #  For details see the accompanying COPYING-CMAKE-SCRIPTS file.
 #

-find_package(PkgConfig QUIET)
-if(PKG_CONFIG_FOUND)
-    pkg_search_module(PKG_SNDFILE "sndfile")
-endif()
+if (SNDFILE_LIBRARIES AND SNDFILE_INCLUDE_DIRS)
+  # in cache already
+  set(SNDFILE_FOUND TRUE)
+else (SNDFILE_LIBRARIES AND SNDFILE_INCLUDE_DIRS)

-find_path(SNDFILE_INCLUDE_DIR
+  find_path(SNDFILE_INCLUDE_DIR
    NAMES
-        sndfile.h
-    HINTS
-        ${PKG_SNDFILE_INCLUDE_DIRS}
+      sndfile.h
    PATHS
-        /usr/include
-        /usr/local/include
-        /opt/local/include
-        /sw/include
-    )
-
-find_library(SNDFILE_LIBRARY
+      /usr/include
+      /usr/local/include
+      /opt/local/include
+      /sw/include
+  )
+  
+  find_library(SNDFILE_LIBRARY
    NAMES
-        sndfile
-    HINTS
-        ${PKG_SNDFILE_LIBRARIES}
+      sndfile
    PATHS
-        /usr/lib
-        /usr/local/lib
-        /opt/local/lib
-        /sw/lib
-)
+      /usr/lib
+      /usr/local/lib
+      /opt/local/lib
+      /sw/lib
+  )

-set(SNDFILE_CFLAGS "${PKG_SNDFILE_CFLAGS_OTHER}" CACHE STRING "CFLAGS of libsndfile")
+  set(SNDFILE_INCLUDE_DIRS
+    ${SNDFILE_INCLUDE_DIR}
+  )
+  set(SNDFILE_LIBRARIES
+    ${SNDFILE_LIBRARY}
+  )

-set(SNDFILE_INCLUDE_DIRS "${SNDFILE_INCLUDE_DIR}")
-set(SNDFILE_LIBRARIES "${SNDFILE_LIBRARY}")
-
-if(SNDFILE_INCLUDE_DIRS AND SNDFILE_LIBRARIES)
+  if (SNDFILE_INCLUDE_DIRS AND SNDFILE_LIBRARIES)
    set(SNDFILE_FOUND TRUE)
-endif()
+  endif (SNDFILE_INCLUDE_DIRS AND SNDFILE_LIBRARIES)

-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(SndFile DEFAULT_MSG SNDFILE_INCLUDE_DIRS SNDFILE_LIBRARIES)
+  if (SNDFILE_FOUND)
+    if (NOT SndFile_FIND_QUIETLY)
+      message(STATUS "Found libsndfile: ${SNDFILE_LIBRARIES}")
+    endif (NOT SndFile_FIND_QUIETLY)
+  else (SNDFILE_FOUND)
+    if (SndFile_FIND_REQUIRED)
+      message(FATAL_ERROR "Could not find libsndfile")
+    endif (SndFile_FIND_REQUIRED)
+  endif (SNDFILE_FOUND)

-if(NOT TARGET SndFile::SndFile)
-    add_library(__SndFile INTERFACE)
-    target_compile_options(__SndFile INTERFACE ${SNDFILE_CFLAGS})
-    target_include_directories(__SndFile INTERFACE ${SNDFILE_INCLUDE_DIRS})
-    target_link_libraries(__SndFile INTERFACE ${SNDFILE_LIBRARIES})
-    add_library(SndFile::SndFile ALIAS __SndFile)
-endif()
+  # show the SNDFILE_INCLUDE_DIRS and SNDFILE_LIBRARIES variables only in the advanced view
+  mark_as_advanced(SNDFILE_INCLUDE_DIRS SNDFILE_LIBRARIES)
+
+endif (SNDFILE_LIBRARIES AND SNDFILE_INCLUDE_DIRS)
--- a/cmake/Findmpg123.cmake
+++ b/cmake/Findmpg123.cmake
@ -1,38 +0,0 @@
-# - Find mpg123
-# Find the native mpg123 includes and library
-#
-#  mpg123_INCLUDE_DIR - Where to find mpg123.h
-#  mpg123_LIBRARIES   - List of libraries when using mpg123.
-#  mpg123_CFLAGS      - Compile options to use mpg123
-#  mpg123_FOUND       - True if mpg123 found.
-#  MPG123::libmpg123  - Imported library of libmpg123
-
-find_package(PkgConfig QUIET)
-if(PKG_CONFIG_FOUND)
-    pkg_search_module(PKG_MPG123 mpg123)
-endif()
-
-find_path(mpg123_INCLUDE_DIR mpg123.h
-    HINTS ${PKG_MPG123_INCLUDE_DIRS}
-    PATHS "${mpg123_DIR}"
-    PATH_SUFFIXES include
-)
-
-find_library(mpg123_LIBRARIES NAMES mpg123 mpg123-0
-    HINTS ${PKG_MPG123_LIBRARIES}
-    PATHS "${mpg123_DIR}"
-    PATH_SUFFIXES lib
-)
-
-set(mpg123_CFLAGS "${PKG_MPG123_CFLAGS_OTHER}" CACHE STRING "CFLAGS of mpg123")
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(mpg123 DEFAULT_MSG mpg123_LIBRARIES mpg123_INCLUDE_DIR)
-
-if(NOT TARGET MPG123::libmpg123)
-    add_library(__libmpg123 INTERFACE)
-    target_compile_options(__libmpg123 INTERFACE ${mpg123_CFLAGS})
-    target_include_directories(__libmpg123 INTERFACE ${mpg123_INCLUDE_DIR})
-    target_link_libraries(__libmpg123 INTERFACE ${mpg123_LIBRARIES})
-    add_library(MPG123::libmpg123 ALIAS __libmpg123)
-endif()
--- a/premake5.lua
+++ b/premake5.lua
@ -172,10 +172,11 @@ workspace "reLCS"

 	filter  {}
 		
-    function setpaths (gamepath, exepath)
+    function setpaths (gamepath, exepath, scriptspath)
+       scriptspath = scriptspath or ""
       if (gamepath) then
          postbuildcommands {
-             '{COPYFILE} "%{cfg.buildtarget.abspath}" "' .. gamepath .. '%{cfg.buildtarget.name}"'
+             '{COPYFILE} "%{cfg.buildtarget.abspath}" "' .. gamepath .. scriptspath .. '%{cfg.buildtarget.name}"'
          }
          debugdir (gamepath)
          if (exepath) then
@ -185,6 +186,7 @@ workspace "reLCS"
             debugdir (gamepath .. (dir or ""))
          end
       end
+       --targetdir ("bin/%{prj.name}/" .. scriptspath)
    end

 if(_OPTIONS["with-librw"]) then
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@ -1,105 +1,92 @@
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)

-file(GLOB_RECURSE ${PROJECT}_SOURCES "*.cpp" "*.h" "*.rc")
+if(${REVC_AUDIO} STREQUAL "OAL")
+        find_package(OpenAL REQUIRED)
+        find_package(MPG123 REQUIRED)
+        find_package(SndFile REQUIRED)
+endif()

-function(header_directories RETURN_LIST)
-    file(GLOB_RECURSE ALL_SRCS *.h *.cpp *.c)
-    set(RELDIRS)
-    foreach(SRC ${ALL_SRCS})
-        file(RELATIVE_PATH RELSRC "${CMAKE_CURRENT_SOURCE_DIR}" "${SRC}")
-        get_filename_component(RELDIR "${RELSRC}" DIRECTORY)
-        list(APPEND RELDIRS ${RELDIR})
-    endforeach()
-    list(REMOVE_DUPLICATES RELDIRS)
-    set(${RETURN_LIST} ${RELDIRS} PARENT_SCOPE)
-endfunction()
+file(GLOB_RECURSE Sources "*.cpp" "*.h")

-header_directories(${PROJECT}_INCLUDES)
+MACRO(HEADER_DIRECTORIES return_list)
+    FILE(GLOB_RECURSE new_list *.cpp)
+    SET(dir_list "animation"
+            "audio"
+            "collision"
+            "control"
+            "core"
+            "entities"
+            "extras"
+            "fakerw"
+            "math"
+            "modelinfo"
+            "objects"
+            "peds"
+            "render"
+            "rw"
+            "save"
+            "skel"
+            "text"
+            "vehicles"
+            "weapons")
+    FOREACH(file_path ${new_list})
+        GET_FILENAME_COMPONENT(dir_path ${file_path} PATH)
+        SET(dir_list ${dir_list} ${dir_path})
+    ENDFOREACH()
+    LIST(REMOVE_DUPLICATES dir_list)
+    SET(${return_list} ${dir_list})
+ENDMACRO()

-add_executable(${EXECUTABLE} WIN32
-    ${${PROJECT}_SOURCES}
-)
+HEADER_DIRECTORIES(header_list)
+include_directories(${header_list})

-target_link_libraries(${EXECUTABLE} PRIVATE
-    librw::librw
-    Threads::Threads
-)

-target_include_directories(${EXECUTABLE}
-    PRIVATE
+add_executable(reVC ${Sources})
+target_link_libraries(reVC librw)
+target_link_libraries(reVC Threads::Threads)
+
+if(${REVC_AUDIO} STREQUAL "OAL")
+        target_link_libraries(reVC ${OPENAL_LIBRARY})
+        target_link_libraries(reVC ${MPG123_LIBRARIES})
+        target_link_libraries(reVC ${SNDFILE_LIBRARIES})
+endif()
+
+target_include_directories(reVC
+    INTERFACE
        $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
-        $<BUILD_INTERFACE:${${PROJECT}_INCLUDES}>
-)
+    )

-target_compile_definitions(${EXECUTABLE}
+target_compile_definitions(reVC
    PRIVATE
-        $<IF:$<CONFIG:DEBUG>,DEBUG,NDEBUG>
-        LIBRW
-        ${PROJECT}_NO_AUTOLINK
-)
-
-if(LIBRW_PLATFORM_D3D9)
-    target_compile_definitions(${EXECUTABLE}
-        PUBLIC
-            USE_D3D9
+        "$<IF:$<CONFIG:DEBUG>,DEBUG,NDEBUG>"
+    PUBLIC
+        "RW_${REVC_PLATFORM}"
    )
-endif()

-if(${PROJECT}_AUDIO STREQUAL "OAL")
-    find_package(OpenAL REQUIRED)
-    target_include_directories(${EXECUTABLE} PRIVATE ${OPENAL_INCLUDE_DIR})
-    target_link_libraries(${EXECUTABLE} PRIVATE ${OPENAL_LIBRARY})
-    target_compile_definitions(${EXECUTABLE} PRIVATE ${OPENAL_DEFINITIONS})
-    target_compile_definitions(${EXECUTABLE} PRIVATE AUDIO_OAL)
-elseif(${PROJECT}_AUDIO STREQUAL "MSS")
-    find_package(MilesSDK REQUIRED)
-    target_compile_definitions(${EXECUTABLE} PRIVATE AUDIO_MSS)
-    target_link_libraries(${EXECUTABLE} PRIVATE MilesSDK::MilesSDK)
-endif()
-
-find_package(mpg123 REQUIRED)
-target_link_libraries(${EXECUTABLE} PRIVATE
-    MPG123::libmpg123
-)
-if(${PROJECT}_WITH_OPUS)
-    find_package(opusfile REQUIRED)
-    target_link_libraries(${EXECUTABLE} PRIVATE
-        opusfile::opusfile
-    )
-    target_compile_definitions(${EXECUTABLE} PRIVATE AUDIO_OPUS)
-endif()
-if(${PROJECT}_WITH_LIBSNDFILE)
-    find_package(SndFile REQUIRED)
-    target_link_libraries(${EXECUTABLE} PRIVATE
-        SndFile::SndFile
-    )
-    target_compile_definitions(${EXECUTABLE} PRIVATE AUDIO_OAL_USE_SNDFILE)
-endif()
-
-target_compile_definitions(${EXECUTABLE} PRIVATE )
+target_compile_definitions(reVC PRIVATE LIBRW=1 AUDIO_OAL=1)

 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
-    target_compile_options(${EXECUTABLE}
+    target_compile_options(reVC
        PRIVATE
            "-Wall"
-    )
-    if (NOT LIBRW_PLATFORM_PS2)
-        target_compile_options(${EXECUTABLE}
-            PRIVATE
-                -Wextra
-                -Wdouble-promotion
-                -Wpedantic
        )
+    if (NOT REVC_PLATFORM_PS2)
+        target_compile_options(reVC
+            PRIVATE
+                "-Wextra"
+                "-Wdouble-promotion"
+                "-Wpedantic"
+            )
    endif()
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-    target_compile_options(${EXECUTABLE}
+    target_compile_options(reVC
        PUBLIC
-            /Zc:sizedDealloc-
-    )
+            /wd4996 /wd4244
+        )
 endif()

-set_target_properties(${EXECUTABLE}
+set_target_properties(reVC
    PROPERTIES
        C_STANDARD 11
        C_EXTENSIONS OFF
@ -107,15 +94,20 @@ set_target_properties(${EXECUTABLE}
        CXX_STANDARD 11
        CXX_EXTENSIONS OFF
        CXX_STANDARD_REQUIRED ON
-)
-
-if(${PROJECT}_INSTALL)
-    install(
-        TARGETS ${EXECUTABLE}
-        EXPORT ${EXECUTABLE}-targets
-        RUNTIME DESTINATION "."
+        PREFIX ""
    )
-    if(MSVC)
-        install(FILES $<TARGET_PDB_FILE:${EXECUTABLE}> DESTINATION "." OPTIONAL)
-    endif()
+
+if(REVC_INSTALL)
+    target_include_directories(reVC
+        INTERFACE
+            $<INSTALL_INTERFACE:${REVC_INSTALL_INCLUDEDIR}>
+        )
+
+    install(
+        TARGETS reVC
+        EXPORT reVC-targets
+        RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
+        LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+        ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+        )
 endif()
--- a/src/animation/AnimBlendClumpData.cpp
+++ b/src/animation/AnimBlendClumpData.cpp
@ -8,7 +8,7 @@
 CAnimBlendClumpData::CAnimBlendClumpData(void)
 {
 	numFrames = 0;
-	velocity2d = nil;
+	velocity = nil;
 	frames = nil;
 	link.Init();
 }
--- a/src/animation/AnimBlendClumpData.h
+++ b/src/animation/AnimBlendClumpData.h
@ -3,6 +3,7 @@
 #include "AnimBlendList.h"


+// TODO: put somewhere else
 struct AnimBlendFrameData
 {
 	enum {
@ -30,10 +31,7 @@ class CAnimBlendClumpData
 public:
 	CAnimBlendLink link;
 	int32 numFrames;
-	union {
-		CVector2D *velocity2d;
-		CVector *velocity3d;
-	};
+	CVector *velocity;
 	// order of frames is determined by RW hierarchy
 	AnimBlendFrameData *frames;

--- a/src/animation/FrameUpdate.cpp
+++ b/src/animation/FrameUpdate.cpp
@ -33,7 +33,7 @@ FrameUpdateCallBackNonSkinned(AnimBlendFrameData *frame, void *arg)
 	AnimBlendFrameUpdateData *updateData = (AnimBlendFrameUpdateData*)arg;

 	if(frame->flag & AnimBlendFrameData::VELOCITY_EXTRACTION &&
-	   gpAnimBlendClump->velocity2d){
+	   gpAnimBlendClump->velocity){
 		if(frame->flag & AnimBlendFrameData::VELOCITY_EXTRACTION_3D)
 			FrameUpdateCallBackWith3dVelocityExtractionNonSkinned(frame, arg);
 		else
@ -142,11 +142,11 @@ FrameUpdateCallBackWithVelocityExtractionNonSkinned(AnimBlendFrameData *frame, v
 	}

 	if((frame->flag & AnimBlendFrameData::IGNORE_TRANSLATION) == 0){
-		gpAnimBlendClump->velocity2d->x = transx - curx;
-		gpAnimBlendClump->velocity2d->y = transy - cury;
+		gpAnimBlendClump->velocity->x = transx - curx;
+		gpAnimBlendClump->velocity->y = transy - cury;
 		if(looped){
-			gpAnimBlendClump->velocity2d->x += endx;
-			gpAnimBlendClump->velocity2d->y += endy;
+			gpAnimBlendClump->velocity->x += endx;
+			gpAnimBlendClump->velocity->y += endy;
 		}
 		mat->pos.x = pos.x - transx;
 		mat->pos.y = pos.y - transy;
@ -222,9 +222,9 @@ FrameUpdateCallBackWith3dVelocityExtractionNonSkinned(AnimBlendFrameData *frame,
 	}

 	if((frame->flag & AnimBlendFrameData::IGNORE_TRANSLATION) == 0){
-		*gpAnimBlendClump->velocity3d = trans - cur;
+		*gpAnimBlendClump->velocity = trans - cur;
 		if(looped)
-			*gpAnimBlendClump->velocity3d += end;
+			*gpAnimBlendClump->velocity += end;
 		mat->pos.x = (pos - trans).x + frame->resetPos.x;
 		mat->pos.y = (pos - trans).y + frame->resetPos.y;
 		mat->pos.z = (pos - trans).z + frame->resetPos.z;
@ -244,7 +244,7 @@ FrameUpdateCallBackSkinned(AnimBlendFrameData *frame, void *arg)
 	AnimBlendFrameUpdateData *updateData = (AnimBlendFrameUpdateData*)arg;

 	if(frame->flag & AnimBlendFrameData::VELOCITY_EXTRACTION &&
-	   gpAnimBlendClump->velocity2d){
+	   gpAnimBlendClump->velocity){
 		if(frame->flag & AnimBlendFrameData::VELOCITY_EXTRACTION_3D)
 			FrameUpdateCallBackWith3dVelocityExtractionSkinned(frame, arg);
 		else
@ -354,11 +354,11 @@ FrameUpdateCallBackWithVelocityExtractionSkinned(AnimBlendFrameData *frame, void
 	}

 	if((frame->flag & AnimBlendFrameData::IGNORE_TRANSLATION) == 0){
-		gpAnimBlendClump->velocity2d->x = transx - curx;
-		gpAnimBlendClump->velocity2d->y = transy - cury;
+		gpAnimBlendClump->velocity->x = transx - curx;
+		gpAnimBlendClump->velocity->y = transy - cury;
 		if(looped){
-			gpAnimBlendClump->velocity2d->x += endx;
-			gpAnimBlendClump->velocity2d->y += endy;
+			gpAnimBlendClump->velocity->x += endx;
+			gpAnimBlendClump->velocity->y += endy;
 		}
 		xform->t.x = pos.x - transx;
 		xform->t.y = pos.y - transy;
@ -434,9 +434,9 @@ FrameUpdateCallBackWith3dVelocityExtractionSkinned(AnimBlendFrameData *frame, vo
 	}

 	if((frame->flag & AnimBlendFrameData::IGNORE_TRANSLATION) == 0){
-		*gpAnimBlendClump->velocity3d = trans - cur;
+		*gpAnimBlendClump->velocity = trans - cur;
 		if(looped)
-			*gpAnimBlendClump->velocity3d += end;
+			*gpAnimBlendClump->velocity += end;
 		xform->t.x = (pos - trans).x + frame->resetPos.x;
 		xform->t.y = (pos - trans).y + frame->resetPos.y;
 		xform->t.z = (pos - trans).z + frame->resetPos.z;
@ -446,7 +446,7 @@ FrameUpdateCallBackWith3dVelocityExtractionSkinned(AnimBlendFrameData *frame, vo
 void
 FrameUpdateCallBackOffscreen(AnimBlendFrameData *frame, void *arg)
 {
-	if(frame->flag & AnimBlendFrameData::VELOCITY_EXTRACTION && gpAnimBlendClump->velocity2d)
+	if(frame->flag & AnimBlendFrameData::VELOCITY_EXTRACTION && gpAnimBlendClump->velocity)
 		FrameUpdateCallBackWithVelocityExtractionSkinned(frame, arg);
 }

@ -466,7 +466,7 @@ FrameUpdateCallBackNonSkinnedCompressed(AnimBlendFrameData *frame, void *arg)
 	AnimBlendFrameUpdateData *updateData = (AnimBlendFrameUpdateData*)arg;

 	if(frame->flag & AnimBlendFrameData::VELOCITY_EXTRACTION &&
-	   gpAnimBlendClump->velocity2d){
+	   gpAnimBlendClump->velocity){
 		if(updateData->foobar)
 			for(node = updateData->nodes; *node; node++)
 				if((*node)->sequence && (*node)->association->IsPartial())
@ -511,9 +511,9 @@ FrameUpdateCallBackNonSkinnedCompressed(AnimBlendFrameData *frame, void *arg)
 		}

 		if((frame->flag & AnimBlendFrameData::IGNORE_TRANSLATION) == 0){
-			*gpAnimBlendClump->velocity3d = trans - cur;
+			*gpAnimBlendClump->velocity = trans - cur;
 			if(looped)
-				*gpAnimBlendClump->velocity3d += end;
+				*gpAnimBlendClump->velocity += end;
 			mat->pos.x = (pos - trans).x + frame->resetPos.x;
 			mat->pos.y = (pos - trans).y + frame->resetPos.y;
 			mat->pos.z = (pos - trans).z + frame->resetPos.z;
@ -573,7 +573,7 @@ FrameUpdateCallBackSkinnedCompressed(AnimBlendFrameData *frame, void *arg)
 	AnimBlendFrameUpdateData *updateData = (AnimBlendFrameUpdateData*)arg;

 	if(frame->flag & AnimBlendFrameData::VELOCITY_EXTRACTION &&
-	   gpAnimBlendClump->velocity2d){
+	   gpAnimBlendClump->velocity){
 		if(updateData->foobar)
 			for(node = updateData->nodes; *node; node++)
 				if((*node)->sequence && (*node)->association->IsPartial())
@ -620,9 +620,9 @@ FrameUpdateCallBackSkinnedCompressed(AnimBlendFrameData *frame, void *arg)
 		}

 		if((frame->flag & AnimBlendFrameData::IGNORE_TRANSLATION) == 0){
-			*gpAnimBlendClump->velocity3d = trans - cur;
+			*gpAnimBlendClump->velocity = trans - cur;
 			if(looped)
-				*gpAnimBlendClump->velocity3d += end;
+				*gpAnimBlendClump->velocity += end;
 			xform->t.x = (pos - trans).x + frame->resetPos.x;
 			xform->t.y = (pos - trans).y + frame->resetPos.y;
 			xform->t.z = (pos - trans).z + frame->resetPos.z;
--- a/src/animation/RpAnimBlend.cpp
+++ b/src/animation/RpAnimBlend.cpp
@ -437,7 +437,7 @@ RpAnimBlendNodeUpdateKeyframes(AnimBlendFrameData *frames, AnimBlendFrameUpdateD
 		CAnimBlendAssociation *a = (*node)->association;
 		for(i = 0; i < numNodes; i++)
 			if((frames[i].flag & AnimBlendFrameData::VELOCITY_EXTRACTION) == 0 ||
-			   gpAnimBlendClump->velocity2d == nil){
+			   gpAnimBlendClump->velocity == nil){
 				if((*node)[i].sequence)
 					(*node)[i].FindKeyFrame(a->currentTime - a->timeStep);
 			}
--- a/src/control/Replay.cpp
+++ b/src/control/Replay.cpp
@ -1729,7 +1729,7 @@ void CReplay::SaveReplayToHD(void)
 	CFileMgr::SetDir("");
 }

-void CReplay::PlayReplayFromHD(void)
+void PlayReplayFromHD(void)
 {
 	CFileMgr::SetDirMyDocuments();
 	int fr = CFileMgr::OpenFile("replay.rep", "rb");
@ -1748,17 +1748,17 @@ void CReplay::PlayReplayFromHD(void)
 		return;
 	}
 	int slot;
-	for (slot = 0; CFileMgr::Read(fr, (char*)Buffers[slot], sizeof(Buffers[slot])); slot++)
-		BufferStatus[slot] = REPLAYBUFFER_PLAYBACK;
-	BufferStatus[slot - 1] = REPLAYBUFFER_RECORD;
-	while (slot < NUM_REPLAYBUFFERS)
-		BufferStatus[slot++] = REPLAYBUFFER_UNUSED;
+	for (slot = 0; CFileMgr::Read(fr, (char*)CReplay::Buffers[slot], sizeof(CReplay::Buffers[slot])); slot++)
+		CReplay::BufferStatus[slot] = CReplay::REPLAYBUFFER_PLAYBACK;
+	CReplay::BufferStatus[slot - 1] = CReplay::REPLAYBUFFER_RECORD;
+	while (slot < CReplay::NUM_REPLAYBUFFERS)
+		CReplay::BufferStatus[slot++] = CReplay::REPLAYBUFFER_UNUSED;
 	CFileMgr::CloseFile(fr);
 	CFileMgr::SetDir("");
-	TriggerPlayback(REPLAYCAMMODE_ASSTORED, 0.0f, 0.0f, 0.0f, false);
-	bPlayingBackFromFile = true;
-	bAllowLookAroundCam = true;
-	StreamAllNecessaryCarsAndPeds();
+	CReplay::TriggerPlayback(CReplay::REPLAYCAMMODE_ASSTORED, 0.0f, 0.0f, 0.0f, false);
+	CReplay::bPlayingBackFromFile = true;
+	CReplay::bAllowLookAroundCam = true;
+	CReplay::StreamAllNecessaryCarsAndPeds();
 }

 void CReplay::StreamAllNecessaryCarsAndPeds(void)
--- a/src/control/Replay.h
+++ b/src/control/Replay.h
@ -64,6 +64,8 @@ struct CStoredDetailedAnimationState
 	uint8 aGroupId2[NUM_PARTIAL_ANIMS_IN_REPLAY];
 };

+void PlayReplayFromHD(void);
+
 #ifdef GTA_REPLAY
 #define REPLAY_STUB
 #else
@ -408,10 +410,12 @@ private:
 	static void EmptyAllPools(void);
 	static void MarkEverythingAsNew(void);
 	static void SaveReplayToHD(void);
-	static void PlayReplayFromHD(void); // out of class in III PC and later because of SecuROM
 	static void FindFirstFocusCoordinate(CVector *coord);
 	static void ProcessLookAroundCam(void);
 	static size_t FindSizeOfPacket(uint8);
 	static void GoToNextBlock(void);
+
+	/* Absolute nonsense, but how could this function end up being outside of class? */
+	friend void PlayReplayFromHD(void); 
 #endif
 };
--- a/src/control/Script4.cpp
+++ b/src/control/Script4.cpp
@ -785,20 +785,20 @@ int8 CRunningScript::ProcessCommands800To899(int32 command)
 			}else{
 				pPed->m_pMyVehicle->RemovePassenger(pPed);
 			}
-			if (pPed->m_vehDoor) {
+			if (pPed->m_vehEnterType) {
 				if (pPed->GetPedState() == PED_EXIT_CAR || pPed->GetPedState() == PED_DRAG_FROM_CAR) {
 					uint8 flags = 0;
 					if (pPed->m_pMyVehicle->IsBike()) {
-						if (pPed->m_vehDoor == CAR_DOOR_LF ||
-							pPed->m_vehDoor == CAR_DOOR_RF ||
-							pPed->m_vehDoor == CAR_WINDSCREEN)
+						if (pPed->m_vehEnterType == CAR_DOOR_LF ||
+							pPed->m_vehEnterType == CAR_DOOR_RF ||
+							pPed->m_vehEnterType == CAR_WINDSCREEN)
 							flags = CAR_DOOR_FLAG_LF | CAR_DOOR_FLAG_RF;
-						else if (pPed->m_vehDoor == CAR_DOOR_LR ||
-							pPed->m_vehDoor == CAR_DOOR_RR)
+						else if (pPed->m_vehEnterType == CAR_DOOR_LR ||
+							pPed->m_vehEnterType == CAR_DOOR_RR)
 							flags = CAR_DOOR_FLAG_LR | CAR_DOOR_FLAG_RR;
 					}
 					else {
-						switch (pPed->m_vehDoor) {
+						switch (pPed->m_vehEnterType) {
 						case CAR_DOOR_LF:
 							flags = pPed->m_pMyVehicle->m_nNumMaxPassengers != 0 ? CAR_DOOR_FLAG_LF : CAR_DOOR_FLAG_LF | CAR_DOOR_FLAG_LR;
 							break;
@ -814,7 +814,7 @@ int8 CRunningScript::ProcessCommands800To899(int32 command)
 						}
 					}
 					pPed->m_pMyVehicle->m_nGettingOutFlags &= ~flags;
-					pPed->m_pMyVehicle->ProcessOpenDoor(pPed->m_vehDoor, NUM_STD_ANIMS, 0.0f);
+					pPed->m_pMyVehicle->ProcessOpenDoor(pPed->m_vehEnterType, NUM_STD_ANIMS, 0.0f);
 				}
 			}
 		}
--- a/src/core/Camera.cpp
+++ b/src/core/Camera.cpp
@ -2353,7 +2353,7 @@ CCamera::StartTransition(int16 newMode)
 		while(deltaBeta < -PI) deltaBeta += 2*PI;
 		deltaBeta = Abs(deltaBeta);

-		door = FindPlayerPed()->m_vehDoor;
+		door = FindPlayerPed()->m_vehEnterType;
 		if(deltaBeta > HALFPI){
 			if(((CPed*)pTargetEntity)->m_carInObjective){
 				if(((CPed*)pTargetEntity)->m_carInObjective->IsUpsideDown()){
--- a/src/core/Game.cpp
+++ b/src/core/Game.cpp
@ -462,7 +462,7 @@ bool CGame::Initialise(const char* datFile)
 	TestModelIndices();

 	LoadingScreen("Loading the Game", "Setup water", nil);
-	CWaterLevel::Initialise("DATA\\WATER.DAT");
+	WaterLevelInitialise("DATA\\WATER.DAT");
 	TheConsole.Init();
 	CDraw::SetFOV(120.0f);
 	CDraw::ms_fLODDistance = 500.0f;
--- a/src/core/PlayerInfo.cpp
+++ b/src/core/PlayerInfo.cpp
@ -390,8 +390,8 @@ CPlayerInfo::Process(void)
 						m_pPed->SetObjective(OBJECTIVE_ENTER_CAR_AS_PASSENGER, carBelow);
 					} else if (carBelow->IsBoat()) {
 						if (!carBelow->pDriver) {
-							m_pPed->m_vehDoor = 0;
-							m_pPed->SetEnterCar(carBelow, m_pPed->m_vehDoor);
+							m_pPed->m_vehEnterType = 0;
+							m_pPed->SetEnterCar(carBelow, m_pPed->m_vehEnterType);
 						}
 					} else {
 						m_pPed->SetObjective(OBJECTIVE_ENTER_CAR_AS_DRIVER, carBelow);
--- a/src/core/config.h
+++ b/src/core/config.h
@ -240,16 +240,12 @@ enum Config {
 #	define TIMEBARS		// print debug timers
 #endif

-#define FIX_BUGS		// fixes bugs that we've came across during reversing. You can undefine this only on release builds.
+#define FIX_BUGS		// fixes bugs that we've came across during reversing, TODO: use this more
 //#define MORE_LANGUAGES		// Add more translations to the game
 #define COMPATIBLE_SAVES // this allows changing structs while keeping saves compatible
 #define LOAD_INI_SETTINGS // as the name suggests. fundamental for CUSTOM_FRONTEND_OPTIONS
 #define FIX_HIGH_FPS_BUGS_ON_FRONTEND

-#if defined(__LP64__) || defined(_WIN64)
-#define FIX_BUGS_64 // Must have fixes to be able to run 64 bit build
-#endif
-
 // Just debug menu entries
 #ifdef DEBUGMENU
 #define RELOADABLES			// some debug menu options to reload TXD files
--- a/src/core/main.cpp
+++ b/src/core/main.cpp
@ -1426,13 +1426,11 @@ Idle(void *arg)
 	CSprite2d::InitPerFrame();
 	CFont::InitPerFrame();

-	PUSH_MEMID(MEMID_GAME_PROCESS);
 	CPointLights::InitPerFrame();

 	tbStartTimer(0, "CGame::Process");
 	CGame::Process();
 	tbEndTimer("CGame::Process");
-	POP_MEMID();

 	tbStartTimer(0, "DMAudio.Service");
 	DMAudio.Service();
@ -1454,8 +1452,6 @@ Idle(void *arg)
 	if(arg == nil)
 		return;

-	PUSH_MEMID(MEMID_RENDER);
-
 	if(!FrontEndMenuManager.m_bMenuActive && TheCamera.GetScreenFadeStatus() != FADE_2)
 	{
 		// This is from SA, but it's nice for windowed mode
--- a/src/entities/Physical.cpp
+++ b/src/entities/Physical.cpp
@ -883,13 +883,9 @@ CPhysical::ApplyCollision(CPhysical *B, CColPoint &colpoint, float &impulseA, fl
 				if(B->GetStatus() == STATUS_PLAYER)
 					pointposB *= 0.8f;
 				if(CWorld::bNoMoreCollisionTorque){
-#ifdef FIX_BUGS
+					// BUG: the game actually uses A here, but this can't be right
 					B->ApplyFrictionMoveForce(fB*-0.3f);
 					B->ApplyFrictionTurnForce(fB*-0.3f, pointposB);
-#else
-					A->ApplyFrictionMoveForce(fB*-0.3f);
-					A->ApplyFrictionTurnForce(fB*-0.3f, pointposB);
-#endif
 				}
 			}
 			if(!A->bInfiniteMass){
@ -1058,13 +1054,7 @@ CPhysical::ApplyFriction(CPhysical *B, float adhesiveLimit, CColPoint &colpoint)
 		fOtherSpeedA = vOtherSpeedA.Magnitude();
 		fOtherSpeedB = vOtherSpeedB.Magnitude();

-#ifdef FIX_BUGS // division by 0
-		frictionDir = vOtherSpeedA;
-		frictionDir.Normalise();
-#else
 		frictionDir = vOtherSpeedA * (1.0f/fOtherSpeedA);
-#endif
-
 		speedSum = (B->m_fMass*fOtherSpeedB + A->m_fMass*fOtherSpeedA)/(B->m_fMass + A->m_fMass);
 		if(fOtherSpeedA > speedSum){
 			impulseA = (speedSum - fOtherSpeedA) * A->m_fMass;
@ -1094,12 +1084,7 @@ CPhysical::ApplyFriction(CPhysical *B, float adhesiveLimit, CColPoint &colpoint)
 		fOtherSpeedA = vOtherSpeedA.Magnitude();
 		fOtherSpeedB = vOtherSpeedB.Magnitude();

-#ifdef FIX_BUGS // division by 0
-		frictionDir = vOtherSpeedA;
-		frictionDir.Normalise();
-#else
 		frictionDir = vOtherSpeedA * (1.0f/fOtherSpeedA);
-#endif
 		float massB = B->GetMass(pointposB, frictionDir);
 		speedSum = (massB*fOtherSpeedB + A->m_fMass*fOtherSpeedA)/(massB + A->m_fMass);
 		if(fOtherSpeedA > speedSum){
@ -1127,12 +1112,7 @@ CPhysical::ApplyFriction(CPhysical *B, float adhesiveLimit, CColPoint &colpoint)
 		fOtherSpeedA = vOtherSpeedA.Magnitude();
 		fOtherSpeedB = vOtherSpeedB.Magnitude();

-#ifdef FIX_BUGS // division by 0
-		frictionDir = vOtherSpeedA;
-		frictionDir.Normalise();
-#else
 		frictionDir = vOtherSpeedA * (1.0f/fOtherSpeedA);
-#endif
 		float massA = A->GetMass(pointposA, frictionDir);
 		speedSum = (B->m_fMass*fOtherSpeedB + massA*fOtherSpeedA)/(B->m_fMass + massA);
 		if(fOtherSpeedA > speedSum){
@ -1160,12 +1140,7 @@ CPhysical::ApplyFriction(CPhysical *B, float adhesiveLimit, CColPoint &colpoint)
 		fOtherSpeedA = vOtherSpeedA.Magnitude();
 		fOtherSpeedB = vOtherSpeedB.Magnitude();

-#ifdef FIX_BUGS // division by 0
-		frictionDir = vOtherSpeedA;
-		frictionDir.Normalise();
-#else
 		frictionDir = vOtherSpeedA * (1.0f/fOtherSpeedA);
-#endif
 		float massA = A->GetMass(pointposA, frictionDir);
 		float massB = B->GetMass(pointposB, frictionDir);
 		speedSum = (massB*fOtherSpeedB + massA*fOtherSpeedA)/(massB + massA);
@ -1203,12 +1178,7 @@ CPhysical::ApplyFriction(float adhesiveLimit, CColPoint &colpoint)

 		fOtherSpeed = vOtherSpeed.Magnitude();
 		if(fOtherSpeed > 0.0f){
-#ifdef FIX_BUGS // division by 0
-			frictionDir = vOtherSpeed;
-			frictionDir.Normalise();
-#else
 			frictionDir = vOtherSpeed * (1.0f/fOtherSpeed);
-#endif
 			// not really impulse but speed
 			// maybe use ApplyFrictionMoveForce instead?
 			fImpulse = -fOtherSpeed;
@ -1226,12 +1196,7 @@ CPhysical::ApplyFriction(float adhesiveLimit, CColPoint &colpoint)

 		fOtherSpeed = vOtherSpeed.Magnitude();
 		if(fOtherSpeed > 0.0f){
-#ifdef FIX_BUGS // division by 0
-			frictionDir = vOtherSpeed;
-			frictionDir.Normalise();
-#else
 			frictionDir = vOtherSpeed * (1.0f/fOtherSpeed);
-#endif
 			fImpulse = -fOtherSpeed * m_fMass;
 			impulseLimit = adhesiveLimit*CTimer::GetTimeStep() * 1.5;
 			if(fImpulse < -impulseLimit) fImpulse = -impulseLimit;
--- a/src/objects/CutsceneObject.cpp
+++ b/src/objects/CutsceneObject.cpp
@ -46,7 +46,7 @@ CCutsceneObject::SetModelIndex(uint32 id)
 	CEntity::SetModelIndex(id);
 	assert(RwObjectGetType(m_rwObject) == rpCLUMP);
 	RpAnimBlendClumpInit((RpClump*)m_rwObject);
-	(*RPANIMBLENDCLUMPDATA(m_rwObject))->velocity3d = &m_vecMoveSpeed;
+	(*RPANIMBLENDCLUMPDATA(m_rwObject))->velocity = &m_vecMoveSpeed;
 	(*RPANIMBLENDCLUMPDATA(m_rwObject))->frames[0].flag |= AnimBlendFrameData::VELOCITY_EXTRACTION_3D;
 }

--- a/src/peds/Ped.cpp
+++ b/src/peds/Ped.cpp
@ -113,15 +113,15 @@ CPed::CPed(uint32 pedType) : m_pedIK(this)
 	m_attackTimer = 0;
 	m_timerUnused = 0;
 	m_lookTimer = 0;
-	m_chatTimer = 0;
+	m_standardTimer = 0;
 	m_shootTimer = 0;
-	m_carJackTimer = 0;
+	m_hitRecoverTimer = 0;
 	m_duckAndCoverTimer = 0;
 	m_moved = CVector2D(0.0f, 0.0f);
 	m_fRotationCur = 0.0f;
 	m_headingRate = 15.0f;
 	m_fRotationDest = 0.0f;
-	m_vehDoor = CAR_DOOR_LF;
+	m_vehEnterType = CAR_DOOR_LF;
 	m_walkAroundType = 0;
 	m_pCurrentPhysSurface = nil;
 	m_vecOffsetFromPhysSurface = CVector(0.0f, 0.0f, 0.0f);
@ -381,7 +381,7 @@ CPed::~CPed(void)
 		GetPedAttractorManager()->DeRegisterPed(this, m_attractor);
 	CRadar::ClearBlipForEntity(BLIP_CHAR, CPools::GetPedPool()->GetIndex(this));
 	if (InVehicle()){
-		uint8 door_flag = GetCarDoorFlag(m_vehDoor);
+		uint8 door_flag = GetCarDoorFlag(m_vehEnterType);
 		if (m_pMyVehicle->pDriver == this)
 			m_pMyVehicle->pDriver = nil;
 		else {
@ -434,7 +434,8 @@ CPed::SetModelIndex(uint32 mi)
 	if (!CanUseTorsoWhenLooking())
 		m_pedIK.m_flags |= CPedIK::LOOKAROUND_HEAD_ONLY;

-	(*RPANIMBLENDCLUMPDATA(m_rwObject))->velocity2d = &m_vecAnimMoveDelta;
+	// This is a mistake by R*, velocity is CVector, whereas m_vecAnimMoveDelta is CVector2D. 
+	(*RPANIMBLENDCLUMPDATA(m_rwObject))->velocity = (CVector*) &m_vecAnimMoveDelta;

 	if(modelInfo->GetHitColModel() == nil)
 		modelInfo->CreateHitColModelSkinned(GetClump());
@ -1298,8 +1299,7 @@ CPed::ScanForInterestingStuff(void)
 	if (LookForInterestingNodes())
 		return;

-	if (m_nPedType == PEDTYPE_CRIMINAL && m_carJackTimer < CTimer::GetTimeInMilliseconds()) {
-		// Find a car to steal or a ped to mug if we haven't already decided to steal a car
+	if (m_nPedType == PEDTYPE_CRIMINAL && m_hitRecoverTimer < CTimer::GetTimeInMilliseconds()) {
 		if (CGeneral::GetRandomNumber() % 100 < 10) {
 			int mostExpensiveVehAround = -1;
 			int bestMonetaryValue = 0;
@ -1322,10 +1322,10 @@ CPed::ScanForInterestingStuff(void)
 			}
 			if (bestMonetaryValue > 2000 && mostExpensiveVehAround != -1 && vehicles[mostExpensiveVehAround]) {
 				SetObjective(OBJECTIVE_ENTER_CAR_AS_DRIVER, vehicles[mostExpensiveVehAround]);
-				m_carJackTimer = CTimer::GetTimeInMilliseconds() + 5000;
+				m_hitRecoverTimer = CTimer::GetTimeInMilliseconds() + 5000;
 				return;
 			}
-			m_carJackTimer = CTimer::GetTimeInMilliseconds() + 5000;
+			m_hitRecoverTimer = CTimer::GetTimeInMilliseconds() + 5000;
 		} else if (m_objective != OBJECTIVE_MUG_CHAR && !(CGeneral::GetRandomNumber() & 7)) {
 			CPed *charToMug = nil;
 			for (int i = 0; i < m_numNearPeds; ++i) {
@ -1347,13 +1347,13 @@ CPed::ScanForInterestingStuff(void)
 			if (charToMug)
 				SetObjective(OBJECTIVE_MUG_CHAR, charToMug);

-			m_carJackTimer = CTimer::GetTimeInMilliseconds() + 5000;
+			m_hitRecoverTimer = CTimer::GetTimeInMilliseconds() + 5000;
 		}
 	}

 	if (m_nPedState == PED_WANDER_PATH) {
 		if (CGeneral::GetRandomNumberInRange(0.0f, 1.0f) < 0.5f) {
-			if (CTimer::GetTimeInMilliseconds() > m_chatTimer) {
+			if (CTimer::GetTimeInMilliseconds() > m_standardTimer) {
 				for (int i = 0; i < m_numNearPeds; i ++) {
 					if (m_nearPeds[i] && m_nearPeds[i]->m_nPedState == PED_WANDER_PATH) {
 						if ((GetPosition() - m_nearPeds[i]->GetPosition()).Magnitude() < 1.8f
@ -1369,7 +1369,7 @@ CPed::ScanForInterestingStuff(void)
 				}
 			}
 		} else {
-			m_chatTimer = CTimer::GetTimeInMilliseconds() + 200;
+			m_standardTimer = CTimer::GetTimeInMilliseconds() + 200;
 		}
 	}
 }
@ -3656,7 +3656,7 @@ CPed::SetDirectionToWalkAroundObject(CEntity *obj)
 			if (Abs(angleDiffBtwObjCenterAndForward) >= objTopRightHeading) {
 				if (PI - objTopRightHeading >= Abs(angleDiffBtwObjCenterAndForward)) {
 					if ((angleDiffBtwObjCenterAndForward <= 0.0f || objUpsideDown) && (angleDiffBtwObjCenterAndForward < 0.0f || !objUpsideDown)) {
-						if (goingToEnterCar && (m_vehDoor == CAR_DOOR_RF || m_vehDoor == CAR_DOOR_RR)) {
+						if (goingToEnterCar && (m_vehEnterType == CAR_DOOR_RF || m_vehEnterType == CAR_DOOR_RR)) {
 							m_walkAroundType = 0;
 						} else {
 							if (CGeneral::LimitRadianAngle(m_fRotationDest - angleToFaceObjCenter) >= 0.0f) {
@ -3674,7 +3674,7 @@ CPed::SetDirectionToWalkAroundObject(CEntity *obj)
 							}
 						}
 					} else {
-						if (goingToEnterCar && (m_vehDoor == CAR_DOOR_LF || m_vehDoor == CAR_DOOR_LR)) {
+						if (goingToEnterCar && (m_vehEnterType == CAR_DOOR_LF || m_vehEnterType == CAR_DOOR_LR)) {
 							m_walkAroundType = 0;
 						} else {
 							if (CGeneral::LimitRadianAngle(m_fRotationDest - angleToFaceObjCenter) <= 0.0f) {
@ -3692,7 +3692,7 @@ CPed::SetDirectionToWalkAroundObject(CEntity *obj)
 							}
 						}
 					}
-				} else if (goingToEnterCar && (m_vehDoor == CAR_DOOR_LF || m_vehDoor == CAR_DOOR_LR)
+				} else if (goingToEnterCar && (m_vehEnterType == CAR_DOOR_LF || m_vehEnterType == CAR_DOOR_LR)
 					|| CGeneral::LimitRadianAngle(m_fRotationDest - angleToFaceObjCenter) < 0.0f) {
 					if (entityOnTopLeftOfObj == 1 || entityOnTopLeftOfObj && !entityOnTopRightOfObj && !entityOnBottomRightOfObj) {
 						m_walkAroundType = 3;
@ -3700,7 +3700,7 @@ CPed::SetDirectionToWalkAroundObject(CEntity *obj)
 				} else if (entityOnTopRightOfObj == 1 || entityOnTopRightOfObj && !entityOnTopLeftOfObj && !entityOnBottomLeftOfObj) {
 					m_walkAroundType = 4;
 				}
-			} else if (goingToEnterCar && (m_vehDoor == CAR_DOOR_LF || m_vehDoor == CAR_DOOR_LR)
+			} else if (goingToEnterCar && (m_vehEnterType == CAR_DOOR_LF || m_vehEnterType == CAR_DOOR_LR)
 				|| CGeneral::LimitRadianAngle(m_fRotationDest - angleToFaceObjCenter) > 0.0f) {
 				if (entityOnBottomLeftOfObj == 1 || entityOnBottomLeftOfObj && !entityOnTopRightOfObj && !entityOnBottomRightOfObj) {
 					m_walkAroundType = 2;
@ -3723,10 +3723,10 @@ CPed::SetDirectionToWalkAroundObject(CEntity *obj)
 	if (Abs(angleDiffBtwObjCenterAndForward) < objTopRightHeading) {
 		if (goingToEnterCar) {
 			if (goingToEnterCarAndItsVan) {
-				if (m_vehDoor == CAR_DOOR_LR || m_vehDoor == CAR_DOOR_RR)
+				if (m_vehEnterType == CAR_DOOR_LR || m_vehEnterType == CAR_DOOR_RR)
 					return;
 			}
-			if (m_vehDoor != CAR_DOOR_LF && m_vehDoor != CAR_DOOR_LR && (!entityOnBottomRightOfObj || entityOnBottomLeftOfObj)) {
+			if (m_vehEnterType != CAR_DOOR_LF && m_vehEnterType != CAR_DOOR_LR && (!entityOnBottomRightOfObj || entityOnBottomLeftOfObj)) {
 				m_fRotationDest = CGeneral::LimitRadianAngle(dirToSet - HALFPI);
 				localPosToHead.x = adjustedColMax.x;
 				localPosToHead.z = 0.0f;
@ -3755,9 +3755,9 @@ CPed::SetDirectionToWalkAroundObject(CEntity *obj)
 	} else {
 		if (PI - objTopRightHeading >= Abs(angleDiffBtwObjCenterAndForward)) {
 			if (angleDiffBtwObjCenterAndForward <= 0.0f) {
-				if (!goingToEnterCar || !goingToEnterCarAndItsVan || m_vehDoor != CAR_DOOR_LR && m_vehDoor != CAR_DOOR_RR) {
+				if (!goingToEnterCar || !goingToEnterCarAndItsVan || m_vehEnterType != CAR_DOOR_LR && m_vehEnterType != CAR_DOOR_RR) {
 					if (goingToEnterCar) {
-						if (m_vehDoor == CAR_DOOR_RF || (m_vehDoor == CAR_DOOR_RR && !goingToEnterCarAndItsVan))
+						if (m_vehEnterType == CAR_DOOR_RF || (m_vehEnterType == CAR_DOOR_RR && !goingToEnterCarAndItsVan))
 							return;
 					}
 					if (m_walkAroundType == 4 || m_walkAroundType == 3
@ -3779,14 +3779,14 @@ CPed::SetDirectionToWalkAroundObject(CEntity *obj)
 					localPosToHead.z = 0.0f;
 					localPosToHead.y = adjustedColMin.y;
 				}
-			} else if (goingToEnterCar && goingToEnterCarAndItsVan && (m_vehDoor == CAR_DOOR_LR || m_vehDoor == CAR_DOOR_RR)) {
+			} else if (goingToEnterCar && goingToEnterCarAndItsVan && (m_vehEnterType == CAR_DOOR_LR || m_vehEnterType == CAR_DOOR_RR)) {
 				m_fRotationDest = CGeneral::LimitRadianAngle(PI + dirToSet);
 				localPosToHead.x = adjustedColMin.x;
 				localPosToHead.z = 0.0f;
 				localPosToHead.y = adjustedColMin.y;
 			} else {
 				if (goingToEnterCar) {
-					if (m_vehDoor == CAR_DOOR_LF || m_vehDoor == CAR_DOOR_LR && !goingToEnterCarAndItsVan)
+					if (m_vehEnterType == CAR_DOOR_LF || m_vehEnterType == CAR_DOOR_LR && !goingToEnterCarAndItsVan)
 						return;
 				}
 				if (m_walkAroundType == 1 || m_walkAroundType == 2
@ -3804,8 +3804,8 @@ CPed::SetDirectionToWalkAroundObject(CEntity *obj)
 				}
 			}
 		} else {
-			if (goingToEnterCar && (!goingToEnterCarAndItsVan || m_vehDoor != CAR_DOOR_LR && m_vehDoor != CAR_DOOR_RR)) {
-				if (m_vehDoor != CAR_DOOR_LF && m_vehDoor != CAR_DOOR_LR && (!entityOnTopRightOfObj || entityOnTopLeftOfObj)) {
+			if (goingToEnterCar && (!goingToEnterCarAndItsVan || m_vehEnterType != CAR_DOOR_LR && m_vehEnterType != CAR_DOOR_RR)) {
+				if (m_vehEnterType != CAR_DOOR_LF && m_vehEnterType != CAR_DOOR_LR && (!entityOnTopRightOfObj || entityOnTopLeftOfObj)) {

 					m_fRotationDest = CGeneral::LimitRadianAngle(dirToSet - HALFPI);
 					localPosToHead.x = adjustedColMax.x;
@ -4099,9 +4099,9 @@ CPed::PedSetOutCarCB(CAnimBlendAssociation *animAssoc, void *arg)
 		}
 		if (veh && veh->IsBike())
 			// BUG? 
-			veh->m_nGettingOutFlags &= ~GetBikeDoorFlag(ped->m_vehDoor);
+			veh->m_nGettingOutFlags &= ~GetBikeDoorFlag(ped->m_vehEnterType);
 		else
-			veh->m_nGettingOutFlags &= ~GetCarDoorFlag(ped->m_vehDoor);
+			veh->m_nGettingOutFlags &= ~GetCarDoorFlag(ped->m_vehEnterType);

 		if (veh->pDriver == ped) {
 			veh->RemoveDriver();
@ -4123,7 +4123,7 @@ CPed::PedSetOutCarCB(CAnimBlendAssociation *animAssoc, void *arg)

 		if (veh->bIsBus && !veh->IsUpsideDown() && !veh->IsOnItsSide()) {
 			float angleAfterExit;
-			if (ped->m_vehDoor == CAR_DOOR_LF) {
+			if (ped->m_vehEnterType == CAR_DOOR_LF) {
 				angleAfterExit = HALFPI + veh->GetForward().Heading();
 			} else {
 				angleAfterExit = veh->GetForward().Heading() - HALFPI;
@ -4174,7 +4174,7 @@ CPed::PedSetDraggedOutCarCB(CAnimBlendAssociation *dragAssoc, void *arg)
 	uint8 exitFlags = 0;
 	quickJackedAssoc = RpAnimBlendClumpGetAssociation(ped->GetClump(), ANIM_CAR_QJACKED);
 	if (dragAssoc && dragAssoc->animId == ANIM_BIKE_HIT && ped->m_pMyVehicle) {
-		if (ped->m_vehDoor == CAR_DOOR_LF || ped->m_vehDoor == CAR_DOOR_RF) {
+		if (ped->m_vehEnterType == CAR_DOOR_LF || ped->m_vehEnterType == CAR_DOOR_RF) {
 			CAnimManager::BlendAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_BIKE_FALL_OFF, 100.0f);
 			ped->m_pMyVehicle->m_nGettingOutFlags &= ~(CAR_DOOR_FLAG_RF | CAR_DOOR_FLAG_LF);
 		} else {
@ -4196,9 +4196,9 @@ CPed::PedSetDraggedOutCarCB(CAnimBlendAssociation *dragAssoc, void *arg)
 	vehicle = ped->m_pMyVehicle;

 	if (vehicle && vehicle->IsBike())
-		exitFlags = GetBikeDoorFlagInclJumpInFromFront(ped->m_vehDoor);
+		exitFlags = GetBikeDoorFlagInclJumpInFromFront(ped->m_vehEnterType);
 	else
-		exitFlags = GetCarDoorFlag(ped->m_vehDoor);
+		exitFlags = GetCarDoorFlag(ped->m_vehEnterType);

 	if (vehicle)
 		vehicle->m_nGettingOutFlags &= ~exitFlags;
@ -4419,7 +4419,7 @@ CPed::PedSetInCarCB(CAnimBlendAssociation *animAssoc, void *arg)
 		} else if (veh->bIsBus) {
 			veh->AddPassenger(ped);
 		} else {
-			switch (ped->m_vehDoor) {
+			switch (ped->m_vehEnterType) {
 				case CAR_DOOR_RF:
 					veh->AddPassenger(ped, 0);
 					break;
@ -4449,9 +4449,9 @@ CPed::PedSetInCarCB(CAnimBlendAssociation *animAssoc, void *arg)

 	int8 doorFlag;
 	if (veh->IsBike()) {
-		doorFlag = GetBikeDoorFlagInclJumpInFromFront(ped->m_vehDoor);
+		doorFlag = GetBikeDoorFlagInclJumpInFromFront(ped->m_vehEnterType);
 	} else {
-		doorFlag = GetEnterCarDoorFlag(ped->m_vehDoor, veh->m_nNumMaxPassengers);
+		doorFlag = GetEnterCarDoorFlag(ped->m_vehEnterType, veh->m_nNumMaxPassengers);
 	}

 	veh->m_nGettingInFlags &= ~doorFlag;
@ -5133,13 +5133,13 @@ void
 CPed::Idle(void)
 {
 	CVehicle *veh = m_pMyVehicle;
-	if (veh && veh->m_nGettingOutFlags && m_vehDoor) {
+	if (veh && veh->m_nGettingOutFlags && m_vehEnterType) {

-		if (veh->m_nGettingOutFlags & GetCarDoorFlag(m_vehDoor)) {
+		if (veh->m_nGettingOutFlags & GetCarDoorFlag(m_vehEnterType)) {

 			if (m_objective != OBJECTIVE_KILL_CHAR_ON_FOOT) {

-				CVector doorPos = GetPositionToOpenCarDoor(veh, m_vehDoor);
+				CVector doorPos = GetPositionToOpenCarDoor(veh, m_vehEnterType);
 				CVector doorDist = GetPosition() - doorPos;

 				if (doorDist.MagnitudeSqr() < sq(0.5f)) {
@ -5886,7 +5886,7 @@ CPed::ClearFlee(void)
 {
 	RestorePreviousState();
 	bUsePedNodeSeek = false;
-	m_chatTimer = 0;
+	m_standardTimer = 0;
 	m_fleeTimer = 0;
 }

@ -5932,7 +5932,7 @@ CPed::Flee(void)
 		if (m_nPedStateTimer < CTimer::GetTimeInMilliseconds()
 			&& m_collidingThingTimer < CTimer::GetTimeInMilliseconds()) {

-			if (m_pNextPathNode && CTimer::GetTimeInMilliseconds() > m_chatTimer)  {
+			if (m_pNextPathNode && CTimer::GetTimeInMilliseconds() > m_standardTimer)  {

 				curDirectionShouldBe = CGeneral::GetNodeHeadingFromVector(GetPosition().x - ms_vec2DFleePosition.x, GetPosition().y - ms_vec2DFleePosition.y);
 				if (m_nPathDir < curDirectionShouldBe)
@ -5975,7 +5975,7 @@ CPed::Flee(void)
 			
 			if (m_pNextPathNode && m_pNextPathNode != realLastNode && m_pNextPathNode != m_pLastPathNode && curDirectionShouldBe - nextDirection != 4) {
 				m_nPathDir = nextDirection;
-				m_chatTimer = CTimer::GetTimeInMilliseconds() + 2000;
+				m_standardTimer = CTimer::GetTimeInMilliseconds() + 2000;
 			} else {
 				bUsePedNodeSeek = false;
 				SetMoveState(PEDMOVE_RUN);
@ -7215,7 +7215,7 @@ CPed::SetChat(CEntity *chatWith, uint32 time)
 	SetMoveState(PEDMOVE_STILL);
 	m_lookTimer = 0;
 	SetLookFlag(chatWith, true);
-	m_chatTimer = CTimer::GetTimeInMilliseconds() + time;
+	m_standardTimer = CTimer::GetTimeInMilliseconds() + time;
 	m_lookTimer = CTimer::GetTimeInMilliseconds() + 3000;
 }

@ -7236,7 +7236,7 @@ CPed::Chat(void)

 	if (partner->m_nPedState != PED_CHAT) {
 		ClearChat();
-		m_chatTimer = CTimer::GetTimeInMilliseconds() + 30000;
+		m_standardTimer = CTimer::GetTimeInMilliseconds() + 30000;
 		if (partner->m_pedInObjective) {
 			if (partner->m_objective == OBJECTIVE_KILL_CHAR_ON_FOOT ||
 				partner->m_objective == OBJECTIVE_FLEE_CHAR_ON_FOOT_TILL_SAFE)
@ -7269,9 +7269,9 @@ CPed::Chat(void)
 			Say(SOUND_PED_CHAT);
 		}
 	}
-	if (m_chatTimer && CTimer::GetTimeInMilliseconds() > m_chatTimer) {
+	if (m_standardTimer && CTimer::GetTimeInMilliseconds() > m_standardTimer) {
 		ClearChat();
-		m_chatTimer = CTimer::GetTimeInMilliseconds() + 30000;
+		m_standardTimer = CTimer::GetTimeInMilliseconds() + 30000;
 	}
 }

@ -7480,7 +7480,7 @@ CPed::SetSeekCar(CVehicle *car, uint32 doorNode)
 	m_pMyVehicle = car;
 	m_pMyVehicle->RegisterReference((CEntity**) &m_pMyVehicle);
 	// m_pSeekTarget->RegisterReference((CEntity**) &m_pSeekTarget);
-	m_vehDoor = doorNode;
+	m_vehEnterType = doorNode;
 	m_distanceToCountSeekDone = 0.5f;
 	SetPedState(PED_SEEK_CAR);

@ -7498,9 +7498,9 @@ CPed::SeekCar(void)
 	}

 	if (m_objective != OBJECTIVE_ENTER_CAR_AS_PASSENGER) {
-		if (!vehToSeek->IsBike() && m_vehDoor && m_objective != OBJECTIVE_ENTER_CAR_AS_DRIVER) {
+		if (!vehToSeek->IsBike() && m_vehEnterType && m_objective != OBJECTIVE_ENTER_CAR_AS_DRIVER) {
 			if (IsRoomToBeCarJacked()) {
-				dest = GetPositionToOpenCarDoor(vehToSeek, m_vehDoor);
+				dest = GetPositionToOpenCarDoor(vehToSeek, m_vehEnterType);
 			} else if (m_nPedType == PEDTYPE_COP) {
 				dest = GetPositionToOpenCarDoor(vehToSeek, CAR_DOOR_RF);
 			} else {
@ -7509,7 +7509,7 @@ CPed::SeekCar(void)
 		} else
 			GetNearestDoor(vehToSeek, dest);
 	} else {
-		if (m_carJackTimer > CTimer::GetTimeInMilliseconds()) {
+		if (m_hitRecoverTimer > CTimer::GetTimeInMilliseconds()) {
 			SetMoveState(PEDMOVE_STILL);
 			return;
 		}
@ -7553,7 +7553,7 @@ CPed::SeekCar(void)
 			if (IsPlayer()) {
 				ClearObjective();
 			} else if (CharCreatedBy == RANDOM_CHAR) {
-				m_carJackTimer = CTimer::GetTimeInMilliseconds() + 30000;
+				m_hitRecoverTimer = CTimer::GetTimeInMilliseconds() + 30000;
 			}
 			SetMoveState(PEDMOVE_STILL);
 			TheCamera.ClearPlayerWeaponMode();
@ -7581,7 +7581,7 @@ CPed::SeekCar(void)
 	else if (2.0f * vehToSeek->GetColModel()->boundingBox.max.x > distToDestSqr)
 		bCanPedEnterSeekedCar = true;

-	if (vehToSeek->m_nGettingInFlags & GetCarDoorFlag(m_vehDoor))
+	if (vehToSeek->m_nGettingInFlags & GetCarDoorFlag(m_vehEnterType))
 		bVehEnterDoorIsBlocked = true;
 	else
 		bVehEnterDoorIsBlocked = false;
@ -7592,7 +7592,7 @@ CPed::SeekCar(void)
 			if (1.6f + GetPosition().z > dest.z && GetPosition().z - 0.5f < dest.z) {
 #ifdef GTA_TRAIN
 				if (vehToSeek->IsTrain()) {
-					SetEnterTrain(vehToSeek, m_vehDoor);
+					SetEnterTrain(vehToSeek, m_vehEnterType);
 				} else
 #endif
 				{
@ -7613,42 +7613,42 @@ CPed::SeekCar(void)
 								case STATUS_PLAYER_DISABLED:
 									if (vehToSeek->IsBike()) {
 										if ((!m_leader || m_leader != vehToSeek->pDriver) &&
-											((m_vehDoor == CAR_DOOR_LF || m_vehDoor == CAR_DOOR_RF || m_vehDoor == CAR_WINDSCREEN) && vehToSeek->pDriver ||
-											(m_vehDoor == CAR_DOOR_LR || m_vehDoor == CAR_DOOR_RR) && vehToSeek->pPassengers[0])) {
+											((m_vehEnterType == CAR_DOOR_LF || m_vehEnterType == CAR_DOOR_RF || m_vehEnterType == CAR_WINDSCREEN) && vehToSeek->pDriver ||
+											(m_vehEnterType == CAR_DOOR_LR || m_vehEnterType == CAR_DOOR_RR) && vehToSeek->pPassengers[0])) {
 											SetCarJack(vehToSeek);
 										} else {
-											SetEnterCar(vehToSeek, m_vehDoor);
+											SetEnterCar(vehToSeek, m_vehEnterType);
 										}
 									} else if (!vehToSeek->bIsBus && (!m_leader || m_leader != vehToSeek->pDriver) &&
-										(m_vehDoor == CAR_DOOR_LF && vehToSeek->pDriver || m_vehDoor == CAR_DOOR_RF && vehToSeek->pPassengers[0] || m_vehDoor == CAR_DOOR_LR && vehToSeek->pPassengers[1] || m_vehDoor == CAR_DOOR_RR && vehToSeek->pPassengers[2])) {
+										(m_vehEnterType == CAR_DOOR_LF && vehToSeek->pDriver || m_vehEnterType == CAR_DOOR_RF && vehToSeek->pPassengers[0] || m_vehEnterType == CAR_DOOR_LR && vehToSeek->pPassengers[1] || m_vehEnterType == CAR_DOOR_RR && vehToSeek->pPassengers[2])) {
 										SetCarJack(vehToSeek);
-										if (m_objective == OBJECTIVE_ENTER_CAR_AS_DRIVER && m_vehDoor != CAR_DOOR_LF)
+										if (m_objective == OBJECTIVE_ENTER_CAR_AS_DRIVER && m_vehEnterType != CAR_DOOR_LF)
 											vehToSeek->pDriver->bFleeAfterExitingCar = true;
 									} else {
-										SetEnterCar(vehToSeek, m_vehDoor);
+										SetEnterCar(vehToSeek, m_vehEnterType);
 									}
 									break;
 								case STATUS_ABANDONED:
 									if (vehToSeek->IsBike()) {
-										if ((m_vehDoor == CAR_DOOR_LR || m_vehDoor == CAR_DOOR_RR) && vehToSeek->pPassengers[0]) {
+										if ((m_vehEnterType == CAR_DOOR_LR || m_vehEnterType == CAR_DOOR_RR) && vehToSeek->pPassengers[0]) {
 											if (vehToSeek->pPassengers[0]->bDontDragMeOutCar) {
 												if (IsPlayer())
-													SetEnterCar(vehToSeek, m_vehDoor);
+													SetEnterCar(vehToSeek, m_vehEnterType);
 											} else {
 												SetCarJack(vehToSeek);
 											}
 										} else {
-											SetEnterCar(vehToSeek, m_vehDoor);
+											SetEnterCar(vehToSeek, m_vehEnterType);
 										}
-									} else if (m_vehDoor == CAR_DOOR_RF && vehToSeek->pPassengers[0]) {
+									} else if (m_vehEnterType == CAR_DOOR_RF && vehToSeek->pPassengers[0]) {
 										if (vehToSeek->pPassengers[0]->bDontDragMeOutCar) {
 											if (IsPlayer())
-												SetEnterCar(vehToSeek, m_vehDoor);
+												SetEnterCar(vehToSeek, m_vehEnterType);
 										} else {
 											SetCarJack(vehToSeek);
 										}
 									} else {
-										SetEnterCar(vehToSeek, m_vehDoor);
+										SetEnterCar(vehToSeek, m_vehEnterType);
 									}
 									break;
 								case STATUS_WRECKED:
@ -7966,7 +7966,7 @@ CPed::LookForInterestingNodes(void)
 	C2dEffect *effect;
 	CMatrix *objMat;

-	if ((CTimer::GetFrameCounter() + (m_randomSeed % 256)) & 7 || CTimer::GetTimeInMilliseconds() <= m_chatTimer) {
+	if ((CTimer::GetFrameCounter() + (m_randomSeed % 256)) & 7 || CTimer::GetTimeInMilliseconds() <= m_standardTimer) {
 		return false;
 	}
 	bool found = false;
@ -8076,7 +8076,7 @@ CPed::LookForInterestingNodes(void)
 	float angleToFace = CGeneral::GetRadianAngleBetweenPoints(effectFrontLocal.x, effectFrontLocal.y, 0.0f, 0.0f);
 	randVal = CGeneral::GetRandomNumber() % 256;
 	if (randVal <= m_randomSeed % 256) {
-		m_chatTimer = CTimer::GetTimeInMilliseconds() + 2000;
+		m_standardTimer = CTimer::GetTimeInMilliseconds() + 2000;
 		SetLookFlag(angleToFace, true);
 		SetLookTimer(1000);
 		return false;
@ -8299,7 +8299,7 @@ CPed::SetWaitState(eWaitState state, void *time)
 			if (m_objective == OBJECTIVE_ENTER_CAR_AS_PASSENGER && CharCreatedBy == RANDOM_CHAR && m_nPedState == PED_SEEK_CAR) {
 				ClearObjective();
 				RestorePreviousState();
-				m_carJackTimer = CTimer::GetTimeInMilliseconds() + 30000;
+				m_hitRecoverTimer = CTimer::GetTimeInMilliseconds() + 30000;
 			}
 			break;
 		case WAITSTATE_TURN180:
@ -8328,7 +8328,7 @@ CPed::SetWaitState(eWaitState state, void *time)
 			if (m_objective == OBJECTIVE_ENTER_CAR_AS_PASSENGER && CharCreatedBy == RANDOM_CHAR && m_nPedState == PED_SEEK_CAR) {
 				ClearObjective();
 				RestorePreviousState();
-				m_carJackTimer = CTimer::GetTimeInMilliseconds() + 30000;
+				m_hitRecoverTimer = CTimer::GetTimeInMilliseconds() + 30000;
 			}
 			break;
 		case WAITSTATE_LOOK_ABOUT:
@ -8980,14 +8980,14 @@ CPed::SetSolicit(uint32 time)

 	if (CharCreatedBy != MISSION_CHAR && m_carInObjective->m_nNumGettingIn == 0
 		&& CTimer::GetTimeInMilliseconds() < m_objectiveTimer) {
-		if (m_vehDoor == CAR_DOOR_LF) {
+		if (m_vehEnterType == CAR_DOOR_LF) {
 			m_fRotationDest = m_carInObjective->GetForward().Heading() - HALFPI;
 		} else {
 			m_fRotationDest = m_carInObjective->GetForward().Heading() + HALFPI;
 		}

 		if (Abs(m_fRotationDest - m_fRotationCur) < HALFPI) {
-			m_chatTimer = CTimer::GetTimeInMilliseconds() + time;
+			m_standardTimer = CTimer::GetTimeInMilliseconds() + time;

 			if(!m_carInObjective->bIsVan && !m_carInObjective->bIsBus)
 				m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_HOOKERTALK, 4.0f);
@ -9001,8 +9001,8 @@ CPed::SetSolicit(uint32 time)
 void
 CPed::Solicit(void)
 {
-	if (m_chatTimer >= CTimer::GetTimeInMilliseconds() && m_carInObjective) {
-		CVector doorPos = GetPositionToOpenCarDoor(m_carInObjective, m_vehDoor, 0.0f);
+	if (m_standardTimer >= CTimer::GetTimeInMilliseconds() && m_carInObjective) {
+		CVector doorPos = GetPositionToOpenCarDoor(m_carInObjective, m_vehEnterType, 0.0f);
 		Say(SOUND_PED_SOLICIT);
 		if (FindPlayerVehicle() == m_carInObjective) {
 			FindPlayerPed()->Say(SOUND_PED_SOLICIT);
@ -9062,7 +9062,7 @@ CPed::BuyIceCream(void)
 {
 	if (m_carInObjective) {
 		CPed *driver = m_carInObjective->pDriver;
-		if (driver && CTimer::GetTimeInMilliseconds() > m_chatTimer) {
+		if (driver && CTimer::GetTimeInMilliseconds() > m_standardTimer) {
 			SetChat(driver, 8000);
 			driver->SetChat(this, 8000);
 			return;
@ -9138,7 +9138,7 @@ CPed::PossiblyFindBetterPosToSeekCar(CVector *pos, CVehicle *veh)
 		bool canHeadToRf = NTVF_RF <= 0.0f || NTVF_RF >= HALFPI;

 		// Only order of conditions are different among enterTypes.
-		if (m_vehDoor == CAR_DOOR_RR) {
+		if (m_vehEnterType == CAR_DOOR_RR) {
 			if (canHeadToRr) {
 				foundPos = rightRearPos;
 				foundIt = true;
@ -9152,7 +9152,7 @@ CPed::PossiblyFindBetterPosToSeekCar(CVector *pos, CVehicle *veh)
 				foundPos = leftFrontPos;
 				foundIt = true;
 			}
-		} else if(m_vehDoor == CAR_DOOR_RF) {
+		} else if(m_vehEnterType == CAR_DOOR_RF) {
 			if (canHeadToRf) {
 				foundPos = rightFrontPos;
 				foundIt = true;
@ -9166,7 +9166,7 @@ CPed::PossiblyFindBetterPosToSeekCar(CVector *pos, CVehicle *veh)
 				foundPos = leftRearPos;
 				foundIt = true;
 			}
-		} else if (m_vehDoor == CAR_DOOR_LF) {
+		} else if (m_vehEnterType == CAR_DOOR_LF) {
 			if (canHeadToLf) {
 				foundPos = leftFrontPos;
 				foundIt = true;
@ -9180,7 +9180,7 @@ CPed::PossiblyFindBetterPosToSeekCar(CVector *pos, CVehicle *veh)
 				foundPos = rightRearPos;
 				foundIt = true;
 			}
-		} else if (m_vehDoor == CAR_DOOR_LR) {
+		} else if (m_vehEnterType == CAR_DOOR_LR) {
 			if (canHeadToLr) {
 				foundPos = leftRearPos;
 				foundIt = true;
--- a/src/peds/Ped.h
+++ b/src/peds/Ped.h
@ -596,7 +596,7 @@ public:
 	float m_fRotationCur;
 	float m_fRotationDest;
 	float m_headingRate;
-	uint16 m_vehDoor;
+	uint16 m_vehEnterType;
 	int16 m_walkAroundType;
 	CPhysical *m_pCurrentPhysSurface;
 	CVector m_vecOffsetFromPhysSurface;
@ -650,10 +650,10 @@ public:
 	uint32 m_leaveCarTimer;
 	uint32 m_getUpTimer;
 	uint32 m_lookTimer;
-	uint32 m_chatTimer;
+	uint32 m_standardTimer;
 	uint32 m_attackTimer;
 	uint32 m_shootTimer; // shooting is a part of attack
-	uint32 m_carJackTimer;
+	uint32 m_hitRecoverTimer;
 	uint32 m_objectiveTimer;
 	uint32 m_duckTimer;
 	uint32 m_duckAndCoverTimer;
--- a/src/peds/PedAI.cpp
+++ b/src/peds/PedAI.cpp
@ -1223,7 +1223,7 @@ CPed::ProcessObjective(void)
 							bool foundSeat = false;
 							if (m_carInObjective->IsBike()) {
 								if (!m_carInObjective->pPassengers[0] && !(m_carInObjective->m_nGettingInFlags & (CAR_DOOR_FLAG_RR | CAR_DOOR_FLAG_LR))) {
-									m_vehDoor = CAR_DOOR_RR;
+									m_vehEnterType = CAR_DOOR_RR;
 									foundSeat = true;
 								}
 							} else {
@ -1232,27 +1232,27 @@ CPed::ProcessObjective(void)
 										if (m_carInObjective->pPassengers[2] || m_carInObjective->m_nGettingInFlags & CAR_DOOR_FLAG_RR) {
 											foundSeat = false;
 										} else {
-											m_vehDoor = CAR_DOOR_RR;
+											m_vehEnterType = CAR_DOOR_RR;
 											foundSeat = true;
 										}
 									} else {
-										m_vehDoor = CAR_DOOR_LR;
+										m_vehEnterType = CAR_DOOR_LR;
 										foundSeat = true;
 									}
 								} else {
-									m_vehDoor = CAR_DOOR_RF;
+									m_vehEnterType = CAR_DOOR_RF;
 									foundSeat = true;
 								}
 							}
 							for (int i = 2; i < m_carInObjective->m_nNumMaxPassengers; ++i) {
 								if (!m_carInObjective->pPassengers[i] && !(m_carInObjective->m_nGettingInFlags & CAR_DOOR_FLAG_RF)) {
-									m_vehDoor = CAR_DOOR_RF;
+									m_vehEnterType = CAR_DOOR_RF;
 									foundSeat = true;
 								}
 							}
 							if (foundSeat) {
-								SetPosition(GetPositionToOpenCarDoor(m_carInObjective, m_vehDoor));
-								SetEnterCar(m_carInObjective, m_vehDoor);
+								SetPosition(GetPositionToOpenCarDoor(m_carInObjective, m_vehEnterType));
+								SetEnterCar(m_carInObjective, m_vehEnterType);
 							}
 						}
 						m_objectiveTimer = 0;
@ -1565,7 +1565,7 @@ CPed::ProcessObjective(void)
 				if (bInVehicle) {
 					bScriptObjectiveCompleted = true;
 					RestorePreviousObjective();
-				} else if (m_carJackTimer < CTimer::GetTimeInMilliseconds()) {
+				} else if (m_hitRecoverTimer < CTimer::GetTimeInMilliseconds()) {
 					CVehicle *carToSteal = nil;
 					float closestCarDist = nEnterCarRangeMultiplier * ENTER_CAR_MAX_DIST;
 					CVector pos = GetPosition();
@ -1590,7 +1590,7 @@ CPed::ProcessObjective(void)
 					}
 					if (carToSteal) {
 						SetObjective(OBJECTIVE_ENTER_CAR_AS_DRIVER, carToSteal);
-						m_carJackTimer = CTimer::GetTimeInMilliseconds() + 5000;
+						m_hitRecoverTimer = CTimer::GetTimeInMilliseconds() + 5000;
 					} else {
 						RestorePreviousObjective();
 						RestorePreviousState();
@ -2382,7 +2382,7 @@ CPed::PedAnimAlignCB(CAnimBlendAssociation *animAssoc, void *arg)
 		return;
 	}

-	if (!ped->m_vehDoor) {
+	if (!ped->m_vehEnterType) {
 		ped->QuitEnteringCar();
 		return;
 	}
@ -2396,7 +2396,7 @@ CPed::PedAnimAlignCB(CAnimBlendAssociation *animAssoc, void *arg)
 	bool itsLow = !!veh->bLowVehicle;
 	eDoors enterDoor;

-	switch (ped->m_vehDoor) {
+	switch (ped->m_vehEnterType) {
 		case CAR_DOOR_RF:
 			itsVan = false;
 			enterDoor = DOOR_FRONT_RIGHT;
@ -2418,7 +2418,7 @@ CPed::PedAnimAlignCB(CAnimBlendAssociation *animAssoc, void *arg)
 	if (veh->IsBike()) {
 		CPed *pedToDragOut = nil;
 		if (veh->GetStatus() == STATUS_ABANDONED) {
-			if (ped->m_vehDoor == CAR_WINDSCREEN) {
+			if (ped->m_vehEnterType == CAR_WINDSCREEN) {
 				ped->m_pVehicleAnim = CAnimManager::BlendAnimation(ped->GetClump(), ((CBike*)veh)->m_bikeAnimType, ANIM_BIKE_KICK, 6.0f);
 				ped->m_pVehicleAnim->SetFinishCallback(PedAnimGetInCB, ped);
 				((CBike*)veh)->bIsBeingPickedUp = true;
@ -2444,7 +2444,7 @@ CPed::PedAnimAlignCB(CAnimBlendAssociation *animAssoc, void *arg)
 				ped->m_pVehicleAnim->SetFinishCallback(PedAnimGetInCB, ped);
 				((CBike*)veh)->bIsBeingPickedUp = true;
 			}
-		} else if (ped->m_vehDoor == CAR_WINDSCREEN) {
+		} else if (ped->m_vehEnterType == CAR_WINDSCREEN) {
 			if (veh->pDriver->m_nPedState != PED_DRIVING || veh->pDriver->bDontDragMeOutCar) {
 				ped->QuitEnteringCar();
 			} else {
@ -2458,7 +2458,7 @@ CPed::PedAnimAlignCB(CAnimBlendAssociation *animAssoc, void *arg)
 				if (veh->pDriver) {
 					if (veh->m_vecMoveSpeed.Magnitude() > 0.2f) {
 						ped->QuitEnteringCar();
-						ped->SetFall(1000, ped->m_vehDoor == CAR_DOOR_LF || ped->m_vehDoor == CAR_DOOR_LR ? ANIM_KO_SPIN_L : ANIM_KO_SPIN_R, false);
+						ped->SetFall(1000, ped->m_vehEnterType == CAR_DOOR_LF || ped->m_vehEnterType == CAR_DOOR_LR ? ANIM_KO_SPIN_L : ANIM_KO_SPIN_R, false);
 						return;
 					}
 					if (veh->pDriver->m_nPedState != PED_DRIVING || veh->pDriver->bDontDragMeOutCar) {
@ -2479,7 +2479,7 @@ CPed::PedAnimAlignCB(CAnimBlendAssociation *animAssoc, void *arg)
 				if (veh->pPassengers[0]) {
 					if (veh->m_vecMoveSpeed.Magnitude() > 0.2f) {
 						ped->QuitEnteringCar();
-						ped->SetFall(1000, ped->m_vehDoor == CAR_DOOR_LF || ped->m_vehDoor == CAR_DOOR_LR ? ANIM_KO_SPIN_L : ANIM_KO_SPIN_R, false);
+						ped->SetFall(1000, ped->m_vehEnterType == CAR_DOOR_LF || ped->m_vehEnterType == CAR_DOOR_LR ? ANIM_KO_SPIN_L : ANIM_KO_SPIN_R, false);
 						return;
 					}
 					if (veh->pPassengers[0]->m_nPedState != PED_DRIVING || veh->pPassengers[0]->bDontDragMeOutCar) {
@ -2502,7 +2502,7 @@ CPed::PedAnimAlignCB(CAnimBlendAssociation *animAssoc, void *arg)
 		}

 		if (pedToDragOut) {
-			pedToDragOut->SetBeingDraggedFromCar(veh, ped->m_vehDoor, false);
+			pedToDragOut->SetBeingDraggedFromCar(veh, ped->m_vehEnterType, false);
 			if (pedToDragOut->IsGangMember())
 				pedToDragOut->RegisterThreatWithGangPeds(ped);

@ -2580,7 +2580,7 @@ CPed::PedAnimAlignCB(CAnimBlendAssociation *animAssoc, void *arg)
 					}

 					if (player != veh->pDriver) {
-						veh->pDriver->SetBeingDraggedFromCar(veh, ped->m_vehDoor, true);
+						veh->pDriver->SetBeingDraggedFromCar(veh, ped->m_vehEnterType, true);
 						if (veh->pDriver->IsGangMember())
 							veh->pDriver->RegisterThreatWithGangPeds(ped);
 					}
@ -2630,7 +2630,7 @@ CPed::PedAnimDoorOpenCB(CAnimBlendAssociation* animAssoc, void* arg)

 	eDoors door;
 	CPed *pedInSeat = nil;
-	switch (ped->m_vehDoor) {
+	switch (ped->m_vehEnterType) {
 		case CAR_DOOR_RF:
 			door = DOOR_FRONT_RIGHT;
 			pedInSeat = veh->pPassengers[0];
@ -2688,21 +2688,21 @@ CPed::PedAnimDoorOpenCB(CAnimBlendAssociation* animAssoc, void* arg)
 	if (veh->m_vecMoveSpeed.Magnitude() > 0.2f ||
 		veh->IsCar() && veh->GetVehicleAppearance() == VEHICLE_APPEARANCE_HELI && ((CAutomobile*)veh)->m_nWheelsOnGround == 0) {
 		ped->QuitEnteringCar();
-		if (ped->m_vehDoor != CAR_DOOR_LF && ped->m_vehDoor != CAR_DOOR_LR)
+		if (ped->m_vehEnterType != CAR_DOOR_LF && ped->m_vehEnterType != CAR_DOOR_LR)
 			ped->SetFall(1000, ANIM_KO_SPIN_R, false);
 		else
 			ped->SetFall(1000, ANIM_KO_SPIN_L, false);
 		
 		return;
 	}
-	veh->ProcessOpenDoor(ped->m_vehDoor, ANIM_CAR_OPEN_LHS, 1.0f);
+	veh->ProcessOpenDoor(ped->m_vehEnterType, ANIM_CAR_OPEN_LHS, 1.0f);

-	if (ped->m_vehDoor == CAR_DOOR_LF || ped->m_vehDoor == CAR_DOOR_RF)
+	if (ped->m_vehEnterType == CAR_DOOR_LF || ped->m_vehEnterType == CAR_DOOR_RF)
 		isVan = false;

 	if (ped->m_nPedState != PED_CARJACK || isBus) {

-		if (ped->m_vehDoor == CAR_DOOR_LF || ped->m_vehDoor == CAR_DOOR_LR) {
+		if (ped->m_vehEnterType == CAR_DOOR_LF || ped->m_vehEnterType == CAR_DOOR_LR) {
 			if (veh->IsBike()) {
 				ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ((CBike*)veh)->m_bikeAnimType, ANIM_BIKE_JUMPON_R);
 			} else if (isVan) {
@ -2727,14 +2727,14 @@ CPed::PedAnimDoorOpenCB(CAnimBlendAssociation* animAssoc, void* arg)
 				ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ASSOCGRP_STD, ANIM_CAR_GETIN_RHS);
 			}

-			if (ped->m_vehDoor == CAR_DOOR_RF && pedInSeat && veh->IsCar())
+			if (ped->m_vehEnterType == CAR_DOOR_RF && pedInSeat && veh->IsCar())
 				pedInSeat->SetObjective(OBJECTIVE_LEAVE_CAR, veh);
 		}
 		
 		ped->m_pVehicleAnim->SetFinishCallback(PedAnimGetInCB, ped);
 	} else {
 		CPed *pedToDragOut = nil;
-		switch (ped->m_vehDoor) {
+		switch (ped->m_vehEnterType) {
 			case CAR_DOOR_RF: pedToDragOut = veh->pPassengers[0]; break;
 			case CAR_DOOR_RR: pedToDragOut = veh->pPassengers[2]; break;
 			case CAR_DOOR_LF: pedToDragOut = veh->pDriver; break;
@ -2748,7 +2748,7 @@ CPed::PedAnimDoorOpenCB(CAnimBlendAssociation* animAssoc, void* arg)
 				((CCopPed*)ped)->SetArrestPlayer(ped->m_pedInObjective);
 		}

-		if (ped->m_vehDoor != CAR_DOOR_LF && ped->m_vehDoor != CAR_DOOR_LR) {
+		if (ped->m_vehEnterType != CAR_DOOR_LF && ped->m_vehEnterType != CAR_DOOR_LR) {

 			if (pedToDragOut && !pedToDragOut->bDontDragMeOutCar) {
 				if (pedToDragOut->m_nPedState != PED_DRIVING) {
@ -2818,7 +2818,7 @@ CPed::PedAnimDoorOpenCB(CAnimBlendAssociation* animAssoc, void* arg)
 			}

 			if (player != pedToDragOut) {
-				pedToDragOut->SetBeingDraggedFromCar(veh, ped->m_vehDoor, false);
+				pedToDragOut->SetBeingDraggedFromCar(veh, ped->m_vehEnterType, false);
 				if (pedToDragOut->IsGangMember())
 					pedToDragOut->RegisterThreatWithGangPeds(ped);
 			}
@ -2889,7 +2889,7 @@ CPed::PedAnimPullPedOutCB(CAnimBlendAssociation* animAssoc, void* arg)
 		}

 		if (ped->m_objective == OBJECTIVE_ENTER_CAR_AS_DRIVER) {
-			if (ped->m_vehDoor == CAR_DOOR_LF || ped->m_vehDoor == CAR_DOOR_LR) {
+			if (ped->m_vehEnterType == CAR_DOOR_LF || ped->m_vehEnterType == CAR_DOOR_LR) {
 				if (veh->IsBike())
 					ped->m_pVehicleAnim = CAnimManager::AddAnimation(ped->GetClump(), ((CBike*)veh)->m_bikeAnimType, ANIM_BIKE_JUMPON_R);
 				else if (isLow)
@ -2946,7 +2946,7 @@ CPed::PedAnimGetInCB(CAnimBlendAssociation *animAssoc, void *arg)
 		}
 		return;
 	}
-	if (ped->IsPlayer() && ped->m_vehDoor == CAR_DOOR_LF
+	if (ped->IsPlayer() && ped->m_vehEnterType == CAR_DOOR_LF
 		&& (Pads[0].GetAccelerate() >= 255.0f || Pads[0].GetBrake() >= 255.0f)
 		&& veh->IsCar() && !veh->pDriver) {

@ -2965,7 +2965,7 @@ CPed::PedAnimGetInCB(CAnimBlendAssociation *animAssoc, void *arg)
 	bool isBus = !!veh->bIsBus;
 	bool isLow = !!veh->bLowVehicle;
 	eDoors enterDoor;
-	switch (ped->m_vehDoor) {
+	switch (ped->m_vehEnterType) {
 		case CAR_DOOR_RF:
 			isVan = false;
 			enterDoor = DOOR_FRONT_RIGHT;
@ -3011,7 +3011,7 @@ CPed::PedAnimGetInCB(CAnimBlendAssociation *animAssoc, void *arg)
 			ped->m_leaveCarTimer = CTimer::GetTimeInMilliseconds() + 400;
 			return;
 		}
-		if (driver != ped && ped->m_vehDoor != CAR_DOOR_LF) {
+		if (driver != ped && ped->m_vehEnterType != CAR_DOOR_LF) {
 			if (!driver->IsPlayer()) {
 				driver->bUsePedNodeSeek = true;
 				driver->m_pLastPathNode = nil;
@ -3094,10 +3094,10 @@ CPed::PedAnimDoorCloseCB(CAnimBlendAssociation *animAssoc, void *arg)
 		bool isLow = !!veh->bLowVehicle;

 		if (!veh->bIsBus)
-			veh->ProcessOpenDoor(ped->m_vehDoor, ANIM_CAR_CLOSEDOOR_LHS, 1.0f);
+			veh->ProcessOpenDoor(ped->m_vehEnterType, ANIM_CAR_CLOSEDOOR_LHS, 1.0f);

 		eDoors door;
-		switch (ped->m_vehDoor) {
+		switch (ped->m_vehEnterType) {
 			case CAR_DOOR_RF: door = DOOR_FRONT_RIGHT; break;
 			case CAR_DOOR_RR: door = DOOR_REAR_RIGHT; break;
 			case CAR_DOOR_LF: door = DOOR_FRONT_LEFT; break;
@ -3110,7 +3110,7 @@ CPed::PedAnimDoorCloseCB(CAnimBlendAssociation *animAssoc, void *arg)

 		if (door == DOOR_FRONT_LEFT || ped->m_objective == OBJECTIVE_ENTER_CAR_AS_PASSENGER || veh->bIsBus || veh->m_nNumMaxPassengers == 0) {
 			PedSetInCarCB(nil, ped);
-		} else if (ped->m_vehDoor == CAR_DOOR_RF
+		} else if (ped->m_vehEnterType == CAR_DOOR_RF
 				&& (veh->m_nGettingInFlags & CAR_DOOR_FLAG_LF ||
 					(veh->pDriver != nil && 
 						(veh->pDriver->m_objective != OBJECTIVE_LEAVE_CAR
@ -3263,7 +3263,7 @@ CPed::PedAnimStepOutCarCB(CAnimBlendAssociation* animAssoc, void* arg)
 	veh->m_vecMoveSpeed += CVector(0.001f, 0.001f, 0.001f);
 	veh->m_vecTurnSpeed += CVector(0.001f, 0.001f, 0.001f);
 	if (!veh->bIsBus)
-		veh->ProcessOpenDoor(ped->m_vehDoor, ANIM_CAR_GETOUT_LHS, 1.0f);
+		veh->ProcessOpenDoor(ped->m_vehEnterType, ANIM_CAR_GETOUT_LHS, 1.0f);

 	/* 
 	// Duplicate and only in PC for some reason
@ -3273,7 +3273,7 @@ CPed::PedAnimStepOutCarCB(CAnimBlendAssociation* animAssoc, void* arg)
 	}
 	*/
 	eDoors door;
-	switch (ped->m_vehDoor) {
+	switch (ped->m_vehEnterType) {
 		case CAR_DOOR_RF:
 			door = DOOR_FRONT_RIGHT;
 			break;
@ -3442,7 +3442,7 @@ CPed::LineUpPedWithCar(PedLineUpPhase phase)
 	if (veh->GetUp().z <= -0.8f)
 		vehIsUpsideDown = true;

-	if (m_vehDoor == CAR_DOOR_RF || m_vehDoor == CAR_DOOR_RR) {
+	if (m_vehEnterType == CAR_DOOR_RF || m_vehEnterType == CAR_DOOR_RR) {
 		if (vehIsUpsideDown) {
 			m_fRotationDest = -PI + veh->GetForward().Heading();
 		} else if (veh->bIsBus) {
@ -3450,7 +3450,7 @@ CPed::LineUpPedWithCar(PedLineUpPhase phase)
 		} else {
 			m_fRotationDest = veh->GetForward().Heading();
 		}
-	} else if (m_vehDoor == CAR_DOOR_LF || m_vehDoor == CAR_DOOR_LR) {
+	} else if (m_vehEnterType == CAR_DOOR_LF || m_vehEnterType == CAR_DOOR_LR) {
 		if (vehIsUpsideDown) {
 			m_fRotationDest = veh->GetForward().Heading();
 		} else if (veh->bIsBus) {
@ -3465,7 +3465,7 @@ CPed::LineUpPedWithCar(PedLineUpPhase phase)
 			m_fRotationDest = veh->GetForward().Heading();
 		} else if (veh->bIsBus) {
 			m_fRotationDest = 0.5f * PI + veh->GetForward().Heading();
-		} else if (m_vehDoor == CAR_WINDSCREEN) {
+		} else if (m_vehEnterType == CAR_WINDSCREEN) {
 			m_fRotationDest = veh->GetForward().Heading() + PI;
 		} else {
 			m_fRotationDest = veh->GetForward().Heading();
@ -3573,7 +3573,7 @@ CPed::LineUpPedWithCar(PedLineUpPhase phase)
 	if (phase == LINE_UP_TO_CAR_2) {
 		neededPos = GetPosition();
 	} else {
-		neededPos = GetPositionToOpenCarDoor(veh, m_vehDoor, seatPosMult);
+		neededPos = GetPositionToOpenCarDoor(veh, m_vehEnterType, seatPosMult);
 	}

 	autoZPos = neededPos;
@ -3690,13 +3690,13 @@ CPed::LineUpPedWithCar(PedLineUpPhase phase)
 		SetHeading(m_fRotationCur);
 	} else {
 		CMatrix vehDoorMat(veh->GetMatrix());
-		vehDoorMat.GetPosition() += Multiply3x3(vehDoorMat, GetLocalPositionToOpenCarDoor(veh, m_vehDoor, 0.0f));
+		vehDoorMat.GetPosition() += Multiply3x3(vehDoorMat, GetLocalPositionToOpenCarDoor(veh, m_vehEnterType, 0.0f));

-		if (m_vehDoor == CAR_WINDSCREEN || veh->bIsBus) {
+		if (m_vehEnterType == CAR_WINDSCREEN || veh->bIsBus) {
 			CMatrix correctionMat;
-			if (veh->bIsBus && (m_vehDoor == CAR_DOOR_LF || m_vehDoor == CAR_DOOR_LR))
+			if (veh->bIsBus && (m_vehEnterType == CAR_DOOR_LF || m_vehEnterType == CAR_DOOR_LR))
 				correctionMat.SetRotateZ(-HALFPI);
-			else if (veh->bIsBus && (m_vehDoor == CAR_DOOR_RF || m_vehDoor == CAR_DOOR_RR))
+			else if (veh->bIsBus && (m_vehEnterType == CAR_DOOR_RF || m_vehEnterType == CAR_DOOR_RR))
 				correctionMat.SetRotateZ(HALFPI);
 			else
 				correctionMat.SetRotateZ(PI);
@ -3720,7 +3720,7 @@ CPed::SetCarJack(CVehicle* car)
 		return;

 	if (car->IsBike()) {
-		switch (m_vehDoor) {
+		switch (m_vehEnterType) {
 			case CAR_DOOR_RF:
 				doorFlag = CAR_DOOR_FLAG_LF | CAR_DOOR_FLAG_RF;
 				door = DOOR_FRONT_RIGHT;
@ -3747,7 +3747,7 @@ CPed::SetCarJack(CVehicle* car)
 				break;
 		}
 	} else {
-		switch (m_vehDoor) {
+		switch (m_vehEnterType) {
 			case CAR_DOOR_RF:
 				doorFlag = CAR_DOOR_FLAG_RF;
 				door = DOOR_FRONT_RIGHT;
@ -3788,7 +3788,7 @@ CPed::SetCarJack(CVehicle* car)
 			if (m_nPedState != PED_CARJACK && !m_pVehicleAnim)
 				if ((car->IsDoorReady(door) || car->IsDoorFullyOpen(door)))
 					if (!car->bIsBeingCarJacked && !(doorFlag & car->m_nGettingInFlags) && !(doorFlag & car->m_nGettingOutFlags))
-						SetCarJack_AllClear(car, m_vehDoor, doorFlag);
+						SetCarJack_AllClear(car, m_vehEnterType, doorFlag);
 }

 // --MIAMI: Done
@ -3812,7 +3812,7 @@ CPed::SetCarJack_AllClear(CVehicle* car, uint32 doorNode, uint32 doorFlag)
 		Say(SOUND_PED_CAR_JACKING, 1000);

 	CVector carEnterPos;
-	carEnterPos = GetPositionToOpenCarDoor(car, m_vehDoor);
+	carEnterPos = GetPositionToOpenCarDoor(car, m_vehEnterType);

 	car->m_nGettingInFlags |= doorFlag;
 	m_vecOffsetSeek = carEnterPos - GetPosition();
@ -3825,7 +3825,7 @@ CPed::SetCarJack_AllClear(CVehicle* car, uint32 doorNode, uint32 doorFlag)
 		float zDiff = Max(0.0f, carEnterPos.z - GetPosition().z);
 		bUsesCollision = false;

-		if (m_vehDoor == CAR_DOOR_LF || m_vehDoor == CAR_DOOR_LR)
+		if (m_vehEnterType == CAR_DOOR_LF || m_vehEnterType == CAR_DOOR_LR)
 			m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, zDiff > 4.4f ? ANIM_CAR_ALIGNHI_LHS : ANIM_CAR_ALIGN_LHS, 4.0f);
 		else
 			m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, zDiff > 4.4f ? ANIM_CAR_ALIGNHI_RHS : ANIM_CAR_ALIGN_RHS, 4.0f);
@ -3851,14 +3851,14 @@ CPed::SetBeingDraggedFromCar(CVehicle *veh, uint32 vehEnterType, bool quickJack)
 	if (veh->IsBike()) {
 		((CBike*)veh)->bIsBeingPickedUp = true;
 		if (veh->pPassengers[0] != this && (vehEnterType != CAR_WINDSCREEN || veh->pPassengers[0]))
-			m_vehDoor = CAR_DOOR_LF;
+			m_vehEnterType = CAR_DOOR_LF;
 		else
-			m_vehDoor = CAR_DOOR_LR;
+			m_vehEnterType = CAR_DOOR_LR;
 	} else {
-		m_vehDoor = vehEnterType;
+		m_vehEnterType = vehEnterType;
 	}

-	if (m_vehDoor == CAR_DOOR_LF) {
+	if (m_vehEnterType == CAR_DOOR_LF) {
 		if (veh->pDriver && veh->pDriver->IsPlayer())
 			veh->SetStatus(STATUS_PLAYER_DISABLED);
 		else
@ -3878,9 +3878,9 @@ CPed::SetBeingDraggedFromCar(CVehicle *veh, uint32 vehEnterType, bool quickJack)
 	SetRadioStation();

 	if(veh->IsBike())
-		veh->m_nGettingOutFlags |= GetBikeDoorFlagInclJumpInFromFront(m_vehDoor);
+		veh->m_nGettingOutFlags |= GetBikeDoorFlagInclJumpInFromFront(m_vehEnterType);
 	else
-		veh->m_nGettingOutFlags |= GetCarDoorFlag(m_vehDoor);
+		veh->m_nGettingOutFlags |= GetCarDoorFlag(m_vehEnterType);
 }

 // --MIAMI: Done
@ -3899,15 +3899,15 @@ CPed::BeingDraggedFromCar(void)
 			assocGroup = ((CBike*)m_pMyVehicle)->m_bikeAnimType;

 		} else {
-			if (m_vehDoor == CAR_DOOR_LF || m_vehDoor == CAR_DOOR_LR) {
-				if (bWillBeQuickJacked && m_vehDoor == CAR_DOOR_LF) {
+			if (m_vehEnterType == CAR_DOOR_LF || m_vehEnterType == CAR_DOOR_LR) {
+				if (bWillBeQuickJacked && m_vehEnterType == CAR_DOOR_LF) {
 					enterAnim = ANIM_CAR_QJACKED;
 				} else if (m_pMyVehicle->bLowVehicle) {
 					enterAnim = ANIM_CAR_LJACKED_LHS;
 				} else {
 					enterAnim = ANIM_CAR_JACKED_LHS;
 				}
-			} else if (m_vehDoor == CAR_DOOR_RF || m_vehDoor == CAR_DOOR_RR) {
+			} else if (m_vehEnterType == CAR_DOOR_RF || m_vehEnterType == CAR_DOOR_RR) {
 				if (m_pMyVehicle->bLowVehicle)
 					enterAnim = ANIM_CAR_LJACKED_RHS;
 				else
@ -3944,7 +3944,7 @@ CPed::BeingDraggedFromCar(void)
 	static float mult = 5.f;
 	if (m_objective == OBJECTIVE_LEAVE_CAR_AND_DIE) {
 		if (m_pMyVehicle) {
-			m_pMyVehicle->ProcessOpenDoor(m_vehDoor, NUM_STD_ANIMS, m_pVehicleAnim->currentTime * mult);
+			m_pMyVehicle->ProcessOpenDoor(m_vehEnterType, NUM_STD_ANIMS, m_pVehicleAnim->currentTime * mult);
 		}
 	}
 }
@ -3960,7 +3960,7 @@ CPed::SetEnterCar(CVehicle *car, uint32 unused)
 		uint8 doorFlag;
 		eDoors door;
 		if (car->IsBike()) {
-			switch (m_vehDoor) {
+			switch (m_vehEnterType) {
 				case CAR_DOOR_RF:
 					doorFlag = CAR_DOOR_FLAG_RF | CAR_DOOR_FLAG_LF;
 					door = DOOR_FRONT_RIGHT;
@ -3986,7 +3986,7 @@ CPed::SetEnterCar(CVehicle *car, uint32 unused)
 					break;
 			}
 		} else {
-			switch (m_vehDoor) {
+			switch (m_vehEnterType) {
 				case CAR_DOOR_RF:
 					doorFlag = CAR_DOOR_FLAG_RF;
 					door = DOOR_FRONT_RIGHT;
@ -4022,7 +4022,7 @@ CPed::SetEnterCar(CVehicle *car, uint32 unused)
 			|| doorFlag && !car->IsDoorReady(door) && !car->IsDoorFullyOpen(door))
 			SetMoveState(PEDMOVE_STILL);
 		else
-			SetEnterCar_AllClear(car, m_vehDoor, doorFlag);
+			SetEnterCar_AllClear(car, m_vehEnterType, doorFlag);
 	}
 }

@ -4038,9 +4038,9 @@ CPed::SetEnterCar_AllClear(CVehicle *car, uint32 doorNode, uint32 doorFlag)

 	m_pSeekTarget = car;
 	m_pSeekTarget->RegisterReference((CEntity **) &m_pSeekTarget);
-	m_vehDoor = doorNode;
+	m_vehEnterType = doorNode;
 	SetPedState(PED_ENTER_CAR);
-	if (m_vehDoor == CAR_DOOR_RF && m_objective == OBJECTIVE_ENTER_CAR_AS_DRIVER && !car->IsBike()) {
+	if (m_vehEnterType == CAR_DOOR_RF && m_objective == OBJECTIVE_ENTER_CAR_AS_DRIVER && !car->IsBike()) {
 		car->bIsBeingCarJacked = true;
 	}

@ -4048,7 +4048,7 @@ CPed::SetEnterCar_AllClear(CVehicle *car, uint32 doorNode, uint32 doorFlag)
 	m_pMyVehicle->RegisterReference((CEntity**) &m_pMyVehicle);
 	((CVehicle*)m_pSeekTarget)->m_nNumGettingIn++;
 	bUsesCollision = false;
-	CVector doorOpenPos = GetPositionToOpenCarDoor(car, m_vehDoor);
+	CVector doorOpenPos = GetPositionToOpenCarDoor(car, m_vehEnterType);

 	// Because buses have stairs
 	if (!m_pMyVehicle->bIsBus)
@ -4071,7 +4071,7 @@ CPed::SetEnterCar_AllClear(CVehicle *car, uint32 doorNode, uint32 doorFlag)
 		car->AutoPilot.m_nCruiseSpeed = 0;

 	} else {
-		if (m_vehDoor == CAR_DOOR_LF || m_vehDoor == CAR_DOOR_LR)
+		if (m_vehEnterType == CAR_DOOR_LF || m_vehEnterType == CAR_DOOR_LR)
 			m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, zDiff > 4.4f ? ANIM_CAR_ALIGNHI_RHS : ANIM_CAR_ALIGN_RHS, 4.0f);
 		else
 			m_pVehicleAnim = CAnimManager::BlendAnimation(GetClump(), ASSOCGRP_STD, zDiff > 4.4f ? ANIM_CAR_ALIGNHI_LHS : ANIM_CAR_ALIGN_LHS, 4.0f);
@ -4087,11 +4087,11 @@ CPed::EnterCar(void)
 		CVehicle *veh = m_pMyVehicle;

 		// Not used.
-		// CVector posForDoor = GetPositionToOpenCarDoor(veh, m_vehDoor);
+		// CVector posForDoor = GetPositionToOpenCarDoor(veh, m_vehEnterType);

 		if (veh->CanPedOpenLocks(this)) {
-			if (m_vehDoor && m_pVehicleAnim) {
-				veh->ProcessOpenDoor(m_vehDoor, m_pVehicleAnim->animId, m_pVehicleAnim->currentTime);
+			if (m_vehEnterType && m_pVehicleAnim) {
+				veh->ProcessOpenDoor(m_vehEnterType, m_pVehicleAnim->animId, m_pVehicleAnim->currentTime);
 			}
 		}
 		bIsInTheAir = false;
@ -4147,10 +4147,10 @@ CPed::QuitEnteringCar(void)
 			RestorePreviousObjective();

 		if (veh->IsBike()) {
-			veh->m_nGettingInFlags &= ~GetBikeDoorFlag(m_vehDoor);
+			veh->m_nGettingInFlags &= ~GetBikeDoorFlag(m_vehEnterType);
 			((CBike*)veh)->bIsBeingPickedUp = false;
 		} else
-			veh->m_nGettingInFlags &= ~GetEnterCarDoorFlag(m_vehDoor, veh->m_nNumMaxPassengers);
+			veh->m_nGettingInFlags &= ~GetEnterCarDoorFlag(m_vehEnterType, veh->m_nNumMaxPassengers);
 	}

 	bUsesCollision = true;
@ -4184,7 +4184,7 @@ CPed::SetExitBoat(CVehicle *boat)
 		newPos = { 0.0f, 0.0f, boatCol->boundingBox.min.z };
 		newPos = boat->GetMatrix() * newPos;
 		newPos.z += 1.0f;
-		m_vehDoor = CAR_DOOR_RF;
+		m_vehEnterType = CAR_DOOR_RF;
 		PedSetOutCarCB(nil, this);
 		bIsStanding = true;
 		m_pCurSurface = boat;
@ -4193,7 +4193,7 @@ CPed::SetExitBoat(CVehicle *boat)
 	} else {
 		if (boat->m_modelIndex == MI_SKIMMER) {
 			if (!boat->bIsInWater) {
-				m_vehDoor = CAR_DOOR_RF;
+				m_vehEnterType = CAR_DOOR_RF;
 				PedSetOutCarCB(nil, this);
 				bIsStanding = true;
 				SetMoveState(PEDMOVE_STILL);
@ -4214,7 +4214,7 @@ CPed::SetExitBoat(CVehicle *boat)

 			newPos.z += 2.0f;
 		}
-		m_vehDoor = CAR_DOOR_RF;
+		m_vehEnterType = CAR_DOOR_RF;
 		PedSetOutCarCB(nil, this);
 		bIsStanding = true;
 		m_pCurSurface = boat;
@ -4455,14 +4455,14 @@ CPed::SetExitCar(CVehicle *veh, uint32 wantedDoorNode)

 				// needed for PositionPedOutOfCollision()
 				optedDoorNode = firstOptedDoor;
-				m_vehDoor = firstOptedDoor;
+				m_vehEnterType = firstOptedDoor;
 				PositionPedOutOfCollision();
 				teleportNeeded = true;
 			}
 		}

 		if (!teleportNeeded && veh->IsOnItsSide()) {
-			m_vehDoor = optedDoorNode;
+			m_vehEnterType = optedDoorNode;
 			PositionPedOutOfCollision();
 			teleportNeeded = true;
 		}
@ -4480,7 +4480,7 @@ CPed::SetExitCar(CVehicle *veh, uint32 wantedDoorNode)
 		bUsesCollision = false;
 		m_pSeekTarget = veh;
 		m_pSeekTarget->RegisterReference((CEntity**) &m_pSeekTarget);
-		m_vehDoor = optedDoorNode;
+		m_vehEnterType = optedDoorNode;
 		SetPedState(PED_EXIT_CAR);
 		if (m_pVehicleAnim && m_pVehicleAnim->flags & ASSOC_PARTIAL)
 			m_pVehicleAnim->blendDelta = -1000.0f;
@ -4493,16 +4493,16 @@ CPed::SetExitCar(CVehicle *veh, uint32 wantedDoorNode)
 			PedSetOutCarCB(nil, this);
 		} else {
 			if (veh->GetUp().z <= -0.8f && !veh->IsBike()) {
-				if (m_vehDoor == CAR_DOOR_RF || m_vehDoor == CAR_DOOR_RR) {
+				if (m_vehEnterType == CAR_DOOR_RF || m_vehEnterType == CAR_DOOR_RR) {
 					m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_CRAWLOUT_RHS2);
-				} else if (m_vehDoor == CAR_DOOR_LF || m_vehDoor == CAR_DOOR_LR) {
+				} else if (m_vehEnterType == CAR_DOOR_LF || m_vehEnterType == CAR_DOOR_LR) {
 					m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_CRAWLOUT_RHS);
 				}
 				m_pVehicleAnim->SetFinishCallback(PedSetOutCarCB, this);

 			} else if (veh->IsBike()) {
 				CBike* bike = (CBike*)veh;
-				switch (m_vehDoor) {
+				switch (m_vehEnterType) {
 					case CAR_BUMP_REAR:
 					case CAR_BOOT:
 						m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), bike->m_bikeAnimType, ANIM_BIKE_GETOFF_BACK);
@ -4521,7 +4521,7 @@ CPed::SetExitCar(CVehicle *veh, uint32 wantedDoorNode)
 				int8 exitFlags = 0;

 				// Bike door flags incl. passenger jump off
-				switch (m_vehDoor) {
+				switch (m_vehEnterType) {
 					case CAR_BUMP_REAR:
 					case CAR_DOOR_RR:
 					case CAR_DOOR_LR:
@ -4535,7 +4535,7 @@ CPed::SetExitCar(CVehicle *veh, uint32 wantedDoorNode)
 				}

 				// Passenger get off
-				if (m_vehDoor == CAR_BUMP_REAR || m_vehDoor == CAR_BOOT) {
+				if (m_vehEnterType == CAR_BUMP_REAR || m_vehEnterType == CAR_BOOT) {
 					m_pVehicleAnim->SetFinishCallback(RestoreHeadingRateCB, this);
 					m_headingRate = 0.0f;

@ -4545,7 +4545,7 @@ CPed::SetExitCar(CVehicle *veh, uint32 wantedDoorNode)
 				}

 			} else {
-				switch (m_vehDoor) {
+				switch (m_vehEnterType) {
 					case CAR_DOOR_RF:
 						if (canJumpOut) {
 							m_pVehicleAnim = CAnimManager::AddAnimation(GetClump(), ASSOCGRP_STD, ANIM_CAR_ROLLOUT_RHS);
@ -4596,7 +4596,7 @@ CPed::SetExitCar(CVehicle *veh, uint32 wantedDoorNode)
 						break;
 				}
 				if (!bBusJacked && !canJumpOut) {
-					veh->m_nGettingOutFlags |= GetCarDoorFlag(m_vehDoor);
+					veh->m_nGettingOutFlags |= GetCarDoorFlag(m_vehEnterType);
 				}
 				m_pVehicleAnim->SetFinishCallback(canJumpOut ? RestoreHeadingRateCB : PedAnimStepOutCarCB, this);
 			}
@ -4622,7 +4622,7 @@ CPed::ExitCar(void)
 	if (!m_pVehicleAnim) {
 		if (InVehicle()) {
 			if (m_pMyVehicle->IsBike()) {
-				if (m_vehDoor == CAR_BOOT || m_vehDoor == CAR_BUMP_REAR) {
+				if (m_vehEnterType == CAR_BOOT || m_vehEnterType == CAR_BUMP_REAR) {
 					((CBike*)m_pMyVehicle)->KnockOffRider(WEAPONTYPE_UNARMED, 0, this, false);
 				}
 			} else if (m_pMyVehicle->IsCar()) {
@ -4656,7 +4656,7 @@ CPed::ExitCar(void)
 			LineUpPedWithCar(LINE_UP_TO_CAR_FALL);
 		}
 	} else {
-		m_pMyVehicle->ProcessOpenDoor(m_vehDoor, exitAnim, animTime);
+		m_pMyVehicle->ProcessOpenDoor(m_vehEnterType, exitAnim, animTime);

 		if (m_pSeekTarget) {
 			// Car is upside down
@ -4718,17 +4718,17 @@ CPed::GetNearestDoor(CVehicle *veh, CVector &posToOpen)
 					angleDiff += TWOPI;

 				if (Abs(angleDiff) < DEGTORAD(30.f)
-					&& (IsPlayer() && ((CPlayerPed*)this)->m_fMoveSpeed > 1.5f && !m_vehDoor ||
+					&& (IsPlayer() && ((CPlayerPed*)this)->m_fMoveSpeed > 1.5f && !m_vehEnterType ||
 						!IsPlayer() && m_nPedType != PEDTYPE_COP && m_nMoveState == PEDMOVE_RUN
 						&& m_pedStats->m_temper > 65
-						&& !m_vehDoor || m_vehDoor == CAR_WINDSCREEN)) {
-					m_vehDoor = CAR_WINDSCREEN;
+						&& !m_vehEnterType || m_vehEnterType == CAR_WINDSCREEN)) {
+					m_vehEnterType = CAR_WINDSCREEN;
 					posToOpen = GetPositionToOpenCarDoor(veh, CAR_WINDSCREEN);
 					return;
 				}
 			}
 		}
-	} else if (m_vehDoor == CAR_DOOR_LF && veh->pDriver && !veh->bLowVehicle && !veh->bIsBus) {
+	} else if (m_vehEnterType == CAR_DOOR_LF && veh->pDriver && !veh->bLowVehicle && !veh->bIsBus) {
 		enterOffset = &vecPedQuickDraggedOutCarAnimOffset;
 	}

@ -4739,10 +4739,10 @@ CPed::GetNearestDoor(CVehicle *veh, CVector &posToOpen)
 	if ((lfPos - GetPosition()).MagnitudeSqr2D() < (rfPos - GetPosition()).MagnitudeSqr2D()) {

 		if (veh->IsRoomForPedToLeaveCar(CAR_DOOR_LF, enterOffset)) {
-			m_vehDoor = CAR_DOOR_LF;
+			m_vehEnterType = CAR_DOOR_LF;
 			posToOpen = lfPos;
 		} else if (veh->IsRoomForPedToLeaveCar(CAR_DOOR_RF, enterOffset)) {
-			m_vehDoor = CAR_DOOR_RF;
+			m_vehEnterType = CAR_DOOR_RF;
 			posToOpen = rfPos;
 		}
 	} else {
@ -4756,14 +4756,14 @@ CPed::GetNearestDoor(CVehicle *veh, CVector &posToOpen)
 					&& veh->IsRoomForPedToLeaveCar(CAR_DOOR_LF, enterOffset)
 				|| (veh->m_nGettingInFlags & CAR_DOOR_FLAG_RF) && veh->IsRoomForPedToLeaveCar(CAR_DOOR_LF, enterOffset)) {

-				m_vehDoor = CAR_DOOR_LF;
+				m_vehEnterType = CAR_DOOR_LF;
 				posToOpen = lfPos;
 			} else {
-				m_vehDoor = CAR_DOOR_RF;
+				m_vehEnterType = CAR_DOOR_RF;
 				posToOpen = rfPos;
 			}
 		} else if (veh->IsRoomForPedToLeaveCar(CAR_DOOR_LF, enterOffset)) {
-			m_vehDoor = CAR_DOOR_LF;
+			m_vehEnterType = CAR_DOOR_LF;
 			posToOpen = lfPos;
 		}
 	}
@ -4780,7 +4780,7 @@ CPed::GetNearestPassengerDoor(CVehicle *veh, CVector &posToOpen)

 	switch (veh->GetModelIndex()) {
 		case MI_BUS:
-			m_vehDoor = CAR_DOOR_RF;
+			m_vehEnterType = CAR_DOOR_RF;
 			posToOpen = GetPositionToOpenCarDoor(veh, CAR_DOOR_RF);
 			return true;
 		case MI_RHINO:
@ -4839,15 +4839,15 @@ CPed::GetNearestPassengerDoor(CVehicle *veh, CVector &posToOpen)

 	CVector2D nextToCompare = rfPosDist;
 	posToOpen = rfPos;
-	m_vehDoor = CAR_DOOR_RF;
+	m_vehEnterType = CAR_DOOR_RF;
 	if (lrPosDist.MagnitudeSqr() < nextToCompare.MagnitudeSqr()) {
-		m_vehDoor = CAR_DOOR_LR;
+		m_vehEnterType = CAR_DOOR_LR;
 		posToOpen = lrPos;
 		nextToCompare = lrPosDist;
 	}

 	if (rrPosDist.MagnitudeSqr() < nextToCompare.MagnitudeSqr()) {
-		m_vehDoor = CAR_DOOR_RR;
+		m_vehEnterType = CAR_DOOR_RR;
 		posToOpen = rrPos;
 	}
 	return canEnter;
@ -4870,7 +4870,7 @@ void CPed::PedSetGetInCarPositionCB(CAnimBlendAssociation* assoc, void* arg)
 	CPed* pPed = (CPed*)arg;
 	CMatrix mat(pPed->GetMatrix());
 	CVehicle* pVehicle = pPed->m_pMyVehicle;
-	const CVector& offset = (pVehicle->bIsVan && (pPed->m_vehDoor == CAR_DOOR_RR || pPed->m_vehDoor == CAR_DOOR_LR)) ? vecPedVanRearDoorAnimOffset : vecPedCarDoorAnimOffset;
+	const CVector& offset = (pVehicle->bIsVan && (pPed->m_vehEnterType == CAR_DOOR_RR || pPed->m_vehEnterType == CAR_DOOR_LR)) ? vecPedVanRearDoorAnimOffset : vecPedCarDoorAnimOffset;
 	CVector position = Multiply3x3(mat, offset) + pPed->GetPosition();
 	CPedPlacement::FindZCoorForPed(&position);
 	pPed->SetMoveSpeed(0.0f, 0.0f, 0.0f);
@ -5054,7 +5054,7 @@ CPed::PedSetQuickDraggedOutCarPositionCB(CAnimBlendAssociation *animAssoc, void
 	ped->bUsesCollision = true;
 	ped->RestartNonPartialAnims();
 	draggedOutOffset = vecPedQuickDraggedOutCarAnimOffset;
-	if (ped->m_vehDoor == CAR_DOOR_RF || ped->m_vehDoor == CAR_DOOR_RR)
+	if (ped->m_vehEnterType == CAR_DOOR_RF || ped->m_vehEnterType == CAR_DOOR_RR)
 		draggedOutOffset.x = -draggedOutOffset.x;

 	finalPos = Multiply3x3(pedMat, draggedOutOffset) + ped->GetPosition();
@ -5067,7 +5067,7 @@ CPed::PedSetQuickDraggedOutCarPositionCB(CAnimBlendAssociation *animAssoc, void
 		ped->m_fRotationCur = ped->m_fRotationDest;
 		ped->CalculateNewOrientation();

-		if (!veh->IsRoomForPedToLeaveCar(ped->m_vehDoor, &vecPedQuickDraggedOutCarAnimOffset))
+		if (!veh->IsRoomForPedToLeaveCar(ped->m_vehEnterType, &vecPedQuickDraggedOutCarAnimOffset))
 			ped->PositionPedOutOfCollision();
 	}

@ -5158,7 +5158,7 @@ CPed::PedSetDraggedOutCarPositionCB(CAnimBlendAssociation* animAssoc, void* arg)
 	} else {
 		draggedOutOffset = vecPedDraggedOutCarAnimOffset;
 	}
-	if (ped->m_vehDoor == CAR_DOOR_RF || ped->m_vehDoor == CAR_DOOR_RR)
+	if (ped->m_vehEnterType == CAR_DOOR_RF || ped->m_vehEnterType == CAR_DOOR_RR)
 		draggedOutOffset.x = -draggedOutOffset.x;

 	CVector posAfterBeingDragged = Multiply3x3(pedMat, draggedOutOffset);
@ -5167,7 +5167,7 @@ CPed::PedSetDraggedOutCarPositionCB(CAnimBlendAssociation* animAssoc, void* arg)
 	ped->m_vecMoveSpeed = CVector(0.0f, 0.0f, 0.0f);
 	ped->SetPosition(posAfterBeingDragged);

-	if (ped->m_pMyVehicle && !ped->m_pMyVehicle->IsBike() && !ped->m_pMyVehicle->IsRoomForPedToLeaveCar(ped->m_vehDoor, &vecPedDraggedOutCarAnimOffset)) {
+	if (ped->m_pMyVehicle && !ped->m_pMyVehicle->IsBike() && !ped->m_pMyVehicle->IsRoomForPedToLeaveCar(ped->m_vehEnterType, &vecPedDraggedOutCarAnimOffset)) {
 		ped->PositionPedOutOfCollision();
 	}

@ -5235,7 +5235,7 @@ CPed::GetNearestTrainDoor(CVehicle *train, CVector &doorPos)
 	CVehicleModelInfo* trainModel = (CVehicleModelInfo*)CModelInfo::GetModelInfo(train->m_modelIndex);
 	CMatrix trainMat = CMatrix(train->GetMatrix());

-	doorPos = trainModel->m_positions[m_vehDoor];
+	doorPos = trainModel->m_positions[m_vehEnterType];
 	doorPos.x -= 1.5f;
 	doorPos = Multiply3x3(trainMat, doorPos);
 	doorPos += train->GetPosition();
@ -5286,17 +5286,17 @@ CPed::GetNearestTrainPedPosition(CVehicle *train, CVector &enterPos)
 	if (distMidEntry < distLeftEntry) {
 		if (distMidEntry < distRightEntry) {
 			enterPos = midEntryPos;
-			m_vehDoor = TRAIN_POS_MID_ENTRY;
+			m_vehEnterType = TRAIN_POS_MID_ENTRY;
 		} else {
 			enterPos = rightEntryPos;
-			m_vehDoor = TRAIN_POS_RIGHT_ENTRY;
+			m_vehEnterType = TRAIN_POS_RIGHT_ENTRY;
 		}
 	} else if (distRightEntry < distLeftEntry) {
 		enterPos = rightEntryPos;
-		m_vehDoor = TRAIN_POS_RIGHT_ENTRY;
+		m_vehEnterType = TRAIN_POS_RIGHT_ENTRY;
 	} else {
 		enterPos = leftEntryPos;
-		m_vehDoor = TRAIN_POS_LEFT_ENTRY;
+		m_vehEnterType = TRAIN_POS_LEFT_ENTRY;
 	}

 	return 1;
@ -6075,7 +6075,7 @@ CPed::SeekBoatPosition(void)
 		m_vecSeekPos = boatMat * enterOffset;
 		if (Seek()) {
 			// We arrived to the boat
-			m_vehDoor = 0;
+			m_vehEnterType = 0;
 			SetEnterCar(m_carInObjective, 0);
 		}
 	} else
@ -6212,9 +6212,9 @@ CPed::PositionPedOutOfCollision(void)
 				foundAPos = true;
 		}

-	} else if (m_vehDoor != 0) {
+	} else if (m_vehEnterType != 0) {
 		// Try the normal way
-		CVector pos = GetPositionToOpenCarDoor(m_pMyVehicle, m_vehDoor);
+		CVector pos = GetPositionToOpenCarDoor(m_pMyVehicle, m_vehEnterType);
 		newPos = pos;
 		GetMatrix().SetTranslate(newPos);
 		if (!CheckCollision()) {
@ -6224,7 +6224,7 @@ CPed::PositionPedOutOfCollision(void)
 	}

 	float vehRelativeExitX = vehCol->boundingBox.min.x - 0.355f;
-	if (m_vehDoor == CAR_DOOR_RF || m_vehDoor == CAR_DOOR_RR)
+	if (m_vehEnterType == CAR_DOOR_RF || m_vehEnterType == CAR_DOOR_RR)
 		vehRelativeExitX = 0.355f + vehCol->boundingBox.max.x;

 	if (!foundAPos) {
@ -6545,19 +6545,19 @@ CPed::KillCharOnFootArmed(CVector &ourPos, CVector &targetPos, CVector &distWith
 						if (m_nPedType == PEDTYPE_COP || vehOfTarget->bIsBus) {
 							GoToNearestDoor(vehOfTarget);
 						} else {
-							m_vehDoor = 0;
+							m_vehEnterType = 0;
 							if (m_pedInObjective == vehOfTarget->pDriver || vehOfTarget->bIsBus) {
-								m_vehDoor = CAR_DOOR_LF;
+								m_vehEnterType = CAR_DOOR_LF;
 							} else if (m_pedInObjective == vehOfTarget->pPassengers[0]) {
-								m_vehDoor = CAR_DOOR_RF;
+								m_vehEnterType = CAR_DOOR_RF;
 							} else if (m_pedInObjective == vehOfTarget->pPassengers[1]) {
-								m_vehDoor = CAR_DOOR_LR;
+								m_vehEnterType = CAR_DOOR_LR;
 							} else if (m_pedInObjective == vehOfTarget->pPassengers[2]) {
-								m_vehDoor = CAR_DOOR_RR;
+								m_vehEnterType = CAR_DOOR_RR;
 							}
 							// Unused
-							// GetPositionToOpenCarDoor(vehOfTarget, m_vehDoor);
-							SetSeekCar(vehOfTarget, m_vehDoor);
+							// GetPositionToOpenCarDoor(vehOfTarget, m_vehEnterType);
+							SetSeekCar(vehOfTarget, m_vehEnterType);
 							SetMoveState(PEDMOVE_RUN);
 						}
 					}
@ -6835,19 +6835,19 @@ CPed::KillCharOnFootMelee(CVector &ourPos, CVector &targetPos, CVector &distWith
 						if (m_nPedType == PEDTYPE_COP || vehOfTarget->bIsBus) {
 							GoToNearestDoor(vehOfTarget);
 						} else {
-							m_vehDoor = 0;
+							m_vehEnterType = 0;
 							if (m_pedInObjective == vehOfTarget->pDriver || vehOfTarget->bIsBus) {
-								m_vehDoor = CAR_DOOR_LF;
+								m_vehEnterType = CAR_DOOR_LF;
 							} else if (m_pedInObjective == vehOfTarget->pPassengers[0]) {
-								m_vehDoor = CAR_DOOR_RF;
+								m_vehEnterType = CAR_DOOR_RF;
 							} else if (m_pedInObjective == vehOfTarget->pPassengers[1]) {
-								m_vehDoor = CAR_DOOR_LR;
+								m_vehEnterType = CAR_DOOR_LR;
 							} else if (m_pedInObjective == vehOfTarget->pPassengers[2]) {
-								m_vehDoor = CAR_DOOR_RR;
+								m_vehEnterType = CAR_DOOR_RR;
 							}
 							// Unused
-							// GetPositionToOpenCarDoor(vehOfTarget, m_vehDoor);
-							SetSeekCar(vehOfTarget, m_vehDoor);
+							// GetPositionToOpenCarDoor(vehOfTarget, m_vehEnterType);
+							SetSeekCar(vehOfTarget, m_vehEnterType);
 							SetMoveState(PEDMOVE_RUN);
 						}
 					}
--- a/src/peds/PedFight.cpp
+++ b/src/peds/PedFight.cpp
@ -2418,7 +2418,7 @@ CPed::SetInvestigateEvent(eEventType event, CVector2D pos, float distanceToCount
 	SetStoredState();
 	bFindNewNodeAfterStateRestore = false;
 	SetPedState(PED_INVESTIGATE);
-	m_chatTimer = CTimer::GetTimeInMilliseconds() + time;
+	m_standardTimer = CTimer::GetTimeInMilliseconds() + time;
 	m_eventType = event;
 	m_eventOrThreat = pos;
 	m_distanceToCountSeekDone = distanceToCountDone;
@ -2442,13 +2442,13 @@ CPed::InvestigateEvent(void)
 	if (m_nWaitState == WAITSTATE_TURN180)
 		return;

-	if (CTimer::GetTimeInMilliseconds() > m_chatTimer) {
+	if (CTimer::GetTimeInMilliseconds() > m_standardTimer) {

-		if (m_chatTimer) {
+		if (m_standardTimer) {
 			if (m_eventType < EVENT_UNK)
 				SetWaitState(WAITSTATE_TURN180, nil);

-			m_chatTimer = 0;
+			m_standardTimer = 0;
 		} else {
 			ClearInvestigateEvent();
 		}
@ -2509,7 +2509,7 @@ CPed::InvestigateEvent(void)
 							Say(SOUND_PED_CHAT_EVENT);

 					} else {
-						m_chatTimer = 0;
+						m_standardTimer = 0;
 					}

 				} else if (CTimer::GetTimeInMilliseconds() > m_lookTimer) {
@ -2653,7 +2653,7 @@ CPed::ClearInvestigateEvent(void)
 		animAssoc->flags |= ASSOC_DELETEFADEDOUT;
 	}
 	if (m_eventType > EVENT_EXPLOSION)
-		m_chatTimer = CTimer::GetTimeInMilliseconds() + 15000;
+		m_standardTimer = CTimer::GetTimeInMilliseconds() + 15000;

 	bGonnaInvestigateEvent = false;
 	m_pEventEntity = nil;
--- a/src/render/Font.cpp
+++ b/src/render/Font.cpp
@ -274,13 +274,13 @@ CFont::Initialise(void)
 	SetScale(1.0f, 1.0f);
 	SetSlantRefPoint(SCREEN_WIDTH, 0.0f);
 	SetSlant(0.0f);
-	SetColor(CRGBA(255, 255, 255, 0));
+	SetColor(CRGBA(0xFF, 0xFF, 0xFF, 0));
 	SetJustifyOff();
 	SetCentreOff();
 	SetWrapx(SCREEN_WIDTH);
 	SetCentreSize(SCREEN_WIDTH);
 	SetBackgroundOff();
-	SetBackgroundColor(CRGBA(128, 128, 128, 128));
+	SetBackgroundColor(CRGBA(0x80, 0x80, 0x80, 0x80));
 	SetBackGroundOnlyTextOff();
 	SetPropOn();
 	SetFontStyle(FONT_BANK);
@ -614,10 +614,10 @@ CFont::PrintString(float xstart, float ystart, wchar *s)
 						x = xstart;
 #ifdef MORE_LANGUAGES
 					if (IsJapaneseFont())
-						y += 32.0f * Details.scaleY / 2.75f + 2.0f * Details.scaleY;
+						y += 32.0f * CFont::Details.scaleY / 2.75f + 2.0f * CFont::Details.scaleY;
 					else
 #endif
-						y += 32.0f * Details.scaleY * 0.5f + 2.0f * Details.scaleY;
+						y += 32.0f * CFont::Details.scaleY * 0.5f + 2.0f * CFont::Details.scaleY;
 					start = s;
 				}else
 					break;
@ -653,7 +653,7 @@ CFont::PrintString(float xstart, float ystart, wchar *s)
 					else
 						x = 0.0f;

-					y += 32.0f * Details.scaleY / 2.75f + 2.0f * Details.scaleY;
+					y += 32.0f * CFont::Details.scaleY / 2.75f + 2.0f * CFont::Details.scaleY;
 					numSpaces = 0;
 					first = true;
 					lineLength = 0.0f;
@ -676,7 +676,7 @@ CFont::PrintString(float xstart, float ystart, wchar *s)
 				x = xstart;
 			else
 				x = 0.0f;
-			y += 32.0f * Details.scaleY / 2.75f + 2.0f * Details.scaleY;
+			y += 32.0f * CFont::Details.scaleY / 2.75f + 2.0f * CFont::Details.scaleY;
 			numSpaces = 0;
 			first = true;
 			lineLength = 0.0f;
@ -753,10 +753,10 @@ CFont::GetNumberLines(float xstart, float ystart, wchar *s)
 			// Why even?
 #ifdef MORE_LANGUAGES
 			if (IsJapanese())
-				y += 32.0f * Details.scaleY / 2.75f + 2.0f * Details.scaleY;
+				y += 32.0f * CFont::Details.scaleY / 2.75f + 2.0f * CFont::Details.scaleY;
 			else
 #endif
-				y += 32.0f * Details.scaleY * 0.5f + 2.0f * Details.scaleY;
+				y += 32.0f * CFont::Details.scaleY * 0.5f + 2.0f * CFont::Details.scaleY;
 		}else{
 			// still space in current line
 			t = GetNextSpace(s);
@ -827,7 +827,7 @@ CFont::GetTextRect(CRect *rect, float xstart, float ystart, wchar *s)
 				else
 					x = xstart;
 				numLines++;
-				y += 32.0f * Details.scaleY * 0.5f + 2.0f * Details.scaleY;
+				y += 32.0f * CFont::Details.scaleY * 0.5f + 2.0f * CFont::Details.scaleY;
 			}else{
 				// still space in current line
 				t = GetNextSpace(s);
@ -855,11 +855,11 @@ CFont::GetTextRect(CRect *rect, float xstart, float ystart, wchar *s)
 			rect->right = xstart + maxlength/2 + 4.0f;
 #ifdef MORE_LANGUAGES
 			if (IsJapaneseFont()) {
-				rect->bottom = (32.0f * Details.scaleY / 2.75f + 2.0f * Details.scaleY) * numLines + ystart + (4.0f / 2.75f);
+				rect->bottom = (32.0f * CFont::Details.scaleY / 2.75f + 2.0f * CFont::Details.scaleY) * numLines + ystart + (4.0f / 2.75f);
 				rect->top = ystart - (4.0f / 2.75f);
 			} else {
 #endif
-				rect->bottom = (32.0f * Details.scaleY * 0.5f + 2.0f * Details.scaleY) * numLines + ystart + 2.0f;
+				rect->bottom = (32.0f * CFont::Details.scaleY * 0.5f + 2.0f * CFont::Details.scaleY) * numLines + ystart + 2.0f;
 				rect->top = ystart - 2.0f;
 #ifdef MORE_LANGUAGES
 			}
@ -869,11 +869,11 @@ CFont::GetTextRect(CRect *rect, float xstart, float ystart, wchar *s)
 			rect->right = xstart + Details.centreSize*0.5f + 4.0f;
 #ifdef MORE_LANGUAGES
 			if (IsJapaneseFont()) {
-				rect->bottom = (32.0f * Details.scaleY / 2.75f + 2.0f * Details.scaleY) * numLines + ystart + (4.0f / 2.75f);
+				rect->bottom = (32.0f * CFont::Details.scaleY / 2.75f + 2.0f * CFont::Details.scaleY) * numLines + ystart + (4.0f / 2.75f);
 				rect->top = ystart - (4.0f / 2.75f);
 			} else {
 #endif
-				rect->bottom = (32.0f * Details.scaleY * 0.5f + 2.0f * Details.scaleY) * numLines + ystart + 2.0f;
+				rect->bottom = (32.0f * CFont::Details.scaleY * 0.5f + 2.0f * CFont::Details.scaleY) * numLines + ystart + 2.0f;
 				rect->top = ystart - 2.0f;
 #ifdef MORE_LANGUAGES
 			}
@ -886,10 +886,10 @@ CFont::GetTextRect(CRect *rect, float xstart, float ystart, wchar *s)
 		rect->bottom = ystart - 4.0f + 4.0f;
 #ifdef MORE_LANGUAGES
 		if (IsJapaneseFont())
-			rect->top = (32.0f * Details.scaleY / 2.75f + 2.0f * Details.scaleY) * numLines + ystart + 2.0f + (4.0f / 2.75f);
+			rect->top = (32.0f * CFont::Details.scaleY / 2.75f + 2.0f * CFont::Details.scaleY) * numLines + ystart + 2.0f + (4.0f / 2.75f);
 		else
 #endif
-			rect->top = (32.0f * Details.scaleY * 0.5f + 2.0f * Details.scaleY) * numLines + ystart + 2.0f + 2.0f;
+			rect->top = (32.0f * CFont::Details.scaleY * 0.5f + 2.0f * CFont::Details.scaleY) * numLines + ystart + 2.0f + 2.0f;
 	}
 }

@ -1315,89 +1315,27 @@ CFont::ParseToken(wchar *s)
 		case 'n':
 			NewLine = 1;
 			break;
-		case 'b':
-			Details.color.r = 27;
-			Details.color.g = 89;
-			Details.color.b = 130;
-			Details.anonymous_23 = true;
-			break;
+		case 'b': SetColor(CRGBA(27, 89, 130, 255)); Details.anonymous_23 = true; break;
 		case 'f':
 			Details.bFlash = !Details.bFlash;
 			if (!Details.bFlash)
 				Details.color.a = 255;
 			break;
-		case 'g':
-			Details.color.r = 255;
-			Details.color.g = 150;
-			Details.color.b = 225;
-			Details.anonymous_23 = true;
-			break;
-		case 'h':
-			Details.color.r = 225;
-			Details.color.g = 225;
-			Details.color.b = 225;
-			Details.anonymous_23 = true;
-			break;
-		case 'l':
-			Details.color.r = 0;
-			Details.color.g = 0;
-			Details.color.b = 0;
-			Details.anonymous_23 = true;
-			break;
-		case 'o':
-			Details.color.r = 229;
-			Details.color.g = 125;
-			Details.color.b = 126;
-			Details.anonymous_23 = true;
-			break;
-		case 'p':
-			Details.color.r = 168;
-			Details.color.g = 110;
-			Details.color.b = 252;
-			Details.anonymous_23 = true;
-			break;
-		case 'q':
-			Details.color.r = 199;
-			Details.color.g = 144;
-			Details.color.b = 203;
-			Details.anonymous_23 = true;
-			break;
-		case 'r':
-			Details.color.r = 255;
-			Details.color.g = 150;
-			Details.color.b = 225;
-			Details.anonymous_23 = true;
-			break;
-		case 't':
-			Details.color.r = 86;
-			Details.color.g = 212;
-			Details.color.b = 146;
-			Details.anonymous_23 = true;
-			break;
-		case 'w':
-			Details.color.r = 175;
-			Details.color.g = 175;
-			Details.color.b = 175;
-			Details.anonymous_23 = true;
-			break;
-		case 'x':
+		case 'g': SetColor(CRGBA(255, 150, 225, 255)); Details.anonymous_23 = true; break;
+		case 'h': SetColor(CRGBA(225, 225, 225, 255)); Details.anonymous_23 = true; break;
+		case 'l': SetColor(CRGBA(0, 0, 0, 255)); Details.anonymous_23 = true; break;
+		case 'o': SetColor(CRGBA(229, 125, 126, 255)); Details.anonymous_23 = true; break;
+		case 'p': SetColor(CRGBA(168, 110, 252, 255)); Details.anonymous_23 = true; break;
+		case 'q': SetColor(CRGBA(199, 144, 203, 255)); Details.anonymous_23 = true; break;
+		case 'r': SetColor(CRGBA(255, 150, 225, 255)); Details.anonymous_23 = true; break;
+		case 't': SetColor(CRGBA(86, 212, 146, 255)); Details.anonymous_23 = true; break;
+		case 'w': SetColor(CRGBA(175, 175, 175, 255)); Details.anonymous_23 = true; break;
 #ifdef FIX_BUGS
-			Details.color.r = 0;
-			Details.color.g = 255;
-			Details.color.b = 255;
+		case 'x': SetColor(CRGBA(0, 255, 255, 255)); Details.anonymous_23 = true; break;
 #else
-			Details.color.r = 132;
-			Details.color.g = 146;
-			Details.color.b = 197;
+		case 'x': SetColor(CRGBA(132, 146, 197, 255)); Details.anonymous_23 = true; break;
 #endif
-			Details.anonymous_23 = true;
-			break;
-		case 'y':
-			Details.color.r = 255;
-			Details.color.g = 227;
-			Details.color.b = 79;
-			Details.anonymous_23 = true;
-			break;
+		case 'y': SetColor(CRGBA(255, 227, 79, 255)); Details.anonymous_23 = true; break;
 #ifdef BUTTON_ICONS
 		case 'U': PS2Symbol = BUTTON_UP; break;
 		case 'D': PS2Symbol = BUTTON_DOWN; break;
@ -1604,7 +1542,7 @@ CFont::RenderFontBuffer()
 		if (RenderState.bFontHalfTexture) 
 			c = FindNewCharacter(c); 
 		else if (c > 155) 
-			c = '\0'; 
+			c = 0; 

 		if (RenderState.slant != 0.0f)
 			textPosY = (RenderState.slantRefX - textPosX) * RenderState.slant + RenderState.slantRefY;
@ -1618,7 +1556,7 @@ CFont::RenderFontBuffer()
 		// PS2 uses different chars for some symbols
 		if (!RenderState.bFontHalfTexture && c == 30) c = 61; // wanted star
 #endif
-		textPosX += RenderState.scaleX * GetCharacterWidth(c);
+		textPosX += RenderState.scaleX * (RenderState.proportional ? Size[RenderState.style][c] : Size[RenderState.style][209]);
 		if (c == '\0')
 			textPosX += RenderState.fExtraSpace;
 	}
--- a/src/render/MBlur.cpp
+++ b/src/render/MBlur.cpp
@ -442,7 +442,7 @@ CMBlur::OverlayRender(RwCamera *cam, RwRaster *raster, RwRGBA color, int32 type,
 			RwIm2DVertexSetIntRGBA(&Vertex2[3], r, g, b, 80);
 			RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
 			RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
-			pBufVertCount = 0;
+			// TODO(MIAMI): pBufVertCount = 0;
 		}else{
 			RwIm2DVertexSetIntRGBA(&Vertex2[0], r*2, g*2, b*2, 30);
 			RwIm2DVertexSetIntRGBA(&Vertex2[1], r*2, g*2, b*2, 30);
--- a/src/render/WaterLevel.cpp
+++ b/src/render/WaterLevel.cpp
@ -113,9 +113,9 @@ float fMinWaterAlphaMult      = -30.0f;


 void
-CWaterLevel::Initialise(Const char *pWaterDat)
+WaterLevelInitialise(Const char *pWaterDat)
 {
-	ms_nNoOfWaterLevels = 0;
+	CWaterLevel::ms_nNoOfWaterLevels = 0;
 	
 #ifdef MASTER
 	int32 hFile = -1;
@ -131,11 +131,11 @@ CWaterLevel::Initialise(Const char *pWaterDat)
 	
 	if (hFile > 0)
 	{
-		CFileMgr::Read(hFile, (char *)&ms_nNoOfWaterLevels, sizeof(ms_nNoOfWaterLevels));
-		CFileMgr::Read(hFile, (char *)ms_aWaterZs,	sizeof(ms_aWaterZs));
-		CFileMgr::Read(hFile, (char *)ms_aWaterRects, sizeof(ms_aWaterRects));
-		CFileMgr::Read(hFile, (char *)aWaterBlockList, sizeof(aWaterBlockList));
-		CFileMgr::Read(hFile, (char *)aWaterFineBlockList, sizeof(aWaterFineBlockList));
+		CFileMgr::Read(hFile, (char *)&CWaterLevel::ms_nNoOfWaterLevels, sizeof(CWaterLevel::ms_nNoOfWaterLevels));
+		CFileMgr::Read(hFile, (char *)CWaterLevel::ms_aWaterZs,	sizeof(CWaterLevel::ms_aWaterZs));
+		CFileMgr::Read(hFile, (char *)CWaterLevel::ms_aWaterRects, sizeof(CWaterLevel::ms_aWaterRects));
+		CFileMgr::Read(hFile, (char *)CWaterLevel::aWaterBlockList, sizeof(CWaterLevel::aWaterBlockList));
+		CFileMgr::Read(hFile, (char *)CWaterLevel::aWaterFineBlockList, sizeof(CWaterLevel::aWaterFineBlockList));
 		CFileMgr::CloseFile(hFile);
 	}
 #ifndef MASTER
@ -157,7 +157,7 @@ CWaterLevel::Initialise(Const char *pWaterDat)
 			{
 				float z, l, b, r, t;
 				sscanf(line, "%f %f %f %f %f", &z, &l, &b, &r, &t);
-				AddWaterLevel(l, b, r, t, z);
+				CWaterLevel::AddWaterLevel(l, b, r, t, z);
 			}
 		}

@ -167,17 +167,17 @@ CWaterLevel::Initialise(Const char *pWaterDat)
 		{
 			for (int32 y = 0; y < MAX_SMALL_SECTORS; y++)
 			{
-				aWaterFineBlockList[x][y] = NO_WATER;
+				CWaterLevel::aWaterFineBlockList[x][y] = NO_WATER;
 			}
 		}

 		// rasterize water rects read from file
-		for (int32 i = 0; i < ms_nNoOfWaterLevels; i++)
+		for (int32 i = 0; i < CWaterLevel::ms_nNoOfWaterLevels; i++)
 		{
-			int32 l = WATER_HUGE_X(ms_aWaterRects[i].left + WATER_X_OFFSET);
-			int32 r = WATER_HUGE_X(ms_aWaterRects[i].right + WATER_X_OFFSET) + 1.0f;
-			int32 t = WATER_HUGE_Y(ms_aWaterRects[i].top);
-			int32 b = WATER_HUGE_Y(ms_aWaterRects[i].bottom) + 1.0f;
+			int32 l = WATER_HUGE_X(CWaterLevel::ms_aWaterRects[i].left + WATER_X_OFFSET);
+			int32 r = WATER_HUGE_X(CWaterLevel::ms_aWaterRects[i].right + WATER_X_OFFSET) + 1.0f;
+			int32 t = WATER_HUGE_Y(CWaterLevel::ms_aWaterRects[i].top);
+			int32 b = WATER_HUGE_Y(CWaterLevel::ms_aWaterRects[i].bottom) + 1.0f;

 			l = clamp(l, 0, MAX_SMALL_SECTORS - 1);
 			r = clamp(r, 0, MAX_SMALL_SECTORS - 1);
@ -188,7 +188,7 @@ CWaterLevel::Initialise(Const char *pWaterDat)
 			{
 				for (int32 y = t; y <= b; y++)
 				{
-					aWaterFineBlockList[x][y] = i;
+					CWaterLevel::aWaterFineBlockList[x][y] = i;
 				}
 			}
 		}
@ -209,10 +209,10 @@ CWaterLevel::Initialise(Const char *pWaterDat)
 					{
 						for (int32 j = 0; j <= 8; j++)
 						{
-							CVector worldPos = CVector(worldX + i * (SMALL_SECTOR_SIZE / 8), worldY + j * (SMALL_SECTOR_SIZE / 8), ms_aWaterZs[aWaterFineBlockList[x][y]]);
+							CVector worldPos = CVector(worldX + i * (SMALL_SECTOR_SIZE / 8), worldY + j * (SMALL_SECTOR_SIZE / 8), CWaterLevel::ms_aWaterZs[CWaterLevel::aWaterFineBlockList[x][y]]);

 							if ((worldPos.x > WORLD_MIN_X && worldPos.x < WORLD_MAX_X) && (worldPos.y > WORLD_MIN_Y && worldPos.y < WORLD_MAX_Y) &&
-								(!WaterLevelAccordingToRectangles(worldPos.x, worldPos.y) || TestVisibilityForFineWaterBlocks(worldPos)))
+								(!CWaterLevel::WaterLevelAccordingToRectangles(worldPos.x, worldPos.y) || CWaterLevel::TestVisibilityForFineWaterBlocks(worldPos)))
 								continue;

 							// at least one point in the tile wasn't blocked, so don't remove water
@ -222,37 +222,37 @@ CWaterLevel::Initialise(Const char *pWaterDat)
 					}

 					if (i < 1000)
-						aWaterFineBlockList[x][y] = NO_WATER;
+						CWaterLevel::aWaterFineBlockList[x][y] = NO_WATER;
 				}
 			}
 		}

-		RemoveIsolatedWater();
+		CWaterLevel::RemoveIsolatedWater();

 		// calculate coarse tiles from fine tiles
 		for (int32 x = 0; x < MAX_LARGE_SECTORS; x++)
 		{
 			for (int32 y = 0; y < MAX_LARGE_SECTORS; y++)
 			{
-				if (aWaterFineBlockList[x * 2][y * 2] >= 0)
+				if (CWaterLevel::aWaterFineBlockList[x * 2][y * 2] >= 0)
 				{
-					aWaterBlockList[x][y] = aWaterFineBlockList[x * 2][y * 2];
+					CWaterLevel::aWaterBlockList[x][y] = CWaterLevel::aWaterFineBlockList[x * 2][y * 2];
 				}
-				else if (aWaterFineBlockList[x * 2 + 1][y * 2] >= 0)
+				else if (CWaterLevel::aWaterFineBlockList[x * 2 + 1][y * 2] >= 0)
 				{
-					aWaterBlockList[x][y] = aWaterFineBlockList[x * 2 + 1][y * 2];
+					CWaterLevel::aWaterBlockList[x][y] = CWaterLevel::aWaterFineBlockList[x * 2 + 1][y * 2];
 				}
-				else if (aWaterFineBlockList[x * 2][y * 2 + 1] >= 0)
+				else if (CWaterLevel::aWaterFineBlockList[x * 2][y * 2 + 1] >= 0)
 				{
-					aWaterBlockList[x][y] = aWaterFineBlockList[x * 2][y * 2 + 1];
+					CWaterLevel::aWaterBlockList[x][y] = CWaterLevel::aWaterFineBlockList[x * 2][y * 2 + 1];
 				}
-				else if (aWaterFineBlockList[x * 2 + 1][y * 2 + 1] >= 0)
+				else if (CWaterLevel::aWaterFineBlockList[x * 2 + 1][y * 2 + 1] >= 0)
 				{
-					aWaterBlockList[x][y] = aWaterFineBlockList[x * 2 + 1][y * 2 + 1];
+					CWaterLevel::aWaterBlockList[x][y] = CWaterLevel::aWaterFineBlockList[x * 2 + 1][y * 2 + 1];
 				}
 				else
 				{
-					aWaterBlockList[x][y] = NO_WATER;
+					CWaterLevel::aWaterBlockList[x][y] = NO_WATER;
 				}
 			}
 		}
@ -261,11 +261,11 @@ CWaterLevel::Initialise(Const char *pWaterDat)

 		if (hFile > 0)
 		{
-			CFileMgr::Write(hFile, (char *)&ms_nNoOfWaterLevels, sizeof(ms_nNoOfWaterLevels));
-			CFileMgr::Write(hFile, (char *)ms_aWaterZs, sizeof(ms_aWaterZs));
-			CFileMgr::Write(hFile, (char *)ms_aWaterRects, sizeof(ms_aWaterRects));
-			CFileMgr::Write(hFile, (char *)aWaterBlockList, sizeof(aWaterBlockList));
-			CFileMgr::Write(hFile, (char *)aWaterFineBlockList, sizeof(aWaterFineBlockList));
+			CFileMgr::Write(hFile, (char *)&CWaterLevel::ms_nNoOfWaterLevels, sizeof(CWaterLevel::ms_nNoOfWaterLevels));
+			CFileMgr::Write(hFile, (char *)CWaterLevel::ms_aWaterZs, sizeof(CWaterLevel::ms_aWaterZs));
+			CFileMgr::Write(hFile, (char *)CWaterLevel::ms_aWaterRects, sizeof(CWaterLevel::ms_aWaterRects));
+			CFileMgr::Write(hFile, (char *)CWaterLevel::aWaterBlockList, sizeof(CWaterLevel::aWaterBlockList));
+			CFileMgr::Write(hFile, (char *)CWaterLevel::aWaterFineBlockList, sizeof(CWaterLevel::aWaterFineBlockList));

 			CFileMgr::CloseFile(hFile);
 		}
@ -300,7 +300,7 @@ CWaterLevel::Initialise(Const char *pWaterDat)
 	
 	CTxdStore::PopCurrentTxd();

-	CreateWavyAtomic();
+	CWaterLevel::CreateWavyAtomic();
 	
 	printf("Done Initing waterlevels\n");
 }
--- a/src/render/WaterLevel.h
+++ b/src/render/WaterLevel.h
@ -116,7 +116,6 @@ public:
 	static RpAtomic    *ms_pWavyAtomic;
 	static RpAtomic    *ms_pMaskAtomic;

-	static void    Initialise(Const char *pWaterDat); // out of class in III PC and later because of SecuROM
 	static void    Shutdown();

 	static void    CreateWavyAtomic();
@ -182,3 +181,5 @@ public:
 	static void HandleBeachToysStuff(void);
 	static CEntity *CreateBeachToy(CVector const &vec, eBeachToy beachtoy);
 };
+
+extern void WaterLevelInitialise(Const char *datFile);
--- a/src/rw/MemoryMgr.cpp
+++ b/src/rw/MemoryMgr.cpp
@ -93,7 +93,7 @@ MemoryMgrFree(void *ptr)
 void *
 RwMallocAlign(RwUInt32 size, RwUInt32 align)
 {
-#if defined (FIX_BUGS) || defined(FIX_BUGS_64)
+#ifdef FIX_BUGS
 	uintptr ptralign = align-1;
 	void *mem = (void *)MemoryMgrMalloc(size + sizeof(uintptr) + ptralign);

--- a/src/rw/RwHelper.cpp
+++ b/src/rw/RwHelper.cpp
@ -255,8 +255,7 @@ SkinGetBonePositionsToTable(RpClump *clump, RwV3d *boneTable)
 			parent = stack[sp--];
 		else
 			parent = i;
-
-		//assert(parent >= 0 && parent < numBones);
+		assert(parent >= 0 && parent < numBones);
 	}
 }

@ -264,7 +263,7 @@ RpHAnimAnimation*
 HAnimAnimationCreateForHierarchy(RpHAnimHierarchy *hier)
 {
 	int i;
-#if defined FIX_BUGS || defined LIBRW
+#ifdef FIX_BUGS
 	int numNodes = hier->numNodes*2;	// you're supposed to have at least two KFs per node
 #else
 	int numNodes = hier->numNodes;
@ -278,7 +277,7 @@ HAnimAnimationCreateForHierarchy(RpHAnimHierarchy *hier)
 		frame->q.real = 1.0f;
 		frame->q.imag.x = frame->q.imag.y = frame->q.imag.z = 0.0f;
 		frame->t.x = frame->t.y = frame->t.z = 0.0f;
-#if defined FIX_BUGS || defined LIBRW
+#ifdef FIX_BUGS
 		// times are subtracted and divided giving NaNs
 		// so they can't both be 0
 		frame->time = i/hier->numNodes;
@ -484,7 +483,7 @@ CameraSize(RwCamera * camera, RwRect * rect,
 			RwRaster           *zRaster;

 			// BUG: game just changes camera raster's sizes, but this is a hack
-#if defined FIX_BUGS || defined LIBRW
+#ifdef FIX_BUGS
 			/*
 			 * Destroy rasters...
 			 */
--- a/src/text/Text.cpp
+++ b/src/text/Text.cpp
@ -113,14 +113,14 @@ wchar*
 CText::Get(const char *key)
 {
 	uint8 result = false;
-#if defined (FIX_BUGS) || defined(FIX_BUGS_64)
+#ifdef FIX_BUGS
 	wchar *outstr = keyArray.Search(key, data.chars, &result);
 #else
 	wchar *outstr = keyArray.Search(key, &result);
 #endif

 	if (!result && bHasMissionTextOffsets && bIsMissionTextLoaded)
-#if defined (FIX_BUGS) || defined(FIX_BUGS_64)
+#ifdef FIX_BUGS
 		outstr = mission_keyArray.Search(key, mission_data.chars, &result);
 #else
 		outstr = mission_keyArray.Search(key, &result);
@ -347,7 +347,7 @@ CKeyArray::Unload(void)
 void
 CKeyArray::Update(wchar *chars)
 {
-#if !defined(FIX_BUGS) && !defined(FIX_BUGS_64)
+#ifndef FIX_BUGS
 	int i;
 	for(i = 0; i < numEntries; i++)
 		entries[i].value = (wchar*)((uint8*)chars + (uintptr)entries[i].value);
@ -375,7 +375,7 @@ CKeyArray::BinarySearch(const char *key, CKeyEntry *entries, int16 low, int16 hi
 }

 wchar*
-#if defined (FIX_BUGS) || defined(FIX_BUGS_64)
+#ifdef FIX_BUGS
 CKeyArray::Search(const char *key, wchar *data, uint8 *result)
 #else
 CKeyArray::Search(const char *key, uint8 *result)
@ -385,7 +385,7 @@ CKeyArray::Search(const char *key, uint8 *result)
 	char errstr[25];
 	int i;

-#if defined (FIX_BUGS) || defined(FIX_BUGS_64)
+#ifdef FIX_BUGS
 	found = BinarySearch(key, entries, 0, numEntries-1);
 	if (found) {
 		*result = true;
--- a/src/text/Text.h
+++ b/src/text/Text.h
@ -7,7 +7,7 @@ void TextCopy(wchar *dst, const wchar *src);

 struct CKeyEntry
 {
-#if defined(FIX_BUGS) || defined(FIX_BUGS_64)
+#ifdef FIX_BUGS
 	uint32 valueOffset;
 #else
 	wchar *value;
@ -30,7 +30,7 @@ public:
 	void Unload(void);
 	void Update(wchar *chars);
 	CKeyEntry *BinarySearch(const char *key, CKeyEntry *entries, int16 low, int16 high);
-#if defined (FIX_BUGS) || defined(FIX_BUGS_64)
+#ifdef FIX_BUGS
 	wchar *Search(const char *key, wchar *data, uint8 *result);
 #else
 	wchar *Search(const char *key, uint8* result);
--- a/src/vehicles/Automobile.cpp
+++ b/src/vehicles/Automobile.cpp
@ -5824,7 +5824,7 @@ CAutomobile::KnockPedOutCar(eWeaponType weapon, uint16 door, CPed *ped)
 	if(ped == nil)
 		return;

-	ped->m_vehDoor = door;
+	ped->m_vehEnterType = door;
 	ped->SetPedState(PED_IDLE);
 	CAnimManager::BlendAnimation(ped->GetClump(), ped->m_animGroup, ANIM_IDLE_STANCE, 100.0f);
 	CPed::PedSetOutCarCB(nil, ped);
--- a/src/vehicles/Bike.cpp
+++ b/src/vehicles/Bike.cpp
@ -2609,7 +2609,7 @@ CBike::KnockOffRider(eWeaponType weapon, uint8 direction, CPed *ped, bool bGetBa

 	ped->SetPedState(PED_IDLE);
 	CAnimManager::BlendAnimation(ped->GetClump(), ped->m_animGroup, ANIM_IDLE_STANCE, 100.0f);
-	ped->m_vehDoor = CAR_DOOR_LF;
+	ped->m_vehEnterType = CAR_DOOR_LF;
 	CPed::PedSetOutCarCB(nil, ped);
 	ped->SetMoveState(PEDMOVE_STILL);
 	if(GetUp().z < 0.0f)
--- a/src/vehicles/Cranes.h
+++ b/src/vehicles/Cranes.h
@ -88,7 +88,7 @@ public:
 	static bool IsThisCarBeingCarriedByAnyCrane(CVehicle* pVehicle);
 	static bool IsThisCarBeingTargettedByAnyCrane(CVehicle* pVehicle);
 	static void Save(uint8* buf, uint32* size);
-	static void Load(uint8* buf, uint32 size); // out of class in III PC and later because of SecuROM
+	static void Load(uint8* buf, uint32 size); // on mobile it's CranesLoad outside of the class

 	static uint32 CarsCollectedMilitaryCrane;
 	static int32 NumCranes;
--- a/src/vehicles/Heli.cpp
+++ b/src/vehicles/Heli.cpp
@ -762,7 +762,7 @@ CHeli::InitHelis(void)
 }

 CHeli*
-CHeli::GenerateHeli(bool catalina)
+GenerateHeli(bool catalina)
 {
 	CHeli *heli;
 	CVector heliPos;
@ -800,7 +800,7 @@ CHeli::GenerateHeli(bool catalina)
 		id++;
 		found = true;
 		for(i = 0; i < 4; i++)
-			if(pHelis[i] && pHelis[i]->m_nHeliId == id)
+			if(CHeli::pHelis[i] && CHeli::pHelis[i]->m_nHeliId == id)
 				found = false;
 	}
 	heli->m_nHeliId = id;
--- a/src/vehicles/Heli.h
+++ b/src/vehicles/Heli.h
@ -83,14 +83,13 @@ public:
 	bool SendDownSwat(void);

 	static void InitHelis(void);
-	static CHeli *GenerateHeli(bool catalina); // out of class in III PC and later because of SecuROM
 	static void UpdateHelis(void);
 	static void SpecialHeliPreRender(void);
 	static bool TestRocketCollision(CVector *coors);
 	static bool TestBulletCollision(CVector *line0, CVector *line1, CVector *bulletPos, int32 damage);
 	static bool TestSniperCollision(CVector *line0, CVector *line1);

-	static void StartCatalinaFlyBy(void); // out of class in III PC and later because of SecuROM
+	static void StartCatalinaFlyBy(void);
 	static void RemoveCatalinaHeli(void);
 	static CHeli *FindPointerToCatalinasHeli(void);
 	static void CatalinaTakeOff(void);
--- a/src/vehicles/Train.cpp
+++ b/src/vehicles/Train.cpp
@ -388,7 +388,7 @@ void
 CTrain::AddPassenger(CPed *ped)
 {
 #ifdef GTA_TRAIN
-	int i = ped->m_vehDoor;
+	int i = ped->m_vehEnterType;
 	if((i == TRAIN_POS_LEFT_ENTRY || i == TRAIN_POS_MID_ENTRY || i == TRAIN_POS_RIGHT_ENTRY) && pPassengers[i] == nil){
 		pPassengers[i] = ped;
 		m_nNumPassengers++;
--- a/src/vehicles/Vehicle.cpp
+++ b/src/vehicles/Vehicle.cpp
@ -1430,13 +1430,13 @@ CVehicle::ShufflePassengersToMakeSpace(void)
 		if (!pPassengers[2] && !(m_nGettingInFlags & CAR_DOOR_FLAG_RR)) {
 			pPassengers[2] = pPassengers[1];
 			pPassengers[1] = nil;
-			pPassengers[2]->m_vehDoor = CAR_DOOR_RR;
+			pPassengers[2]->m_vehEnterType = CAR_DOOR_RR;
 			return true;
 		}
 		if (!pPassengers[0] && !(m_nGettingInFlags & CAR_DOOR_FLAG_RF)) {
 			pPassengers[0] = pPassengers[1];
 			pPassengers[1] = nil;
-			pPassengers[0]->m_vehDoor = CAR_DOOR_RF;
+			pPassengers[0]->m_vehEnterType = CAR_DOOR_RF;
 			return true;
 		}
 		return false;
@ -1447,13 +1447,13 @@ CVehicle::ShufflePassengersToMakeSpace(void)
 		if (!pPassengers[1] && !(m_nGettingInFlags & CAR_DOOR_FLAG_LR)) {
 			pPassengers[1] = pPassengers[2];
 			pPassengers[2] = nil;
-			pPassengers[1]->m_vehDoor = CAR_DOOR_LR;
+			pPassengers[1]->m_vehEnterType = CAR_DOOR_LR;
 			return true;
 		}
 		if (!pPassengers[0] && !(m_nGettingInFlags & CAR_DOOR_FLAG_RF)) {
 			pPassengers[0] = pPassengers[2];
 			pPassengers[2] = nil;
-			pPassengers[0]->m_vehDoor = CAR_DOOR_RF;
+			pPassengers[0]->m_vehEnterType = CAR_DOOR_RF;
 			return true;
 		}
 		return false;
@ -1464,13 +1464,13 @@ CVehicle::ShufflePassengersToMakeSpace(void)
 		if (!pPassengers[1] && !(m_nGettingInFlags & CAR_DOOR_FLAG_LR)) {
 			pPassengers[1] = pPassengers[0];
 			pPassengers[0] = nil;
-			pPassengers[1]->m_vehDoor = CAR_DOOR_LR;
+			pPassengers[1]->m_vehEnterType = CAR_DOOR_LR;
 			return true;
 		}
 		if (!pPassengers[2] && !(m_nGettingInFlags & CAR_DOOR_FLAG_RR)) {
 			pPassengers[2] = pPassengers[0];
 			pPassengers[0] = nil;
-			pPassengers[2]->m_vehDoor = CAR_DOOR_RR;
+			pPassengers[2]->m_vehEnterType = CAR_DOOR_RR;
 			return true;
 		}
 		return false;