Initial commit

README.md

+# projetDetude

ale/CMakeLists.txt

+cmake_minimum_required (VERSION 2.6)
+project(ale)
+set(ALEVERSION "0.6")
+
+
+option(USE_SDL "Use SDL" OFF)
+option(USE_RLGLUE "Use RL-Glue" OFF)
+option(BUILD_EXAMPLES "Build Example Agents" ON)
+option(BUILD_CPP_LIB "Build C++ Shared Library" ON)
+option(BUILD_CLI "Build ALE Command Line Interface" ON)
+option(BUILD_C_LIB "Build ALE C Library (needed for Python interface)" ON)
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall -Wunused -fPIC -O3 -fomit-frame-pointer -D__STDC_CONSTANT_MACROS")
+add_definitions(-DHAVE_INTTYPES)
+set(LINK_LIBS z)
+
+if(USE_RLGLUE)
+  add_definitions(-D__USE_RLGLUE)
+  list(APPEND LINK_LIBS rlutils rlgluenetdev)
+endif()
+
+if(USE_SDL)
+  add_definitions(-D__USE_SDL)
+  add_definitions(-DSOUND_SUPPORT)
+  find_package(SDL)
+  if(SDL_FOUND AND ${SDL_VERSION_STRING} VERSION_LESS 2)
+    include_directories(${SDL_INCLUDE_DIR})
+    list(APPEND LINK_LIBS ${SDL_LIBRARY} ${SDL_MAIN_LIBRARY})
+  else()
+    MESSAGE("SDL 1.2 not found: You may need to manually edit CMakeLists.txt or run \"cmake -i\" to specify your SDL path.")
+    # Uncomment below to specify the path to your SDL library. Run "locate libSDL" if unsure.
+    # link_directories(path_to_your_SDL)
+    if(APPLE)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -framework Cocoa")
+      list(APPEND LINK_LIBS sdl sdlmain)
+    else()
+      list(APPEND LINK_LIBS SDL)
+    endif()
+  endif()
+endif()
+
+set(SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src)
+set(MODULES common controllers emucore emucore/m6502/src emucore/m6502/src/bspf/src environment games games/supported external external/TinyMT)
+
+foreach(module ${MODULES})
+  file(GLOB module_sources ${SOURCE_DIR}/${module}/*.c)
+  list(APPEND SOURCES ${module_sources})
+  file(GLOB module_sources ${SOURCE_DIR}/${module}/*.c?[xp])
+  list(APPEND SOURCES ${module_sources})
+endforeach(module ${MODULES})
+
+# OS-dependent specifics
+if(APPLE)
+  include_directories(/System/Library/Frameworks/vecLib.framework/Versions/Current/Headers)
+  set(CMAKE_SHARED_LIBRARY_SUFFIX ".so")
+endif()
+
+if(WINDOWS OR MINGW)
+  list(APPEND SOURCES ${SOURCE_DIR}/os_dependent/SettingsWin32.cxx ${SOURCE_DIR}/os_dependent/OSystemWin32.cxx ${SOURCE_DIR}/os_dependent/FSNodeWin32.cxx)
+else()
+  list(APPEND SOURCES ${SOURCE_DIR}/os_dependent/SettingsUNIX.cxx ${SOURCE_DIR}/os_dependent/OSystemUNIX.cxx ${SOURCE_DIR}/os_dependent/FSNodePOSIX.cxx)
+  SET(BIN_INSTALL_DIR "bin")
+  SET(LIB_SUFFIX "" CACHE STRING "Define suffix of directory name (32/64)" )
+  SET(LIB_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}" CACHE STRING "Library directory name")
+  SET(INCLUDE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/include" CACHE STRING "Headers directory name")
+  SET(PKGCONFIG_INSTALL_DIR "${LIB_INSTALL_DIR}/pkgconfig/" CACHE STRING "Base directory for pkgconfig files")
+
+endif()
+
+# List and set the install targets for the headers, generate and install the pkgconfig file
+if(UNIX)
+
+  INSTALL(FILES ${SOURCE_DIR}/os_dependent/SettingsUNIX.hxx ${SOURCE_DIR}/os_dependent/SettingsWin32.hxx ${SOURCE_DIR}/os_dependent/OSystemUNIX.hxx ${SOURCE_DIR}/os_dependent/OSystemWin32.hxx DESTINATION ${INCLUDE_INSTALL_DIR}/${PROJECT_NAME}/os_dependent)
+  file(GLOB module_headers ${SOURCE_DIR}/*.h?[xp])
+  foreach(header ${module_headers})
+         INSTALL(FILES ${header} DESTINATION ${INCLUDE_INSTALL_DIR}/${PROJECT_NAME})
+  endforeach(header ${HEADERS})
+
+  foreach(module ${MODULES})
+    file(GLOB module_headers ${SOURCE_DIR}/${module}/*.h)
+    foreach(header ${module_headers})
+         INSTALL(FILES ${header} DESTINATION ${INCLUDE_INSTALL_DIR}/${PROJECT_NAME}/${module}/)
+    endforeach(header ${HEADERS})
+
+    file(GLOB module_headers ${SOURCE_DIR}/${module}/*.h?[xp])
+    foreach(header ${module_headers})
+         INSTALL(FILES ${header} DESTINATION ${INCLUDE_INSTALL_DIR}/${PROJECT_NAME}/${module}/)
+    endforeach(header ${HEADERS})
+  endforeach(module ${MODULES})
+
+  ###################################
+  # Pkg-config stuff
+  ###################################
+
+  FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc
+"
+Name: ${PROJECT_NAME}
+Description: The Arcade Learning Environment (ALE) - a platform for AI research.
+URL: http://www.arcadelearningenvironment.org/
+Version: ${ALEVERSION}
+Requires:
+Libs: -L${LIB_INSTALL_DIR} -lale
+Cflags: -I${INCLUDE_INSTALL_DIR}
+"
+)
+
+
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc
+      DESTINATION ${PKGCONFIG_INSTALL_DIR})
+
+endif(UNIX)
+
+include_directories(
+  ${SOURCE_DIR}
+  ${SOURCE_DIR}/common
+  ${SOURCE_DIR}/controllers
+  ${SOURCE_DIR}/emucore
+  ${SOURCE_DIR}/emucore/m6502/src
+  ${SOURCE_DIR}/emucore/m6502/src/bspf/src
+  ${SOURCE_DIR}/environment
+  ${SOURCE_DIR}/games
+  ${SOURCE_DIR}/games/supported
+  ${SOURCE_DIR}/os_dependent
+  ${SOURCE_DIR}/external
+  ${SOURCE_DIR}/external/TinyMT
+)
+
+if(NOT BUILD_CPP_LIB AND BUILD_EXAMPLES)
+  set(BUILD_CPP_LIB ON)
+  MESSAGE("Enabling C++ library to support examples.")
+endif()
+
+if(BUILD_CPP_LIB)
+  add_library(ale-lib SHARED ${SOURCE_DIR}/ale_interface.cpp ${SOURCES})
+  set_target_properties(ale-lib PROPERTIES OUTPUT_NAME ale)
+  set_target_properties(ale-lib PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  if(UNIX)
+    install(TARGETS ale-lib
+      DESTINATION ${LIB_INSTALL_DIR})
+  endif()
+  target_link_libraries(ale-lib ${LINK_LIBS})
+endif()
+
+if(BUILD_CLI)
+  add_executable(ale-bin ${SOURCE_DIR}/main.cpp ${SOURCE_DIR}/ale_interface.cpp ${SOURCES})
+  set_target_properties(ale-bin PROPERTIES OUTPUT_NAME ale)
+  set_target_properties(ale-bin PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  if(UNIX)
+    install(TARGETS ale-bin
+      DESTINATION ${BIN_INSTALL_DIR})
+  endif()
+  target_link_libraries(ale-bin ${LINK_LIBS})
+endif()
+
+if(BUILD_C_LIB)
+  add_library(ale-c-lib SHARED ${CMAKE_CURRENT_SOURCE_DIR}/ale_python_interface/ale_c_wrapper.cpp ${SOURCE_DIR}/ale_interface.cpp ${SOURCES})
+  set_target_properties(ale-c-lib PROPERTIES OUTPUT_NAME ale_c)
+  set_target_properties(ale-c-lib PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/ale_python_interface)
+  if(UNIX)
+    install(TARGETS ale-c-lib
+      DESTINATION ${LIB_INSTALL_DIR})
+  endif()
+  target_link_libraries(ale-c-lib ${LINK_LIBS})
+endif()
+
+if(BUILD_EXAMPLES)
+  # Shared library example.
+  link_directories(${CMAKE_CURRENT_SOURCE_DIR})
+  add_executable(sharedLibraryInterfaceExample ${CMAKE_CURRENT_SOURCE_DIR}/doc/examples/sharedLibraryInterfaceExample.cpp)
+  set_target_properties(sharedLibraryInterfaceExample PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/doc/examples)
+  set_target_properties(sharedLibraryInterfaceExample PROPERTIES OUTPUT_NAME ${PROJECT_NAME}-sharedLibraryInterfaceExample)
+
+  target_link_libraries(sharedLibraryInterfaceExample ale)
+  target_link_libraries(sharedLibraryInterfaceExample ${LINK_LIBS})
+  add_dependencies(sharedLibraryInterfaceExample ale-lib)
+
+  # Fifo interface example.
+  link_directories(${CMAKE_CURRENT_SOURCE_DIR})
+
+  add_executable(fifoInterfaceExample ${CMAKE_CURRENT_SOURCE_DIR}/doc/examples/fifoInterfaceExample.cpp)
+  set_target_properties(fifoInterfaceExample PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/doc/examples)
+  set_target_properties(fifoInterfaceExample PROPERTIES OUTPUT_NAME ${PROJECT_NAME}-fifoInterfaceExample)
+  target_link_libraries(fifoInterfaceExample ale)
+  target_link_libraries(fifoInterfaceExample ${LINK_LIBS})
+  add_dependencies(fifoInterfaceExample ale-lib)
+
+  add_executable(sharedLibraryInterfaceWithModesExample ${CMAKE_CURRENT_SOURCE_DIR}/doc/examples/sharedLibraryInterfaceWithModesExample.cpp)
+  set_target_properties(sharedLibraryInterfaceWithModesExample PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/doc/examples)
+  set_target_properties(sharedLibraryInterfaceWithModesExample PROPERTIES OUTPUT_NAME ${PROJECT_NAME}-sharedLibraryInterfaceWithModesExample)
+  target_link_libraries(sharedLibraryInterfaceWithModesExample ale)
+  target_link_libraries(sharedLibraryInterfaceWithModesExample ${LINK_LIBS})
+  add_dependencies(sharedLibraryInterfaceWithModesExample ale-lib)
+
+  # Example showing how to record an Atari 2600 video.
+  if (USE_SDL)
+    add_executable(videoRecordingExample ${CMAKE_CURRENT_SOURCE_DIR}/doc/examples/videoRecordingExample.cpp)
+    set_target_properties(videoRecordingExample PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/doc/examples)
+    set_target_properties(videoRecordingExample PROPERTIES OUTPUT_NAME ${PROJECT_NAME}-videoRecordingExample)
+    target_link_libraries(videoRecordingExample ale)
+    target_link_libraries(videoRecordingExample ${LINK_LIBS})
+    add_dependencies(videoRecordingExample ale-lib)
+  endif()
+endif()
+
+if(USE_RLGLUE)
+  add_executable(RLGlueAgent ${CMAKE_CURRENT_SOURCE_DIR}/doc/examples/RLGlueAgent.c)
+  set_target_properties(RLGlueAgent PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/doc/examples)
+  set_target_properties(RLGlueAgent PROPERTIES OUTPUT_NAME ${PROJECT_NAME}-RLGlueAgent)
+  target_link_libraries(RLGlueAgent rlutils)
+  target_link_libraries(RLGlueAgent rlagent)
+  target_link_libraries(RLGlueAgent rlgluenetdev)
+
+  add_executable(RLGlueExperiment ${CMAKE_CURRENT_SOURCE_DIR}/doc/examples/RLGlueExperiment.c)
+  set_target_properties(RLGlueExperiment PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/doc/examples)
+  set_target_properties(RLGlueExperiment PROPERTIES OUTPUT_NAME ${PROJECT_NAME}-RLGlueExperiment)
+  target_link_libraries(RLGlueExperiment rlutils)
+  target_link_libraries(RLGlueExperiment rlexperiment)
+  target_link_libraries(RLGlueExperiment rlgluenetdev)
+
+endif()
+
+
+########### Add uninstall target ###############
+  FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake
+"
+IF(NOT EXISTS \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\")
+  MESSAGE(FATAL_ERROR \"Cannot find install manifest: @CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\")
+ENDIF(NOT EXISTS \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\")
+
+FILE(READ \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\" files)
+STRING(REGEX REPLACE \"\\n\" \";\" files \"\${files}\")
+FOREACH(file \${files})
+  MESSAGE(STATUS \"Uninstalling \"\$ENV{DESTDIR}\${file}\"\")
+  IF(EXISTS \"\$ENV{DESTDIR}\${file}\")
+    EXEC_PROGRAM(
+      \"@CMAKE_COMMAND@\" ARGS \"-E remove \"\$ENV{DESTDIR}\${file}\"\"
+      OUTPUT_VARIABLE rm_out
+      RETURN_VALUE rm_retval
+      )
+    IF(NOT \"\${rm_retval}\" STREQUAL 0)
+      MESSAGE(FATAL_ERROR \"Problem when removing \"\$ENV{DESTDIR}\${file}\"\")
+    ENDIF(NOT \"\${rm_retval}\" STREQUAL 0)
+  ELSE(EXISTS \"\$ENV{DESTDIR}\${file}\")
+    MESSAGE(STATUS \"File \"\$ENV{DESTDIR}\${file}\" does not exist.\")
+  ENDIF(EXISTS \"\$ENV{DESTDIR}\${file}\")
+ENDFOREACH(file)
+")
+
+ADD_CUSTOM_TARGET(uninstall
+  "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
+  COMMAND rm -rf ${INCLUDE_INSTALL_DIR}/ale)
+
+

ale/ChangeLog

+Inter-release notes:
+  * color_averaging is now off by default so that environment observations correspond to emulator frames unless requested otherwise.
+
+October 4th, 2015. ALE 0.5dev_b.
+  * Enforce flags existence (@mcmachado).
+  * Fix RNG issues introduced in 0.5.0.
+  * Routines for ALEState serialization (@Jragonmiris). 
+  * Additional bug fixes.
+
+July 7th, 2015. ALE 0.5dev.
+  * Refactored Python getScreenRGB to return unpacked RGB values (@spragunr).
+  * Sets the default value of the color_averaging flag to be true. It was true by default in previous versions but was changed in 0.5.0. Reverted for backward compatibility.
+  * Added RNG serialization capability.
+  * Bug fixes from ALE 0.5.0.
+
+June 22nd, 2015. ALE 0.5.0.
+  * Added action_repeat_stochasticity.
+  * Added sound playback, visualization.
+  * Added screen/sound recording ability.
+  * CMake now available.
+  * Incorporated Benjamin Goodrich's Python interface.
+  * Some game fixes.
+  * Added examples for shared library, Python, fifo, RL-Glue interfaces.
+  * Incorporated Java agent into main repository.
+  * Removed internal controller, now superseded by shared library interface.
+  * Better ALEInterface.
+  * Many other changes.
+
+February 15th, 2015. ALE 0.5dev.
+  * Removed the following command-line flags: 'output_file', 'system_reset_steps', 'use_environment_distribution', 'backward_compatible_save', internal agent flags
+  * The flag 'use_starting_actions' was removed and internally its value is always 'true'.
+  * The flag 'disable_color_averaging' was renamed to 'color_averaging' and FALSE is its default value.
+
+April 28th, 2014. ALE 0.4.4.
+  * Fixed a memory issue in ALEScreen.
+
+April 26th, 2014. Bug fix (Mayank Daswani).
+  * Fixed issues with frame numbers not being correctly updated.
+  * Fixed a bug where total reward was not properly reported under frame skipping. 
+
+January 7th, 2013. ALE 0.4.3.
+  * Fixed a bug with ALEState's m_frame_number.
+
+June 12th, 2013. ALE 0.4.2. 
+  * Modified StellaEnvironment save/load interface to provide additional flexibility. 
+  * Series of bug fixes from Matthew Hausknecht and community.
+
+May 24th, 2013. Bug fix to ALE 0.4.1.
+  * Fixed RL-Glue syntax from OBSERVATION to OBSERVATIONS. Thanks to Angus MacIsaac for picking this bug up.
+
+May 22nd, 2013. ALE 0.4.1.
+  * Added frame skipping support directly in StellaEnvironment.
+  * Reverted default number of episodes to 10.
+
+April 22nd, 2013. ALE 0.4.0.
+  * RL-Glue support 
+  * Shared library interface
+  * Simpler direct environment interfacing
+  * Improved environment handling
+  * Improved environment customization 
+  * Better documentation
+
+October 3rd, 2012. Moving to GITHub.
+
+August 7th, 2012. ALE 0.3.1.
+  * Fixed frames per episode cap for FIFO agents, added functionality to
+    limit the total number of frames per run for FIFO agents.
+
+July 22nd, 2012. ALE 0.3.
+  * Initial ALE release.
+

ale/Copyright.txt

+===========================================================================
+
+   SSSS    tt          lll  lll       
+  SS  SS   tt           ll   ll        
+  SS     tttttt  eeee   ll   ll   aaaa 
+   SSSS    tt   ee  ee  ll   ll      aa
+      SS   tt   eeeeee  ll   ll   aaaaa  --  "An Atari 2600 VCS Emulator"
+  SS  SS   tt   ee      ll   ll  aa  aa
+   SSSS     ttt  eeeee llll llll  aaaaa
+
+===========================================================================
+                  License Information and Copyright Notice
+===========================================================================
+
+Copyright (C) 1995-2012 Bradford W. Mott, Stephen Anthony and the
+Stella Team
+
+===========================================================================
+The Arcade Learning Environment
+===========================================================================
+
+Copyright (C) 2009-2012 Yavar Naddaf, Marc G. Bellemare, Joel Veness and the
+Artificial Intelligence Laboratory at the University of Alberta
+
+
+This program is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or any later version.
+
+You should have received a copy of the GNU General Public License version 2
+along with this program (License.txt); if not, write to the Free Software 
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY. IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO
+ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
+DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. THIS SOFTWARE IS
+PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO
+OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
+MODIFICATIONS.

ale/License.txt

+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                      59 Temple Place, Suite 330, Boston, MA 02111 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	Appendix: How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) 19yy  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) 19yy name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.

ale/README-SDL.txt

+Please distribute this file with the SDL runtime environment:
+
+The Simple DirectMedia Layer (SDL for short) is a cross-platfrom library
+designed to make it easy to write multi-media software, such as games and
+emulators.
+
+The Simple DirectMedia Layer library source code is available from:
+http://www.libsdl.org/
+
+This library is distributed under the terms of the GNU LGPL license:
+http://www.gnu.org/copyleft/lesser.html

ale/README.md

+[![Build Status](https://travis-ci.org/mgbellemare/Arcade-Learning-Environment.svg?branch=master)](https://travis-ci.org/mgbellemare/Arcade-Learning-Environment)
+
+<img align="right" src="doc/manual/figures/ale.gif" width=50>
+
+# The Arcade Learning Environment
+
+The Arcade Learning Environment (ALE) is a simple object-oriented framework that allows researchers and hobbyists to develop AI agents for Atari 2600 games. It is built on top of the Atari 2600 emulator [Stella](https://stella-emu.github.io/) and separates the details of emulation from agent design. This [video](https://www.youtube.com/watch?v=nzUiEkasXZI) depicts over 50 games currently supported in the ALE.
+
+For an overview of our goals for the ALE read [The Arcade Learning Environment: An Evaluation Platform for General Agents](http://www.jair.org/papers/paper3912.html). If you use ALE in your research, we ask that you please cite this paper in reference to the environment (BibTeX entry at the end of this document). Also, if you have any questions or comments about the ALE, please contact us through our [mailing list](https://groups.google.com/forum/#!forum/arcade-learning-environment).
+
+
+Feedback and suggestions are welcome and may be addressed to any active member of the ALE team.
+
+### Features
+- Object-oriented framework with support to add agents and games.
+- Emulation core uncoupled from rendering and sound generation modules for fast emulation with minimal library dependencies.
+- Automatic extraction of game score and end-of-game signal for more than 50 Atari 2600 games.
+- Multi-platform code (compiled and tested under OS X and several Linux distributions, with Cygwin support).
+- Communication between agents and emulation core can be accomplished through pipes, allowing for cross-language development (sample Java code included).
+- Python development is supported through ctypes.
+- Agents programmed in C++ have access to all features in the ALE.
+- Visualization tools.
+
+## Quick start
+
+
+Install main dependences:
+```
+sudo apt-get install libsdl1.2-dev libsdl-gfx1.2-dev libsdl-image1.2-dev cmake
+```
+
+Compilation:
+
+```
+$ mkdir build && cd build
+$ cmake -DUSE_SDL=ON -DUSE_RLGLUE=OFF -DBUILD_EXAMPLES=ON ..
+$ make -j 4
+```
+
+To install python module:
+
+```
+$ pip install .
+or
+$ pip install --user .
+```
+
+Getting the ALE to work on Visual Studio requires a bit of extra wrangling. You may wish to use IslandMan93's [Visual Studio port of the ALE.](https://github.com/Islandman93/Arcade-Learning-Environment)
+
+For more details and installation instructions, see the [manual](doc/manual/manual.pdf). To ask questions and discuss, please join the [ALE-users group](https://groups.google.com/forum/#!forum/arcade-learning-environment).
+
+## ALE releases
+
+Releases before v.0.5 are available for download in our previous [website](http://www.arcadelearningenvironment.org/). For the latest releases, please check our releases [page](https://github.com/mgbellemare/Arcade-Learning-Environment/releases).
+
+## List of command-line parameters
+
+Execute ./ale -help for more details; alternatively, see documentation 
+available at http://www.arcadelearningenvironment.org.
+
+```
+-random_seed [n] -- sets the random seed; defaults to the current time
+
+-game_controller [fifo|fifo_named] -- specifies how agents interact
+  with the ALE; see Java agent documentation for details
+
+-config [file] -- specifies a configuration file, from which additional 
+  parameters are read
+
+-run_length_encoding [false|true] -- determine whether run-length encoding is
+  used to send data over pipes; irrelevant when an internal agent is 
+  being used
+
+-max_num_frames_per_episode [n] -- sets the maximum number of frames per
+  episode. Once this number is reached, a new episode will start. Currently
+  implemented for all agents when using pipes (fifo/fifo_named) 
+
+-max_num_frames [n] -- sets the maximum number of frames (independent of how 
+  many episodes are played)
+```
+
+
+## Citing The Arcade Learning Environment
+
+
+If you use the ALE in your research, we ask that you please cite the following.
+
+*M. G. Bellemare, Y. Naddaf, J. Veness and M. Bowling. The Arcade Learning Environment: An Evaluation Platform for General Agents, Journal of Artificial Intelligence Research, Volume 47, pages 253-279, 2013.*
+
+In BibTeX format:
+
+```
+@Article{bellemare13arcade,
+  author = {{Bellemare}, M.~G. and {Naddaf}, Y. and {Veness}, J. and {Bowling}, M.},
+  title = {The Arcade Learning Environment: An Evaluation Platform for General Agents},
+  journal = {Journal of Artificial Intelligence Research},
+  year = "2013",
+  month = "jun",
+  volume = "47",
+  pages = "253--279",
+}
+```
+
+
+If you use the ALE with sticky actions (flag `repeat_action_probability`), or if you use the different game flavours (mode and difficulty switches), we ask you that you also cite the following:
+
+*M. C. Machado, M. G. Bellemare, E. Talvitie, J. Veness, M. J. Hausknecht, M. Bowling. Revisiting the Arcade Learning Environment: Evaluation Protocols and Open Problems for General Agents,  CoRR abs/1709.06009, 2017.*
+
+In BibTex format:
+
+```
+@Article{machado17arcade,
+  author = {Marlos C. Machado and Marc G. Bellemare and Erik Talvitie and Joel Veness and Matthew J. Hausknecht and Michael Bowling},
+  title = {Revisiting the Arcade Learning Environment: Evaluation Protocols and Open Problems for General Agents},
+  journal = {CoRR},
+  volume = {abs/1709.06009},
+  year = {2017}
+}
+```

ale/ale.cfg

+# Use this file to set default options for ALE.
+# One setting per line. 
+# Format: option-name=option-value
+# 
+# Example.
+#
+# cpu=low
+# repeat_action_probability=0.25
+#
+# Note that, for the Python and C++ interface, these options are set when the interface is
+# first created (i.e. within ALEInterface's constructor), and not when the ROM is loaded. 

ale/ale_python_interface/__init__.py

+from .ale_python_interface import *

ale/ale_python_interface/ale_c_wrapper.cpp

+#include "ale_c_wrapper.h"
+
+#include <cstring>
+#include <string>
+#include <stdexcept>
+
+void encodeState(ALEState *state, char *buf, int buf_len) {
+	std::string str = state->serialize();
+
+	if (buf_len < int(str.length())) {
+		throw new std::runtime_error("Buffer is not big enough to hold serialized ALEState. Please use encodeStateLen to determine the correct buffer size");
+	}
+
+	memcpy(buf, str.data(), str.length());
+}
+
+int encodeStateLen(ALEState *state) {
+	return state->serialize().length();
+}
+
+ALEState *decodeState(const char *serialized, int len) {
+	std::string str(serialized, len);
+
+	return new ALEState(str);
+}
\ No newline at end of file

ale/ale_python_interface/ale_c_wrapper.h

+#ifndef __ALE_C_WRAPPER_H__
+#define __ALE_C_WRAPPER_H__
+
+#include <ale_interface.hpp>
+
+extern "C" {
+  // Declares int rgb_palette[256]
+  ALEInterface *ALE_new() {return new ALEInterface();}
+  void ALE_del(ALEInterface *ale){delete ale;}
+  const char *getString(ALEInterface *ale, const char *key){return ale->getString(key).c_str();}
+  int getInt(ALEInterface *ale,const char *key) {return ale->getInt(key);}
+  bool getBool(ALEInterface *ale,const char *key){return ale->getBool(key);}
+  float getFloat(ALEInterface *ale,const char *key){return ale->getFloat(key);}
+  void setString(ALEInterface *ale,const char *key,const char *value){ale->setString(key,value);}
+  void setInt(ALEInterface *ale,const char *key,int value){ale->setInt(key,value);}
+  void setBool(ALEInterface *ale,const char *key,bool value){ale->setBool(key,value);}
+  void setFloat(ALEInterface *ale,const char *key,float value){ale->setFloat(key,value);}
+  void loadROM(ALEInterface *ale,const char *rom_file){ale->loadROM(rom_file);}
+  int act(ALEInterface *ale,int action){return ale->act((Action)action);}
+  bool game_over(ALEInterface *ale){return ale->game_over();}
+  void reset_game(ALEInterface *ale){ale->reset_game();}
+  void getAvailableModes(ALEInterface *ale,int *availableModes) {
+    ModeVect modes_vect = ale->getAvailableModes();
+    for(unsigned int i = 0; i < ale->getAvailableModes().size(); i++){
+      availableModes[i] = modes_vect[i];
+    }
+  }
+  int getAvailableModesSize(ALEInterface *ale) {return ale->getAvailableModes().size();}
+  void setMode(ALEInterface *ale, int mode) {ale->setMode(mode);}
+  void getAvailableDifficulties(ALEInterface *ale,int *availableDifficulties) {
+    DifficultyVect difficulties_vect = ale->getAvailableDifficulties();
+    for(unsigned int i = 0; i < ale->getAvailableDifficulties().size(); i++){
+      availableDifficulties[i] = difficulties_vect[i];
+    }
+  }
+  int getAvailableDifficultiesSize(ALEInterface *ale) {return ale->getAvailableDifficulties().size();}
+  void setDifficulty(ALEInterface *ale, int difficulty) {ale->setDifficulty(difficulty);}
+  void getLegalActionSet(ALEInterface *ale,int *actions) {
+    ActionVect action_vect = ale->getLegalActionSet();
+    for(unsigned int i = 0; i < ale->getLegalActionSet().size(); i++){
+      actions[i] = action_vect[i];
+    }
+  }
+  int getLegalActionSize(ALEInterface *ale){return ale->getLegalActionSet().size();}
+  void getMinimalActionSet(ALEInterface *ale,int *actions){
+    ActionVect action_vect = ale->getMinimalActionSet();
+    for(unsigned int i = 0;i < ale->getMinimalActionSet().size();i++){
+      actions[i] = action_vect[i];
+    }
+  }
+  int getMinimalActionSize(ALEInterface *ale){return ale->getMinimalActionSet().size();}
+  int getFrameNumber(ALEInterface *ale){return ale->getFrameNumber();}
+  int lives(ALEInterface *ale){return ale->lives();}
+  int getEpisodeFrameNumber(ALEInterface *ale){return ale->getEpisodeFrameNumber();}
+  void getScreen(ALEInterface *ale,unsigned char *screen_data){
+    int w = ale->getScreen().width();
+    int h = ale->getScreen().height();
+    pixel_t *ale_screen_data = (pixel_t *)ale->getScreen().getArray();
+    memcpy(screen_data,ale_screen_data,w*h*sizeof(pixel_t));
+  }
+  void getRAM(ALEInterface *ale,unsigned char *ram){
+    unsigned char *ale_ram = ale->getRAM().array();
+    int size = ale->getRAM().size();
+    memcpy(ram,ale_ram,size*sizeof(unsigned char));
+  }
+  int getRAMSize(ALEInterface *ale){return ale->getRAM().size();}
+  int getScreenWidth(ALEInterface *ale){return ale->getScreen().width();}
+  int getScreenHeight(ALEInterface *ale){return ale->getScreen().height();}
+
+  void getScreenRGB(ALEInterface *ale, unsigned char *output_buffer){
+    size_t w = ale->getScreen().width();
+    size_t h = ale->getScreen().height();
+    size_t screen_size = w*h;
+    pixel_t *ale_screen_data = ale->getScreen().getArray();
+
+    ale->theOSystem->colourPalette().applyPaletteRGB(output_buffer, ale_screen_data, screen_size );
+  }
+
+  void getScreenGrayscale(ALEInterface *ale, unsigned char *output_buffer){
+    size_t w = ale->getScreen().width();
+    size_t h = ale->getScreen().height();
+    size_t screen_size = w*h;
+    pixel_t *ale_screen_data = ale->getScreen().getArray();
+
+    ale->theOSystem->colourPalette().applyPaletteGrayscale(output_buffer, ale_screen_data, screen_size);
+  }
+
+  void saveState(ALEInterface *ale){ale->saveState();}
+  void loadState(ALEInterface *ale){ale->loadState();}
+  ALEState* cloneState(ALEInterface *ale){return new ALEState(ale->cloneState());}
+  void restoreState(ALEInterface *ale, ALEState* state){ale->restoreState(*state);}
+  ALEState* cloneSystemState(ALEInterface *ale){return new ALEState(ale->cloneSystemState());}
+  void restoreSystemState(ALEInterface *ale, ALEState* state){ale->restoreSystemState(*state);}
+  void deleteState(ALEState* state){delete state;}
+  void saveScreenPNG(ALEInterface *ale,const char *filename){ale->saveScreenPNG(filename);}
+
+  // Encodes the state as a raw bytestream. This may have multiple '\0' characters
+  // and thus should not be treated as a C string. Use encodeStateLen to find the length
+  // of the buffer to pass in, or it will be overrun as this simply memcpys bytes into the buffer.
+  void encodeState(ALEState *state, char *buf, int buf_len);
+  int encodeStateLen(ALEState *state);
+  ALEState *decodeState(const char *serialized, int len);
+
+  // 0: Info, 1: Warning, 2: Error
+  void setLoggerMode(int mode) { ale::Logger::setMode(ale::Logger::mode(mode)); }
+}
+
+#endif

ale/ale_python_interface/ale_python_interface.py

+# ale_python_interface.py
+# Author: Ben Goodrich
+# This directly implements a python version of the arcade learning
+# environment interface.
+__all__ = ['ALEInterface']
+
+from ctypes import *
+import numpy as np
+from numpy.ctypeslib import as_ctypes
+import os
+
+ale_lib = cdll.LoadLibrary(os.path.join(os.path.dirname(__file__),
+                                        'libale_c.so'))
+
+ale_lib.ALE_new.argtypes = None
+ale_lib.ALE_new.restype = c_void_p
+ale_lib.ALE_del.argtypes = [c_void_p]
+ale_lib.ALE_del.restype = None
+ale_lib.getString.argtypes = [c_void_p, c_char_p]
+ale_lib.getString.restype = c_char_p
+ale_lib.getInt.argtypes = [c_void_p, c_char_p]
+ale_lib.getInt.restype = c_int
+ale_lib.getBool.argtypes = [c_void_p, c_char_p]
+ale_lib.getBool.restype = c_bool
+ale_lib.getFloat.argtypes = [c_void_p, c_char_p]
+ale_lib.getFloat.restype = c_float
+ale_lib.setString.argtypes = [c_void_p, c_char_p, c_char_p]
+ale_lib.setString.restype = None
+ale_lib.setInt.argtypes = [c_void_p, c_char_p, c_int]
+ale_lib.setInt.restype = None
+ale_lib.setBool.argtypes = [c_void_p, c_char_p, c_bool]
+ale_lib.setBool.restype = None
+ale_lib.setFloat.argtypes = [c_void_p, c_char_p, c_float]
+ale_lib.setFloat.restype = None
+ale_lib.loadROM.argtypes = [c_void_p, c_char_p]
+ale_lib.loadROM.restype = None
+ale_lib.act.argtypes = [c_void_p, c_int]
+ale_lib.act.restype = c_int
+ale_lib.game_over.argtypes = [c_void_p]
+ale_lib.game_over.restype = c_bool
+ale_lib.reset_game.argtypes = [c_void_p]
+ale_lib.reset_game.restype = None
+ale_lib.getAvailableModes.argtypes = [c_void_p, c_void_p]
+ale_lib.getAvailableModes.restype = None
+ale_lib.getAvailableModesSize.argtypes = [c_void_p]
+ale_lib.getAvailableModesSize.restype = c_int
+ale_lib.setMode.argtypes = [c_void_p, c_int]
+ale_lib.setMode.restype = None
+ale_lib.getAvailableDifficulties.argtypes = [c_void_p, c_void_p]
+ale_lib.getAvailableDifficulties.restype = None
+ale_lib.getAvailableDifficultiesSize.argtypes = [c_void_p]
+ale_lib.getAvailableDifficultiesSize.restype = c_int
+ale_lib.setDifficulty.argtypes = [c_void_p, c_int]
+ale_lib.setDifficulty.restype = None
+ale_lib.getLegalActionSet.argtypes = [c_void_p, c_void_p]
+ale_lib.getLegalActionSet.restype = None
+ale_lib.getLegalActionSize.argtypes = [c_void_p]
+ale_lib.getLegalActionSize.restype = c_int
+ale_lib.getMinimalActionSet.argtypes = [c_void_p, c_void_p]
+ale_lib.getMinimalActionSet.restype = None
+ale_lib.getMinimalActionSize.argtypes = [c_void_p]
+ale_lib.getMinimalActionSize.restype = c_int
+ale_lib.getFrameNumber.argtypes = [c_void_p]
+ale_lib.getFrameNumber.restype = c_int
+ale_lib.lives.argtypes = [c_void_p]
+ale_lib.lives.restype = c_int
+ale_lib.getEpisodeFrameNumber.argtypes = [c_void_p]
+ale_lib.getEpisodeFrameNumber.restype = c_int
+ale_lib.getScreen.argtypes = [c_void_p, c_void_p]
+ale_lib.getScreen.restype = None
+ale_lib.getRAM.argtypes = [c_void_p, c_void_p]
+ale_lib.getRAM.restype = None
+ale_lib.getRAMSize.argtypes = [c_void_p]
+ale_lib.getRAMSize.restype = c_int
+ale_lib.getScreenWidth.argtypes = [c_void_p]
+ale_lib.getScreenWidth.restype = c_int
+ale_lib.getScreenHeight.argtypes = [c_void_p]
+ale_lib.getScreenHeight.restype = c_int
+ale_lib.getScreenRGB.argtypes = [c_void_p, c_void_p]
+ale_lib.getScreenRGB.restype = None
+ale_lib.getScreenGrayscale.argtypes = [c_void_p, c_void_p]
+ale_lib.getScreenGrayscale.restype = None
+ale_lib.saveState.argtypes = [c_void_p]
+ale_lib.saveState.restype = None
+ale_lib.loadState.argtypes = [c_void_p]
+ale_lib.loadState.restype = None
+ale_lib.cloneState.argtypes = [c_void_p]
+ale_lib.cloneState.restype = c_void_p
+ale_lib.restoreState.argtypes = [c_void_p, c_void_p]
+ale_lib.restoreState.restype = None
+ale_lib.cloneSystemState.argtypes = [c_void_p]
+ale_lib.cloneSystemState.restype = c_void_p
+ale_lib.restoreSystemState.argtypes = [c_void_p, c_void_p]
+ale_lib.restoreSystemState.restype = None
+ale_lib.deleteState.argtypes = [c_void_p]
+ale_lib.deleteState.restype = None
+ale_lib.saveScreenPNG.argtypes = [c_void_p, c_char_p]
+ale_lib.saveScreenPNG.restype = None
+ale_lib.encodeState.argtypes = [c_void_p, c_void_p, c_int]
+ale_lib.encodeState.restype = None
+ale_lib.encodeStateLen.argtypes = [c_void_p]
+ale_lib.encodeStateLen.restype = c_int
+ale_lib.decodeState.argtypes = [c_void_p, c_int]
+ale_lib.decodeState.restype = c_void_p
+ale_lib.setLoggerMode.argtypes = [c_int]
+ale_lib.setLoggerMode.restype = None
+
+class ALEInterface(object):
+    # Logger enum
+    class Logger:
+        Info = 0
+        Warning = 1
+        Error = 2
+
+
+    def __init__(self):
+        self.obj = ale_lib.ALE_new()
+
+    def getString(self, key):
+        return ale_lib.getString(self.obj, key)
+    def getInt(self, key):
+        return ale_lib.getInt(self.obj, key)
+    def getBool(self, key):
+        return ale_lib.getBool(self.obj, key)
+    def getFloat(self, key):
+        return ale_lib.getFloat(self.obj, key)
+
+    def setString(self, key, value):
+      ale_lib.setString(self.obj, key, value)
+    def setInt(self, key, value):
+      ale_lib.setInt(self.obj, key, value)
+    def setBool(self, key, value):
+      ale_lib.setBool(self.obj, key, value)
+    def setFloat(self, key, value):
+      ale_lib.setFloat(self.obj, key, value)
+
+    def loadROM(self, rom_file):
+        ale_lib.loadROM(self.obj, rom_file)
+
+    def act(self, action):
+        return ale_lib.act(self.obj, int(action))
+
+    def game_over(self):
+        return ale_lib.game_over(self.obj)
+
+    def reset_game(self):
+        ale_lib.reset_game(self.obj)
+
+    def getLegalActionSet(self):
+        act_size = ale_lib.getLegalActionSize(self.obj)
+        act = np.zeros((act_size), dtype=np.intc)
+        ale_lib.getLegalActionSet(self.obj, as_ctypes(act))
+        return act
+
+    def getMinimalActionSet(self):
+        act_size = ale_lib.getMinimalActionSize(self.obj)
+        act = np.zeros((act_size), dtype=np.intc)
+        ale_lib.getMinimalActionSet(self.obj, as_ctypes(act))
+        return act
+
+    def getAvailableModes(self):
+        modes_size = ale_lib.getAvailableModesSize(self.obj)
+        modes = np.zeros((modes_size), dtype=np.intc)
+        ale_lib.getAvailableModes(self.obj, as_ctypes(modes))
+        return modes
+
+    def setMode(self, mode):
+        ale_lib.setMode(self.obj, mode)
+
+    def getAvailableDifficulties(self):
+        difficulties_size = ale_lib.getAvailableDifficultiesSize(self.obj)
+        difficulties = np.zeros((difficulties_size), dtype=np.intc)
+        ale_lib.getAvailableDifficulties(self.obj, as_ctypes(difficulties))
+        return difficulties
+
+    def setDifficulty(self, difficulty):
+        ale_lib.setDifficulty(self.obj, difficulty)
+
+    def getLegalActionSet(self):
+        act_size = ale_lib.getLegalActionSize(self.obj)
+        act = np.zeros((act_size), dtype=np.intc)
+        ale_lib.getLegalActionSet(self.obj, as_ctypes(act))
+        return act
+
+    def getMinimalActionSet(self):
+        act_size = ale_lib.getMinimalActionSize(self.obj)
+        act = np.zeros((act_size), dtype=np.intc)
+        ale_lib.getMinimalActionSet(self.obj, as_ctypes(act))
+        return act
+
+    def getFrameNumber(self):
+        return ale_lib.getFrameNumber(self.obj)
+
+    def lives(self):
+        return ale_lib.lives(self.obj)
+
+    def getEpisodeFrameNumber(self):
+        return ale_lib.getEpisodeFrameNumber(self.obj)
+
+    def getScreenDims(self):
+        """returns a tuple that contains (screen_width, screen_height)
+        """
+        width = ale_lib.getScreenWidth(self.obj)
+        height = ale_lib.getScreenHeight(self.obj)
+        return (width, height)
+
+    def getScreen(self, screen_data=None):
+        """This function fills screen_data with the RAW Pixel data
+        screen_data MUST be a numpy array of uint8/int8. This could be initialized like so:
+        screen_data = np.empty(w*h, dtype=np.uint8)
+        Notice,  it must be width*height in size also
+        If it is None,  then this function will initialize it
+        Note: This is the raw pixel values from the atari,  before any RGB palette transformation takes place
+        """
+        if(screen_data is None):
+            width = ale_lib.getScreenWidth(self.obj)
+            height = ale_lib.getScreenHeight(self.obj)
+            screen_data = np.zeros(width*height, dtype=np.uint8)
+        ale_lib.getScreen(self.obj, as_ctypes(screen_data))
+        return screen_data
+
+    def getScreenRGB(self, screen_data=None):
+        """This function fills screen_data with the data in RGB format
+        screen_data MUST be a numpy array of uint8. This can be initialized like so:
+        screen_data = np.empty((height,width,3), dtype=np.uint8)
+        If it is None,  then this function will initialize it.
+        """
+        if(screen_data is None):
+            width = ale_lib.getScreenWidth(self.obj)
+            height = ale_lib.getScreenHeight(self.obj)
+            screen_data = np.empty((height, width,3), dtype=np.uint8)
+        ale_lib.getScreenRGB(self.obj, as_ctypes(screen_data[:]))
+        return screen_data
+
+    def getScreenGrayscale(self, screen_data=None):
+        """This function fills screen_data with the data in grayscale
+        screen_data MUST be a numpy array of uint8. This can be initialized like so:
+        screen_data = np.empty((height,width,1), dtype=np.uint8)
+        If it is None,  then this function will initialize it.
+        """
+        if(screen_data is None):
+            width = ale_lib.getScreenWidth(self.obj)
+            height = ale_lib.getScreenHeight(self.obj)
+            screen_data = np.empty((height, width,1), dtype=np.uint8)
+        ale_lib.getScreenGrayscale(self.obj, as_ctypes(screen_data[:]))
+        return screen_data
+
+    def getRAMSize(self):
+        return ale_lib.getRAMSize(self.obj)
+
+    def getRAM(self, ram=None):
+        """This function grabs the atari RAM.
+        ram MUST be a numpy array of uint8/int8. This can be initialized like so:
+        ram = np.array(ram_size, dtype=uint8)
+        Notice: It must be ram_size where ram_size can be retrieved via the getRAMSize function.
+        If it is None,  then this function will initialize it.
+        """
+        if(ram is None):
+            ram_size = ale_lib.getRAMSize(self.obj)
+            ram = np.zeros(ram_size, dtype=np.uint8)
+        ale_lib.getRAM(self.obj, as_ctypes(ram))
+        return ram
+
+    def saveScreenPNG(self, filename):
+        """Save the current screen as a png file"""
+        return ale_lib.saveScreenPNG(self.obj, filename)
+
+    def saveState(self):
+        """Saves the state of the system"""
+        return ale_lib.saveState(self.obj)
+
+    def loadState(self):
+        """Loads the state of the system"""
+        return ale_lib.loadState(self.obj)
+
+    def cloneState(self):
+        """This makes a copy of the environment state. This copy does *not*
+        include pseudorandomness, making it suitable for planning
+        purposes. By contrast, see cloneSystemState.
+        """
+        return ale_lib.cloneState(self.obj)
+
+    def restoreState(self, state):
+        """Reverse operation of cloneState(). This does not restore
+        pseudorandomness, so that repeated calls to restoreState() in
+        the stochastic controls setting will not lead to the same
+        outcomes.  By contrast, see restoreSystemState.
+        """
+        ale_lib.restoreState(self.obj, state)
+
+    def cloneSystemState(self):
+        """This makes a copy of the system & environment state, suitable for
+        serialization. This includes pseudorandomness and so is *not*
+        suitable for planning purposes.
+        """
+        return ale_lib.cloneSystemState(self.obj)
+
+    def restoreSystemState(self, state):
+        """Reverse operation of cloneSystemState."""
+        ale_lib.restoreSystemState(self.obj, state)
+
+    def deleteState(self, state):
+        """ Deallocates the ALEState """
+        ale_lib.deleteState(state)
+
+    def encodeStateLen(self, state):
+        return ale_lib.encodeStateLen(state)
+
+    def encodeState(self, state, buf=None):
+        if buf == None:
+            length = ale_lib.encodeStateLen(state)
+            buf = np.zeros(length, dtype=np.uint8)
+        ale_lib.encodeState(state, as_ctypes(buf), c_int(len(buf)))
+        return buf
+
+    def decodeState(self, serialized):
+        return ale_lib.decodeState(as_ctypes(serialized), len(serialized))
+
+    def __del__(self):
+        ale_lib.ALE_del(self.obj)
+
+    @staticmethod
+    def setLoggerMode(mode):
+        dic = {'info': 0, 'warning': 1, 'error': 2}
+        mode = dic.get(mode, mode)
+        assert mode in [0, 1, 2], "Invalid Mode! Mode must be one of 0: info, 1: warning, 2: error"
+        ale_lib.setLoggerMode(mode)

ale/build/CMakeCache.txt

+# This is the CMakeCache file.
+# For build in directory: /home/elucterio/st500/enseignement/Code/Arcade-Learning-Environment/build
+# It was generated by CMake: /usr/bin/cmake
+# You can edit this file to change values found and used by cmake.
+# If you do not want to change any of the values, simply exit the editor.
+# If you do want to change a value, simply edit, save, and exit the editor.
+# The syntax for the file is as follows:
+# KEY:TYPE=VALUE
+# KEY is the name of a variable in the cache.
+# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!.
+# VALUE is the current value for the KEY.
+
+########################
+# EXTERNAL cache entries
+########################
+
+//Build ALE Command Line Interface
+BUILD_CLI:BOOL=ON
+
+//Build C++ Shared Library
+BUILD_CPP_LIB:BOOL=ON
+
+//Build ALE C Library (needed for Python interface)
+BUILD_C_LIB:BOOL=ON
+
+//Build Example Agents
+BUILD_EXAMPLES:BOOL=ON
+
+//Path to a program.
+CMAKE_AR:FILEPATH=/usr/bin/ar
+
+//Choose the type of build, options are: None(CMAKE_CXX_FLAGS or
+// CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel.
+CMAKE_BUILD_TYPE:STRING=
+
+//Enable/Disable color output during build.
+CMAKE_COLOR_MAKEFILE:BOOL=ON
+
+//CXX compiler
+CMAKE_CXX_COMPILER:FILEPATH=/usr/bin/c++
+
+//Flags used by the compiler during all build types.
+CMAKE_CXX_FLAGS:STRING=
+
+//Flags used by the compiler during debug builds.
+CMAKE_CXX_FLAGS_DEBUG:STRING=-g
+
+//Flags used by the compiler during release builds for minimum
+// size.
+CMAKE_CXX_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG
+
+//Flags used by the compiler during release builds.
+CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG
+
+//Flags used by the compiler during release builds with debug info.
+CMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG
+
+//C compiler
+CMAKE_C_COMPILER:FILEPATH=/usr/bin/cc
+
+//Flags used by the compiler during all build types.
+CMAKE_C_FLAGS:STRING=
+
+//Flags used by the compiler during debug builds.
+CMAKE_C_FLAGS_DEBUG:STRING=-g
+
+//Flags used by the compiler during release builds for minimum
+// size.
+CMAKE_C_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG
+
+//Flags used by the compiler during release builds.
+CMAKE_C_FLAGS_RELEASE:STRING=-O3 -DNDEBUG
+
+//Flags used by the compiler during release builds with debug info.
+CMAKE_C_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG
+
+//Flags used by the linker.
+CMAKE_EXE_LINKER_FLAGS:STRING=
+
+//Flags used by the linker during debug builds.
+CMAKE_EXE_LINKER_FLAGS_DEBUG:STRING=
+
+//Flags used by the linker during release minsize builds.
+CMAKE_EXE_LINKER_FLAGS_MINSIZEREL:STRING=
+
+//Flags used by the linker during release builds.
+CMAKE_EXE_LINKER_FLAGS_RELEASE:STRING=
+
+//Flags used by the linker during Release with Debug Info builds.
+CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO:STRING=
+
+//Enable/Disable output of compile commands during generation.
+CMAKE_EXPORT_COMPILE_COMMANDS:BOOL=OFF
+
+//Install path prefix, prepended onto install directories.
+CMAKE_INSTALL_PREFIX:PATH=/usr/local
+
+//Path to a program.
+CMAKE_LINKER:FILEPATH=/usr/bin/ld
+
+//Path to a program.
+CMAKE_MAKE_PROGRAM:FILEPATH=/usr/bin/make
+
+//Flags used by the linker during the creation of modules.
+CMAKE_MODULE_LINKER_FLAGS:STRING=
+
+//Flags used by the linker during debug builds.
+CMAKE_MODULE_LINKER_FLAGS_DEBUG:STRING=
+
+//Flags used by the linker during release minsize builds.
+CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL:STRING=
+
+//Flags used by the linker during release builds.
+CMAKE_MODULE_LINKER_FLAGS_RELEASE:STRING=
+
+//Flags used by the linker during Release with Debug Info builds.
+CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO:STRING=
+
+//Path to a program.
+CMAKE_NM:FILEPATH=/usr/bin/nm
+
+//Path to a program.
+CMAKE_OBJCOPY:FILEPATH=/usr/bin/objcopy
+
+//Path to a program.
+CMAKE_OBJDUMP:FILEPATH=/usr/bin/objdump
+
+//Value Computed by CMake
+CMAKE_PROJECT_NAME:STATIC=ale
+
+//Path to a program.
+CMAKE_RANLIB:FILEPATH=/usr/bin/ranlib
+
+//Flags used by the linker during the creation of dll's.
+CMAKE_SHARED_LINKER_FLAGS:STRING=
+
+//Flags used by the linker during debug builds.
+CMAKE_SHARED_LINKER_FLAGS_DEBUG:STRING=
+
+//Flags used by the linker during release minsize builds.
+CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL:STRING=
+
+//Flags used by the linker during release builds.
+CMAKE_SHARED_LINKER_FLAGS_RELEASE:STRING=
+
+//Flags used by the linker during Release with Debug Info builds.
+CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO:STRING=
+
+//If set, runtime paths are not added when installing shared libraries,
+// but are added when building.
+CMAKE_SKIP_INSTALL_RPATH:BOOL=NO
+
+//If set, runtime paths are not added when using shared libraries.
+CMAKE_SKIP_RPATH:BOOL=NO
+
+//Flags used by the linker during the creation of static libraries.
+CMAKE_STATIC_LINKER_FLAGS:STRING=
+
+//Flags used by the linker during debug builds.
+CMAKE_STATIC_LINKER_FLAGS_DEBUG:STRING=
+
+//Flags used by the linker during release minsize builds.
+CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL:STRING=
+
+//Flags used by the linker during release builds.
+CMAKE_STATIC_LINKER_FLAGS_RELEASE:STRING=
+
+//Flags used by the linker during Release with Debug Info builds.
+CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO:STRING=
+
+//Path to a program.
+CMAKE_STRIP:FILEPATH=/usr/bin/strip
+
+//If this value is on, makefiles will be generated without the
+// .SILENT directive, and all commands will be echoed to the console
+// during the make.  This is useful for debugging only. With Visual
+// Studio IDE projects all commands are done without /nologo.
+CMAKE_VERBOSE_MAKEFILE:BOOL=FALSE
+
+//Headers directory name
+INCLUDE_INSTALL_DIR:STRING=/usr/local/include
+
+//Library directory name
+LIB_INSTALL_DIR:STRING=/usr/local/lib
+
+//Define suffix of directory name (32/64)
+LIB_SUFFIX:STRING=
+
+//Base directory for pkgconfig files
+PKGCONFIG_INSTALL_DIR:STRING=/usr/local/lib/pkgconfig/
+
+//Path to a library.
+SDLMAIN_LIBRARY:FILEPATH=/usr/lib/x86_64-linux-gnu/libSDLmain.a
+
+//Path to a file.
+SDL_INCLUDE_DIR:PATH=/usr/include/SDL
+
+//Where the SDL Library can be found
+SDL_LIBRARY:STRING=/usr/lib/x86_64-linux-gnu/libSDLmain.a;/usr/lib/x86_64-linux-gnu/libSDL.so;-lpthread
+
+//Use RL-Glue
+USE_RLGLUE:BOOL=OFF
+
+//Use SDL
+USE_SDL:BOOL=ON
+
+//Dependencies for the target
+ale-c-lib_LIB_DEPENDS:STATIC=general;z;general;/usr/lib/x86_64-linux-gnu/libSDLmain.a;general;/usr/lib/x86_64-linux-gnu/libSDL.so;general;-lpthread;
+
+//Dependencies for the target
+ale-lib_LIB_DEPENDS:STATIC=general;z;general;/usr/lib/x86_64-linux-gnu/libSDLmain.a;general;/usr/lib/x86_64-linux-gnu/libSDL.so;general;-lpthread;
+
+//Value Computed by CMake
+ale_BINARY_DIR:STATIC=/home/elucterio/st500/enseignement/Code/Arcade-Learning-Environment/build
+
+//Value Computed by CMake
+ale_SOURCE_DIR:STATIC=/home/elucterio/st500/enseignement/Code/Arcade-Learning-Environment
+
+
+########################
+# INTERNAL cache entries
+########################
+
+//ADVANCED property for variable: CMAKE_AR
+CMAKE_AR-ADVANCED:INTERNAL=1
+//This is the directory where this CMakeCache.txt was created
+CMAKE_CACHEFILE_DIR:INTERNAL=/home/elucterio/st500/enseignement/Code/Arcade-Learning-Environment/build
+//Major version of cmake used to create the current loaded cache
+CMAKE_CACHE_MAJOR_VERSION:INTERNAL=3
+//Minor version of cmake used to create the current loaded cache
+CMAKE_CACHE_MINOR_VERSION:INTERNAL=5
+//Patch version of cmake used to create the current loaded cache
+CMAKE_CACHE_PATCH_VERSION:INTERNAL=1
+//ADVANCED property for variable: CMAKE_COLOR_MAKEFILE
+CMAKE_COLOR_MAKEFILE-ADVANCED:INTERNAL=1
+//Path to CMake executable.
+CMAKE_COMMAND:INTERNAL=/usr/bin/cmake
+//Path to cpack program executable.
+CMAKE_CPACK_COMMAND:INTERNAL=/usr/bin/cpack
+//Path to ctest program executable.
+CMAKE_CTEST_COMMAND:INTERNAL=/usr/bin/ctest
+//ADVANCED property for variable: CMAKE_CXX_COMPILER
+CMAKE_CXX_COMPILER-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS
+CMAKE_CXX_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS_DEBUG
+CMAKE_CXX_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS_MINSIZEREL
+CMAKE_CXX_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELEASE
+CMAKE_CXX_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELWITHDEBINFO
+CMAKE_CXX_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_COMPILER
+CMAKE_C_COMPILER-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS
+CMAKE_C_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS_DEBUG
+CMAKE_C_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS_MINSIZEREL
+CMAKE_C_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS_RELEASE
+CMAKE_C_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS_RELWITHDEBINFO
+CMAKE_C_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//Executable file format
+CMAKE_EXECUTABLE_FORMAT:INTERNAL=ELF
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS
+CMAKE_EXE_LINKER_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_DEBUG
+CMAKE_EXE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_MINSIZEREL
+CMAKE_EXE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELEASE
+CMAKE_EXE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO
+CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXPORT_COMPILE_COMMANDS
+CMAKE_EXPORT_COMPILE_COMMANDS-ADVANCED:INTERNAL=1
+//Name of external makefile project generator.
+CMAKE_EXTRA_GENERATOR:INTERNAL=
+//Name of generator.
+CMAKE_GENERATOR:INTERNAL=Unix Makefiles
+//Name of generator platform.
+CMAKE_GENERATOR_PLATFORM:INTERNAL=
+//Name of generator toolset.
+CMAKE_GENERATOR_TOOLSET:INTERNAL=
+//Have symbol pthread_create
+CMAKE_HAVE_LIBC_CREATE:INTERNAL=
+//Have library pthreads
+CMAKE_HAVE_PTHREADS_CREATE:INTERNAL=
+//Have library pthread
+CMAKE_HAVE_PTHREAD_CREATE:INTERNAL=1
+//Have include pthread.h
+CMAKE_HAVE_PTHREAD_H:INTERNAL=1
+//Source directory with the top level CMakeLists.txt file for this
+// project
+CMAKE_HOME_DIRECTORY:INTERNAL=/home/elucterio/st500/enseignement/Code/Arcade-Learning-Environment
+//Install .so files without execute permission.
+CMAKE_INSTALL_SO_NO_EXE:INTERNAL=1
+//ADVANCED property for variable: CMAKE_LINKER
+CMAKE_LINKER-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MAKE_PROGRAM
+CMAKE_MAKE_PROGRAM-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS
+CMAKE_MODULE_LINKER_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_DEBUG
+CMAKE_MODULE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL
+CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELEASE
+CMAKE_MODULE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO
+CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_NM
+CMAKE_NM-ADVANCED:INTERNAL=1
+//number of local generators
+CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=1
+//ADVANCED property for variable: CMAKE_OBJCOPY
+CMAKE_OBJCOPY-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_OBJDUMP
+CMAKE_OBJDUMP-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_RANLIB
+CMAKE_RANLIB-ADVANCED:INTERNAL=1
+//Path to CMake installation.
+CMAKE_ROOT:INTERNAL=/usr/share/cmake-3.5
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS
+CMAKE_SHARED_LINKER_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_DEBUG
+CMAKE_SHARED_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL
+CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELEASE
+CMAKE_SHARED_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO
+CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SKIP_INSTALL_RPATH
+CMAKE_SKIP_INSTALL_RPATH-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SKIP_RPATH
+CMAKE_SKIP_RPATH-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS
+CMAKE_STATIC_LINKER_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_DEBUG
+CMAKE_STATIC_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL
+CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELEASE
+CMAKE_STATIC_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO
+CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STRIP
+CMAKE_STRIP-ADVANCED:INTERNAL=1
+//uname command
+CMAKE_UNAME:INTERNAL=/bin/uname
+//ADVANCED property for variable: CMAKE_VERBOSE_MAKEFILE
+CMAKE_VERBOSE_MAKEFILE-ADVANCED:INTERNAL=1
+//Details about finding SDL
+FIND_PACKAGE_MESSAGE_DETAILS_SDL:INTERNAL=[/usr/lib/x86_64-linux-gnu/libSDLmain.a;/usr/lib/x86_64-linux-gnu/libSDL.so;-lpthread][/usr/include/SDL][v1.2.15()]
+//Details about finding Threads
+FIND_PACKAGE_MESSAGE_DETAILS_Threads:INTERNAL=[TRUE][v()]
+SDL_LIBRARY_TEMP:INTERNAL=/usr/lib/x86_64-linux-gnu/libSDLmain.a;/usr/lib/x86_64-linux-gnu/libSDL.so;-lpthread
+

ale/build/CMakeFiles/3.5.1/CMakeCCompiler.cmake

+set(CMAKE_C_COMPILER "/usr/bin/cc")
+set(CMAKE_C_COMPILER_ARG1 "")
+set(CMAKE_C_COMPILER_ID "GNU")
+set(CMAKE_C_COMPILER_VERSION "5.4.0")
+set(CMAKE_C_COMPILER_WRAPPER "")
+set(CMAKE_C_STANDARD_COMPUTED_DEFAULT "11")
+set(CMAKE_C_COMPILE_FEATURES "c_function_prototypes;c_restrict;c_variadic_macros;c_static_assert")
+set(CMAKE_C90_COMPILE_FEATURES "c_function_prototypes")
+set(CMAKE_C99_COMPILE_FEATURES "c_restrict;c_variadic_macros")
+set(CMAKE_C11_COMPILE_FEATURES "c_static_assert")
+
+set(CMAKE_C_PLATFORM_ID "Linux")
+set(CMAKE_C_SIMULATE_ID "")
+set(CMAKE_C_SIMULATE_VERSION "")
+
+set(CMAKE_AR "/usr/bin/ar")
+set(CMAKE_RANLIB "/usr/bin/ranlib")
+set(CMAKE_LINKER "/usr/bin/ld")
+set(CMAKE_COMPILER_IS_GNUCC 1)
+set(CMAKE_C_COMPILER_LOADED 1)
+set(CMAKE_C_COMPILER_WORKS TRUE)
+set(CMAKE_C_ABI_COMPILED TRUE)
+set(CMAKE_COMPILER_IS_MINGW )
+set(CMAKE_COMPILER_IS_CYGWIN )
+if(CMAKE_COMPILER_IS_CYGWIN)
+  set(CYGWIN 1)
+  set(UNIX 1)
+endif()
+
+set(CMAKE_C_COMPILER_ENV_VAR "CC")
+
+if(CMAKE_COMPILER_IS_MINGW)
+  set(MINGW 1)
+endif()
+set(CMAKE_C_COMPILER_ID_RUN 1)
+set(CMAKE_C_SOURCE_FILE_EXTENSIONS c;m)
+set(CMAKE_C_IGNORE_EXTENSIONS h;H;o;O;obj;OBJ;def;DEF;rc;RC)
+set(CMAKE_C_LINKER_PREFERENCE 10)
+
+# Save compiler ABI information.
+set(CMAKE_C_SIZEOF_DATA_PTR "8")
+set(CMAKE_C_COMPILER_ABI "ELF")
+set(CMAKE_C_LIBRARY_ARCHITECTURE "x86_64-linux-gnu")
+
+if(CMAKE_C_SIZEOF_DATA_PTR)
+  set(CMAKE_SIZEOF_VOID_P "${CMAKE_C_SIZEOF_DATA_PTR}")
+endif()
+
+if(CMAKE_C_COMPILER_ABI)
+  set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_C_COMPILER_ABI}")
+endif()
+
+if(CMAKE_C_LIBRARY_ARCHITECTURE)
+  set(CMAKE_LIBRARY_ARCHITECTURE "x86_64-linux-gnu")
+endif()
+
+set(CMAKE_C_CL_SHOWINCLUDES_PREFIX "")
+if(CMAKE_C_CL_SHOWINCLUDES_PREFIX)
+  set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_C_CL_SHOWINCLUDES_PREFIX}")
+endif()
+
+
+
+
+set(CMAKE_C_IMPLICIT_LINK_LIBRARIES "c")
+set(CMAKE_C_IMPLICIT_LINK_DIRECTORIES "/usr/lib/gcc/x86_64-linux-gnu/5;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib")
+set(CMAKE_C_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "")

ale/build/CMakeFiles/3.5.1/CMakeCXXCompiler.cmake

+set(CMAKE_CXX_COMPILER "/usr/bin/c++")
+set(CMAKE_CXX_COMPILER_ARG1 "")
+set(CMAKE_CXX_COMPILER_ID "GNU")
+set(CMAKE_CXX_COMPILER_VERSION "5.4.0")
+set(CMAKE_CXX_COMPILER_WRAPPER "")
+set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "98")
+set(CMAKE_CXX_COMPILE_FEATURES "cxx_template_template_parameters;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates")
+set(CMAKE_CXX98_COMPILE_FEATURES "cxx_template_template_parameters")
+set(CMAKE_CXX11_COMPILE_FEATURES "cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates")
+set(CMAKE_CXX14_COMPILE_FEATURES "cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates")
+
+set(CMAKE_CXX_PLATFORM_ID "Linux")
+set(CMAKE_CXX_SIMULATE_ID "")
+set(CMAKE_CXX_SIMULATE_VERSION "")
+
+set(CMAKE_AR "/usr/bin/ar")
+set(CMAKE_RANLIB "/usr/bin/ranlib")
+set(CMAKE_LINKER "/usr/bin/ld")
+set(CMAKE_COMPILER_IS_GNUCXX 1)
+set(CMAKE_CXX_COMPILER_LOADED 1)
+set(CMAKE_CXX_COMPILER_WORKS TRUE)
+set(CMAKE_CXX_ABI_COMPILED TRUE)
+set(CMAKE_COMPILER_IS_MINGW )
+set(CMAKE_COMPILER_IS_CYGWIN )
+if(CMAKE_COMPILER_IS_CYGWIN)
+  set(CYGWIN 1)
+  set(UNIX 1)
+endif()
+
+set(CMAKE_CXX_COMPILER_ENV_VAR "CXX")
+
+if(CMAKE_COMPILER_IS_MINGW)
+  set(MINGW 1)
+endif()
+set(CMAKE_CXX_COMPILER_ID_RUN 1)
+set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC)
+set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;mm;CPP)
+set(CMAKE_CXX_LINKER_PREFERENCE 30)
+set(CMAKE_CXX_LINKER_PREFERENCE_PROPAGATES 1)
+
+# Save compiler ABI information.
+set(CMAKE_CXX_SIZEOF_DATA_PTR "8")
+set(CMAKE_CXX_COMPILER_ABI "ELF")
+set(CMAKE_CXX_LIBRARY_ARCHITECTURE "x86_64-linux-gnu")
+
+if(CMAKE_CXX_SIZEOF_DATA_PTR)
+  set(CMAKE_SIZEOF_VOID_P "${CMAKE_CXX_SIZEOF_DATA_PTR}")
+endif()
+
+if(CMAKE_CXX_COMPILER_ABI)
+  set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CXX_COMPILER_ABI}")
+endif()
+
+if(CMAKE_CXX_LIBRARY_ARCHITECTURE)
+  set(CMAKE_LIBRARY_ARCHITECTURE "x86_64-linux-gnu")
+endif()
+
+set(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX "")
+if(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX)
+  set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_CXX_CL_SHOWINCLUDES_PREFIX}")
+endif()
+
+
+
+
+set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "stdc++;m;c")
+set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "/usr/lib/gcc/x86_64-linux-gnu/5;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib")
+set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "")

ale/build/CMakeFiles/3.5.1/CMakeSystem.cmake

+set(CMAKE_HOST_SYSTEM "Linux-4.4.0-124-generic")
+set(CMAKE_HOST_SYSTEM_NAME "Linux")
+set(CMAKE_HOST_SYSTEM_VERSION "4.4.0-124-generic")
+set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64")
+
+
+
+set(CMAKE_SYSTEM "Linux-4.4.0-124-generic")
+set(CMAKE_SYSTEM_NAME "Linux")
+set(CMAKE_SYSTEM_VERSION "4.4.0-124-generic")
+set(CMAKE_SYSTEM_PROCESSOR "x86_64")
+
+set(CMAKE_CROSSCOMPILING "FALSE")
+
+set(CMAKE_SYSTEM_LOADED 1)